Changeset 1107 for XIOS/trunk

Timestamp:

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

Author:

mhnguyen

Message:

Clean up some compilation warnings

Location:

XIOS/trunk/src

Files:

• attribute.cpp (modified) (3 diffs)
• attribute_array.hpp (modified) (3 diffs)
• attribute_enum.hpp (modified) (2 diffs)
• type/enum.hpp (modified) (1 diff)
• type/type.hpp (modified) (2 diffs)
• type/type_decl.cpp (modified) (1 diff)

XIOS/trunk/src/attribute.cpp

@@ -12 +12 @@
       { /* Ne rien faire de plus */ }
 /*
-      CAttribute::CAttribute(const CAttribute & attribut)
-         : CObject(attribut.getId()),CBaseType()
-      { 
- //        this->value = attribut.getAnyValue(); 
-      }
 */      
       CAttribute::~CAttribute(void)
@@ -22 +17 @@
       
       ///--------------------------------------------------------------
-/*
-      const boost::any & CAttribute::getAnyValue(void) const
-      { 
-         return (this->value); 
-      }
 
-
-      void CAttribute::setAnyValue(const boost::any & value)
-      { 
-         this->value = value; 
-      }
-      
-      void CAttribute::clear(void)
-      {
-         this->value = boost::any(); 
-      }
-
-      //---------------------------------------------------------------
-
-      bool CAttribute::isEmpty(void) const
-      { 
-         return (this->value.empty()); 
-      }
-*/
       const StdString & CAttribute::getName(void) const
       { 
@@ -79 +51 @@
       ///--------------------------------------------------------------
 
-
       CMessage& operator<<(CMessage& msg,CAttribute& type)
       {

XIOS/trunk/src/attribute_array.hpp

@@ -13 +13 @@
 {
       /// ////////////////////// Déclarations ////////////////////// ///
+      /*!
+        \class CAttributeArray
+        This class implements the attribute representing array of value
+      */
       template <typename T_numtype, int N_rank>
          class CAttributeArray : public CAttribute, public CArray<T_numtype, N_rank>
@@ -19 +23 @@
 
            using CArray<T_numtype,N_rank>::operator = ;
-//           using Array<T_numtype,N_rank>::operator = ;
 
             /// Constructeurs ///
@@ -63 +66 @@
             virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) ;
 
-
-         protected :
-
-            /// Constructeurs ///
-
          private :
           CArray<T_numtype, N_rank> inheritedValue ;

XIOS/trunk/src/attribute_enum.hpp

@@ -15 +15 @@
 {
       /// ////////////////////// Déclarations ////////////////////// ///
+        /*!
+        \class CAttributeEnum
+        This class implements the attribute representing enumeration
+      */
       template <class T>
          class CAttributeEnum : public CAttribute, public CEnum<T>
@@ -70 +74 @@
             virtual void generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) ;
             virtual void generateFortranInterfaceGetBody_(ostream& oss,const string& className) ;
-            virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) ;
+            virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) ;      
 
-      
-         protected :
-
-            /// Constructeurs ///
-//            CAttributeTemplate(void); // Not implemented.
          private :
           StdString _toString(void) const;

XIOS/trunk/src/type/enum.hpp

@@ -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> 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) ;

XIOS/trunk/src/type/type.hpp

@@ -128 +128 @@
   } ;
 
-  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> 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>
-  inline bool operator==(const CType_ref<T>& lhs, const CType<T>& rhs)
+  bool operator==(const CType_ref<T>& lhs, const CType<T>& rhs)
   {
     if ((lhs.isEmpty() && !rhs.isEmpty()) || (!lhs.isEmpty() && rhs.isEmpty())) return false;
@@ -143 +144 @@
 
   template <typename T>
-  inline bool operator==(const CType<T>& lhs, const CType_ref<T>& rhs)
+  bool operator==(const CType<T>& lhs, const CType_ref<T>& rhs)
   {
     return (rhs == lhs);

XIOS/trunk/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 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 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);