Changeset 1158 for XIOS/dev/dev_olga/src/type

Timestamp:

06/06/17 17:58:16 (7 years ago)

Author:

oabramkina

Message:

Two server levels: merging with trunk r1137.
There are bugs.

Location:

XIOS/dev/dev_olga/src/type

Files:

• enum.hpp (modified) (2 diffs)
• enum_impl.hpp (modified) (1 diff)
• enum_ref_impl.hpp (modified) (1 diff)
• message.cpp (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/dev/dev_olga/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> bool operator== (const CEnum<T>& lhs, const typename T::t_enum& rhs);
+  template <typename T> bool operator== (const typename T::t_enum& lhs, const CEnum<T>& rhs);
+  template <typename T> bool operator== (const CEnum<T>& lhs, const CEnum<T>& rhs);  
+  template <typename T> bool operator== (const CEnum_ref<T>& lhs, const CEnum_ref<T>& rhs);
+  template <typename T> bool operator== (const CEnum_ref<T>& lhs, const typename T::t_enum& rhs);
+  template <typename T> bool operator== (const typename T::t_enum& lhs, const CEnum_ref<T>& rhs);
+  template <typename T> bool operator== (const CEnum<T>& lhs, const CEnum_ref<T>& rhs) {return (lhs.get() == rhs.get());}
+  template <typename T> 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/dev/dev_olga/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/dev/dev_olga/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/dev/dev_olga/src/type/message.cpp

@@ -27 +27 @@
      size_t retSize=0 ;
      
-     for(it=typeList.begin();it!=typeList.end();it++)
-         retSize+=(*it)->size() ;
+     for(it=typeList.begin();it!=typeList.end();it++) retSize+=(*it)->size() ;
      return retSize ;
    }

XIOS/dev/dev_olga/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> bool operator==(const CType<T>& lhs, const T& rhs);   
+  template <typename T> bool operator==(const T& lhs, const CType<T>& rhs);   
+  template <typename T> bool operator==(const CType_ref<T>& lhs, const T& rhs);   
+  template <typename T> bool operator==(const T& lhs, const CType_ref<T>& rhs); 
+  template <typename T> bool operator==(const CType<T>& lhs, const CType<T>& rhs); 
+  template <typename T> bool operator==(const CType_ref<T>& lhs, const CType_ref<T>& rhs); 
+
+  template <typename T>
+  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>
+  bool operator==(const CType<T>& lhs, const CType_ref<T>& rhs)
+  {
+    return (rhs == lhs);
+  }
 
 

XIOS/dev/dev_olga/src/type/type_decl.cpp

@@ -12 +12 @@
   template class CType<decl_type> ; \
   template class CType_ref<decl_type> ; \
-  template CBufferOut& operator<< <decl_type> (CBufferOut& buffer, const CType<decl_type>& type) ; \
-  template CBufferOut& operator<< <decl_type> (CBufferOut& buffer, const CType_ref<decl_type>& type) ; \
-  template CBufferOut& operator<< <decl_type> (CBufferOut& buffer, decl_type& type) ; \
-  template CBufferOut& operator<< <decl_type> (CBufferOut& buffer, const decl_type& type) ; \
-  template CBufferIn& operator>> <decl_type> (CBufferIn& buffer, CType<decl_type>& type) ; \
-  template CBufferIn& operator>> <decl_type> (CBufferIn& buffer, const CType_ref<decl_type>& type) ; \
-  template CBufferIn& operator>> <decl_type> (CBufferIn& buffer, decl_type& type) ; \
-/*  template CMessage& operator<< <decl_type> (CMessage& msg, const CType<decl_type>& type) ;*/ \
-/*  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 CBufferOut& operator<< <decl_type> (CBufferOut& buffer, const CType<decl_type>& type) ;       \
+  template CBufferOut& operator<< <decl_type> (CBufferOut& buffer, const CType_ref<decl_type>& type) ;   \
+  template CBufferOut& operator<< <decl_type> (CBufferOut& buffer, decl_type& type) ;                    \
+  template CBufferOut& operator<< <decl_type> (CBufferOut& buffer, const decl_type& type) ;              \
+  template CBufferIn& operator>> <decl_type> (CBufferIn& buffer, CType<decl_type>& type) ;               \
+  template CBufferIn& operator>> <decl_type> (CBufferIn& buffer, const CType_ref<decl_type>& type) ;     \
+  template CBufferIn& operator>> <decl_type> (CBufferIn& buffer, decl_type& type) ;                      \
+/*  template CMessage& operator<< <decl_type> (CMessage& msg, const CType<decl_type>& type) ;*/          \
+/*  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 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<decl_type>& lhs, const CType<decl_type>& rhs);                    \
+  template bool operator==(const CType_ref<decl_type>& lhs, const CType_ref<decl_type>& rhs);    
   
   macro(string)

XIOS/dev/dev_olga/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/dev/dev_olga/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>