[lmi-commits] [lmi] valyuta/002 ba6a8d1 31/65: implement currency comparisons as free functions

[Greg Chicares]

branch: valyuta/002
commit ba6a8d10c2bb8d565e839fbd715f0d663f925eac
Author: Gregory W. Chicares <gchicares@sbcglobal.net>
Commit: Gregory W. Chicares <gchicares@sbcglobal.net>

    implement currency comparisons as free functions
---
 currency.hpp | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/currency.hpp b/currency.hpp
index df93967..9c5c2b3 100644
--- a/currency.hpp
+++ b/currency.hpp
@@ -74,6 +74,7 @@ class currency
     operator double() const {return to_double();}
     double d() const {return to_double();}
 
+#if 0
     // Is this better, with 'const&'?
 //  bool operator==(currency const& z) const {return z.m_ == m_;}
 
@@ -90,6 +91,7 @@ class currency
     bool operator!=(double d) const {return to_double() != d;}
     bool operator> (double d) const {return to_double() >  d;}
     bool operator>=(double d) const {return to_double() >= d;}
+#endif // 0
 
     // Is this the ideal signature for this operator?
 //  currency operator-() const {return currency(-m_);}
@@ -144,6 +146,45 @@ class currency
     data_type m_ = {0};
 };
 
+inline bool operator==(currency const& lhs, currency const& rhs){return 
lhs.m() == rhs.m();}
+inline bool operator< (currency const& lhs, currency const& rhs){return 
lhs.m() <  rhs.m();}
+inline bool operator!=(currency const& lhs, currency const& rhs){return 
!operator==(lhs,rhs);}
+inline bool operator> (currency const& lhs, currency const& rhs){return  
operator< (rhs,lhs);}
+inline bool operator<=(currency const& lhs, currency const& rhs){return 
!operator> (lhs,rhs);}
+inline bool operator>=(currency const& lhs, currency const& rhs){return 
!operator< (lhs,rhs);}
+
+inline bool operator==(currency const& lhs, int      const& rhs){return 
lhs.m() == rhs;}
+inline bool operator< (currency const& lhs, int      const& rhs){return 
lhs.m() <  rhs;}
+inline bool operator==(int      const& lhs, currency const& rhs){return lhs == 
rhs.m();}
+inline bool operator< (int      const& lhs, currency const& rhs){return lhs <  
rhs.m();}
+
+inline bool operator!=(currency const& lhs, int      const& rhs){return 
!operator==(lhs,rhs);}
+inline bool operator> (currency const& lhs, int      const& rhs){return  
operator< (rhs,lhs);}
+inline bool operator<=(currency const& lhs, int      const& rhs){return 
!operator> (lhs,rhs);}
+inline bool operator>=(currency const& lhs, int      const& rhs){return 
!operator< (lhs,rhs);}
+
+inline bool operator!=(int      const& lhs, currency const& rhs){return 
!operator==(lhs,rhs);}
+inline bool operator> (int      const& lhs, currency const& rhs){return  
operator< (rhs,lhs);}
+inline bool operator<=(int      const& lhs, currency const& rhs){return 
!operator> (lhs,rhs);}
+inline bool operator>=(int      const& lhs, currency const& rhs){return 
!operator< (lhs,rhs);}
+
+// double--avoid these:
+
+inline bool operator==(currency const& lhs, double   const& rhs){return 
lhs.d() == rhs;}
+inline bool operator< (currency const& lhs, double   const& rhs){return 
lhs.d() <  rhs;}
+inline bool operator==(double   const& lhs, currency const& rhs){return lhs == 
rhs.d();}
+inline bool operator< (double   const& lhs, currency const& rhs){return lhs <  
rhs.d();}
+
+inline bool operator!=(currency const& lhs, double   const& rhs){return 
!operator==(lhs,rhs);}
+inline bool operator> (currency const& lhs, double   const& rhs){return  
operator< (rhs,lhs);}
+inline bool operator<=(currency const& lhs, double   const& rhs){return 
!operator> (lhs,rhs);}
+inline bool operator>=(currency const& lhs, double   const& rhs){return 
!operator< (lhs,rhs);}
+
+inline bool operator!=(double   const& lhs, currency const& rhs){return 
!operator==(lhs,rhs);}
+inline bool operator> (double   const& lhs, currency const& rhs){return  
operator< (rhs,lhs);}
+inline bool operator<=(double   const& lhs, currency const& rhs){return 
!operator> (lhs,rhs);}
+inline bool operator>=(double   const& lhs, currency const& rhs){return 
!operator< (lhs,rhs);}
+
 inline currency operator+(currency lhs, currency rhs) {return lhs += rhs;}
 inline currency operator-(currency lhs, currency rhs) {return lhs -= rhs;}
 inline currency operator+(currency lhs, double rhs) {return lhs += 
currency(rhs);}