Changeset 1105 for XIOS/trunk/src/type

Timestamp:

04/25/17 10:57:48 (7 years ago)

Author:

mhnguyen

Message:

Adding comparison operator between objects of XIOS.
Two objects of a same type are considered equal if they have same non-empty
attributes which have same values

+) Add operator== to class CArray
+) Add comparison operator to some basic attribute classes
+) Add operator== to date and duration (It seems that they don't serve much)

Test
+) On Curie
+) No Unit tests but test with transformation work (the next commit)

Location:

XIOS/trunk/src/type

Files:

• enum.hpp (modified) (2 diffs)
• enum_impl.hpp (modified) (1 diff)
• enum_ref_impl.hpp (modified) (1 diff)
• type.hpp (modified) (2 diffs)
• type_decl.cpp (modified) (1 diff)
• type_impl.hpp (modified) (1 diff)
• type_ref_impl.hpp (modified) (1 diff)

XIOS/trunk/src/type/enum.hpp

@@ -100 +100 @@
     __INLINE__ const CEnum_ref& operator = (const CEnum_ref& val) const;
     __INLINE__ operator T_enum&() const;
-    bool operator == (const CEnum_ref &other) {return this->get()==other.get() ;}
+    
 
     inline virtual CBaseType* clone(void) const   { return _clone(); }
@@ -134 +134 @@
   } ;
   
+  template <typename T> __INLINE__ bool operator== (const CEnum<T>& lhs, const typename T::t_enum& rhs);
+  template <typename T> __INLINE__ bool operator== (const typename T::t_enum& lhs, const CEnum<T>& rhs);
+  template <typename T> __INLINE__ bool operator== (const CEnum<T>& lhs, const CEnum<T>& rhs);  
+  template <typename T> __INLINE__ bool operator== (const CEnum_ref<T>& lhs, const CEnum_ref<T>& rhs);
+  template <typename T> __INLINE__ bool operator== (const CEnum_ref<T>& lhs, const typename T::t_enum& rhs);
+  template <typename T> __INLINE__ bool operator== (const typename T::t_enum& lhs, const CEnum_ref<T>& rhs);
+  template <typename T> __INLINE__ bool operator== (const CEnum<T>& lhs, const CEnum_ref<T>& rhs) {return (lhs.get() == rhs.get());}
+  template <typename T> __INLINE__ bool operator== (const CEnum_ref<T>& lhs, const CEnum<T>& rhs) {return (rhs == lhs); }
+
   template <typename T> __INLINE__ CBufferOut& operator<<(CBufferOut& buffer, const CEnum<T>& type) ;
   template <typename T> __INLINE__ CBufferOut& operator<<(CBufferOut& buffer, const typename T::t_enum & type) ;  

XIOS/trunk/src/type/enum_impl.hpp

@@ -249 +249 @@
                      << "Enum is not initialized.");
   }  
-
-  
+  
+  template <typename T> 
+  bool operator== (const CEnum<T>& lhs, const typename T::t_enum& rhs)
+  {
+     if (lhs.isEmpty()) return false;
+     return (lhs.get() == rhs);
+  }
+
+  template <typename T> 
+  bool operator== (const typename T::t_enum& lhs, const CEnum<T>& rhs)
+  {
+    return rhs == lhs;
+  }
+
+  template <typename T> 
+  bool operator== (const CEnum<T>& lhs, const CEnum<T>& rhs)
+  {
+    if ((lhs.isEmpty() && !rhs.isEmpty()) || (!lhs.isEmpty() && rhs.isEmpty())) return false;
+    if (lhs.isEmpty() && rhs.isEmpty()) return true;
+    return (lhs.get() == rhs.get());
+  }
+
+
   template <typename T>
   CBufferOut& operator<<(CBufferOut& buffer, const CEnum<T>& type)

XIOS/trunk/src/type/enum_ref_impl.hpp

@@ -263 +263 @@
   }
                      
-
+  template <typename T> 
+  bool operator== (const CEnum_ref<T>& lhs, const typename T::t_enum& rhs)
+  {
+     if (lhs.isEmpty()) return false;
+     return (lhs.get() == rhs);
+  }
+
+  template <typename T> 
+  bool operator== (const typename T::t_enum& lhs, const CEnum_ref<T>& rhs)
+  {
+    return rhs == lhs;
+  }
+
+  template <typename T> 
+  bool operator== (const CEnum_ref<T>& lhs, const CEnum_ref<T>& rhs)
+  {
+    if ((lhs.isEmpty() && !rhs.isEmpty()) || (!lhs.isEmpty() && rhs.isEmpty())) return false;
+    if (lhs.isEmpty() && rhs.isEmpty()) return true;
+    return (lhs.get() == rhs.get());
+  }
   
   template <typename T>

XIOS/trunk/src/type/type.hpp

@@ -94 +94 @@
     const CType_ref& operator = (CType<T>& val) const ;
     const CType_ref& operator = (const CType_ref& val) const;
-    operator T&() const;
+    operator T&() const;    
 
     inline virtual CBaseType* clone(void) const   { return _clone(); }
@@ -127 +127 @@
     size_t _size(void) const ;
   } ;
+
+  template <typename T> inline bool operator==(const CType<T>& lhs, const T& rhs);   
+  template <typename T> inline bool operator==(const T& lhs, const CType<T>& rhs);   
+  template <typename T> inline bool operator==(const CType_ref<T>& lhs, const T& rhs);   
+  template <typename T> inline bool operator==(const T& lhs, const CType_ref<T>& rhs); 
+  template <typename T> inline bool operator==(const CType_ref<T>& lhs, const CType_ref<T>& rhs); 
+
+  template <typename T>
+  inline bool operator==(const CType_ref<T>& lhs, const CType<T>& rhs)
+  {
+    if ((lhs.isEmpty() && !rhs.isEmpty()) || (!lhs.isEmpty() && rhs.isEmpty())) return false;
+    if (lhs.isEmpty() && rhs.isEmpty()) return true;
+    return (*lhs.ptrValue == *rhs.ptrValue);
+  } 
+
+  template <typename T>
+  inline bool operator==(const CType<T>& lhs, const CType_ref<T>& rhs)
+  {
+    return (rhs == lhs);
+  }
 
 

XIOS/trunk/src/type/type_decl.cpp

@@ -22 +22 @@
 /*  template CMessage& operator<< <decl_type> (CMessage& msg, const CType_ref<decl_type>& type) ;*/ \
   template CMessage& operator<< <decl_type> (CMessage& msg, const decl_type& type) ; \
-  template CMessage& operator<< <decl_type> (CMessage& msg, decl_type& type) ;
+  template CMessage& operator<< <decl_type> (CMessage& msg, decl_type& type) ;       \    
+  template bool operator==(const CType<decl_type>& lhs, const decl_type& rhs);                 \          
+  template bool operator==(const decl_type& lhs, const CType<decl_type>& rhs);                \
+  template bool operator==(const CType_ref<decl_type>& lhs, const decl_type& rhs);             \
+  template bool operator==(const decl_type& lhs, const CType_ref<decl_type>& rhs);             \
+  template bool operator==(const CType_ref<decl_type>& lhs, const CType<decl_type>& rhs);      \
+  template bool operator==(const CType<decl_type>& lhs, const CType_ref<decl_type>& rhs);     \
+  template bool operator==(const CType_ref<decl_type>& lhs, const CType_ref<decl_type>& rhs);    
   
   macro(string)

XIOS/trunk/src/type/type_impl.hpp

@@ -211 +211 @@
   }
 
+  template <typename T>
+  bool operator==(const CType<T>& lhs, const T& rhs)
+  {
+    if (lhs.isEmpty()) return false;
+    return (*lhs.ptrValue == rhs);    
+  }
+
+  template <typename T>
+  bool operator==(const T& lhs, const CType<T>& rhs)
+  {
+    return (rhs == lhs);
+  }
+
+  template <typename T>
+  bool operator==(const CType<T>& lhs, const CType<T>& rhs)
+  {
+    if ((lhs.isEmpty() && !rhs.isEmpty()) || (!lhs.isEmpty() && rhs.isEmpty())) return false;
+    if (lhs.isEmpty() && rhs.isEmpty()) return true;
+    
+    return (*lhs.ptrValue == *rhs.ptrValue);
+  }
 
   template <typename T>

XIOS/trunk/src/type/type_ref_impl.hpp

@@ -201 +201 @@
   }
                      
-
+  template <typename T>
+  bool operator==(const CType_ref<T>& lhs, const T& rhs)
+  {
+    if (lhs.isEmpty()) return false;
+    return (*lhs.ptrValue == rhs);    
+  }
+
+  template <typename T>
+  bool operator==(const T& lhs, const CType_ref<T>& rhs)
+  {
+    return (rhs == lhs);
+  }
+
+  template <typename T>
+  bool operator==(const CType_ref<T>& lhs, const CType_ref<T>& rhs)
+  {
+    if ((lhs.isEmpty() && !rhs.isEmpty()) || (!lhs.isEmpty() && rhs.isEmpty())) return false;
+    if (lhs.isEmpty() && rhs.isEmpty()) return true;
+    
+    return (*lhs.ptrValue == *rhs.ptrValue);
+  }
   
   template <typename T>