Changeset 432

Timestamp:

06/03/13 11:21:19 (11 years ago)

Author:

ymipsl

Message:

Enhancement : Add fortran interface to know if an attribute is set or not
ex : CALL xios_is_defined_field_attr("field_A",enabled=ok)

YM

Location:

XIOS/trunk/src

Files:

• attribute.cpp (modified) (3 diffs)
• attribute.hpp (modified) (2 diffs)
• attribute_map.cpp (modified) (5 diffs)
• attribute_map.hpp (modified) (1 diff)
• attribute_template.hpp (modified) (1 diff)
• attribute_template_impl.hpp (modified) (4 diffs)
• generate_interface.hpp (modified) (3 diffs)
• generate_interface_impl.hpp (modified) (16 diffs)
• interface/c_attr/icaxis_attr.cpp (modified) (10 diffs)
• interface/c_attr/icaxisgroup_attr.cpp (modified) (11 diffs)
• interface/c_attr/iccontext_attr.cpp (modified) (5 diffs)
• interface/c_attr/icdomain_attr.cpp (modified) (31 diffs)
• interface/c_attr/icdomaingroup_attr.cpp (modified) (32 diffs)
• interface/c_attr/icfield_attr.cpp (modified) (15 diffs)
• interface/c_attr/icfieldgroup_attr.cpp (modified) (16 diffs)
• interface/c_attr/icfile_attr.cpp (modified) (11 diffs)
• interface/c_attr/icfilegroup_attr.cpp (modified) (12 diffs)
• interface/c_attr/icgrid_attr.cpp (modified) (5 diffs)
• interface/c_attr/icgridgroup_attr.cpp (modified) (6 diffs)
• interface/fortran/ixios.F90 (modified) (8 diffs)
• interface/fortran_attr/axis_interface_attr.f90 (modified) (10 diffs)
• interface/fortran_attr/axisgroup_interface_attr.f90 (modified) (11 diffs)
• interface/fortran_attr/context_interface_attr.f90 (modified) (5 diffs)
• interface/fortran_attr/domain_interface_attr.f90 (modified) (31 diffs)
• interface/fortran_attr/domaingroup_interface_attr.f90 (modified) (32 diffs)
• interface/fortran_attr/field_interface_attr.f90 (modified) (15 diffs)
• interface/fortran_attr/fieldgroup_interface_attr.f90 (modified) (16 diffs)
• interface/fortran_attr/file_interface_attr.f90 (modified) (11 diffs)
• interface/fortran_attr/filegroup_interface_attr.f90 (modified) (12 diffs)
• interface/fortran_attr/grid_interface_attr.f90 (modified) (5 diffs)
• interface/fortran_attr/gridgroup_interface_attr.f90 (modified) (6 diffs)
• interface/fortran_attr/iaxis_attr.F90 (modified) (1 diff)
• interface/fortran_attr/iaxisgroup_attr.F90 (modified) (1 diff)
• interface/fortran_attr/icontext_attr.F90 (modified) (1 diff)
• interface/fortran_attr/idomain_attr.F90 (modified) (1 diff)
• interface/fortran_attr/idomaingroup_attr.F90 (modified) (1 diff)
• interface/fortran_attr/ifield_attr.F90 (modified) (1 diff)
• interface/fortran_attr/ifieldgroup_attr.F90 (modified) (1 diff)
• interface/fortran_attr/ifile_attr.F90 (modified) (19 diffs)
• interface/fortran_attr/ifilegroup_attr.F90 (modified) (19 diffs)
• interface/fortran_attr/igrid_attr.F90 (modified) (1 diff)
• interface/fortran_attr/igridgroup_attr.F90 (modified) (1 diff)
• object_template_impl.hpp (modified) (1 diff)
• test/test_client.f90 (modified) (2 diffs)

XIOS/trunk/src/attribute.cpp

@@ -1 +1 @@
 #include "attribute.hpp"
 #include "base_type.hpp"
+#include "generate_interface.hpp"
+
 
 namespace xios
@@ -48 +50 @@
          return (this->getId()); 
       }
+   
+      void CAttribute::generateCInterfaceIsDefined(ostream& oss, const string& className)
+      {
+        CInterface::AttributeIsDefinedCInterface(oss, className, this->getName()) ;
+      }
       
+      void CAttribute::generateFortran2003InterfaceIsDefined(ostream& oss, const string& className)
+      {
+        CInterface::AttributeIsDefinedFortran2003Interface(oss, className, this->getName()) ;
+      }
+      
+      
+      void CAttribute::generateFortranInterfaceIsDefinedDeclaration_(ostream& oss,const string& className)
+      {
+        CInterface::AttributeFortranInterfaceIsDefinedDeclaration(oss, className, this->getName()+"_") ;
+      }
+
+      void CAttribute::generateFortranInterfaceIsDefinedDeclaration(ostream& oss,const string& className)
+      {
+        CInterface::AttributeFortranInterfaceIsDefinedDeclaration(oss, className, this->getName()) ;
+      }
+
+      void CAttribute::generateFortranInterfaceIsDefinedBody_(ostream& oss,const string& className)
+      {
+        CInterface::AttributeFortranInterfaceIsDefinedBody(oss, className, this->getName()) ;
+      }
 
       ///--------------------------------------------------------------
@@ -81 +108 @@
      }
 
+ 
 } // namespace xios

XIOS/trunk/src/attribute.hpp

@@ -53 +53 @@
 
             virtual void generateCInterface(ostream& oss, const string& className) = 0 ;
+            virtual void generateCInterfaceIsDefined(ostream& oss, const string& className) ;
             virtual void generateFortran2003Interface(ostream& oss, const string& className) = 0 ;
+            virtual void generateFortran2003InterfaceIsDefined(ostream& oss, const string& className) ;
             virtual void generateFortranInterfaceDeclaration_(ostream& oss,const string& className) = 0 ;
             virtual void generateFortranInterfaceDeclaration(ostream& oss,const string& className) = 0 ;
@@ -60 +62 @@
             virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) = 0 ;
             virtual void generateFortranInterfaceGetBody_(ostream& oss,const string& className) = 0 ;
+            virtual void generateFortranInterfaceIsDefinedDeclaration_(ostream& oss,const string& className) ;
+            virtual void generateFortranInterfaceIsDefinedDeclaration(ostream& oss,const string& className)  ;
+            virtual void generateFortranInterfaceIsDefinedBody_(ostream& oss,const string& className) ;
 
 

XIOS/trunk/src/attribute_map.cpp

@@ -191 +191 @@
          {
            it->second->generateCInterface(oss,className) ;
+           it->second->generateCInterfaceIsDefined(oss,className) ;
            oss<<iendl<<iendl ;
          }
@@ -201 +202 @@
          {
            it->second->generateFortran2003Interface(oss,className) ;
+           it->second->generateFortran2003InterfaceIsDefined(oss,className) ;
+          
            oss<<iendl<<iendl ;
          }
@@ -299 +302 @@
          oss<<"END SUBROUTINE xios(get_"<<className<<"_attr_hdl_)"<<iendl ;
          
-      }      
+      }     
+      
+
+      void CAttributeMap::generateFortranInterfaceIsDefined_hdl_(ostream& oss, const string& className)
+      {
+         oss<<"SUBROUTINE xios(is_defined_"<<className<<"_attr_hdl_)   &"<<iendl++ ;
+         ostringstream* oss2 ;
+         SuperClassMap::const_iterator it ;
+         SuperClassMap::const_iterator begin = SuperClassMap::begin(), end = SuperClassMap::end();
+         
+         oss2=new ostringstream ;
+         
+         *oss2<<"( "<<className<<"_hdl"  ;
+         
+         for ( it=begin ; it != end; it++) 
+         {
+           *oss2<<", "<<it->second->getName()<<"_" ;
+           if (oss2->str().size()>90) 
+           {
+             oss<<oss2->str()<<"  &"<<iendl ;
+             delete oss2 ;
+             oss2=new ostringstream ;
+           }
+         }
+         *oss2<<" )" ;
+         oss<<oss2->str()<<iendl ;
+         oss<<iendl ;
+         delete oss2 ; 
+         
+         oss<<"IMPLICIT NONE"<<iendl++ ;
+         oss<<"TYPE(txios("<<className<<")) , INTENT(IN) :: "<<className<<"_hdl"<<iendl ;
+         
+         for (it=begin; it != end; it++)
+         {
+           it->second->generateFortranInterfaceIsDefinedDeclaration_(oss,className) ;
+         }
+         
+         oss<<iendl ;
+         
+         for (it=begin; it != end; it++)
+         {
+           it->second->generateFortranInterfaceIsDefinedBody_(oss,className) ;
+           oss<<iendl ;
+         }
+         
+         oss<<iendl--<<iendl-- ;
+         oss<<"END SUBROUTINE xios(is_defined_"<<className<<"_attr_hdl_)"<<iendl ;
+         
+      }      
+       
 
       void CAttributeMap::generateFortranInterface_hdl(ostream& oss, const string& className)
@@ -413 +465 @@
          oss<<"END SUBROUTINE xios(get_"<<className<<"_attr_hdl)"<<iendl ;
       }      
+
+
+      void CAttributeMap::generateFortranInterfaceIsDefined_hdl(ostream& oss, const string& className)
+      {
+         oss<<"SUBROUTINE xios(is_defined_"<<className<<"_attr_hdl)  &"<<iendl++ ;
+         ostringstream* oss2 ;
+         SuperClassMap::const_iterator it ;
+         SuperClassMap::const_iterator begin = SuperClassMap::begin(), end = SuperClassMap::end();
+         
+         oss2=new ostringstream ;
+         *oss2<<"( "<<className<<"_hdl"  ;
+         for ( it=begin ; it != end; it++) 
+         {
+           *oss2<<", "<<it->second->getName() ;
+           if (oss2->str().size()>90) 
+           {
+             oss<<oss2->str()<<"  &"<<iendl ;
+             delete oss2 ;
+             oss2=new ostringstream ;
+           }
+         }
+         *oss2<<" )" ;
+         oss<<oss2->str()<<iendl ;
+         oss<<iendl ;
+         delete oss2 ; 
+         oss2=new ostringstream ;
+         
+         oss<<"IMPLICIT NONE"<<iendl++ ;
+         oss<<"TYPE(txios("<<className<<")) , INTENT(IN) :: "<<className<<"_hdl"<<iendl ;
+         
+         for (it=begin; it != end; it++)
+         {
+           it->second->generateFortranInterfaceIsDefinedDeclaration(oss,className) ;
+         }
+         
+         oss<<iendl ;
+         
+         oss<<"CALL xios(is_defined_"<<className<<"_attr_hdl_)  &"<<iendl ;
+         
+         *oss2<<"( "<<className<<"_hdl"  ;
+         for ( it=begin ; it != end; it++) 
+         {
+           *oss2<<", "<<it->second->getName() ;
+           if (oss2->str().size()>90) 
+           {
+             oss<<oss2->str()<<"  &"<<iendl ;
+             delete oss2 ;
+             oss2=new ostringstream ;
+           }
+         }
+         *oss2<<" )" ;
+         oss<<oss2->str() ;
+         delete oss2 ; 
+         
+         oss<<iendl--<<iendl-- ;
+         oss<<"END SUBROUTINE xios(is_defined_"<<className<<"_attr_hdl)"<<iendl ;
+      }      
+
       
       void CAttributeMap::generateFortranInterface_id(ostream& oss, const string& className)
@@ -529 +639 @@
          
       }      
+      
+      void CAttributeMap::generateFortranInterfaceIsDefined_id(ostream& oss, const string& className)
+      {
+         oss<<"SUBROUTINE xios(is_defined_"<<className<<"_attr)  &"<<iendl++ ;
+         ostringstream* oss2 ;
+         SuperClassMap::const_iterator it ;
+         SuperClassMap::const_iterator begin = SuperClassMap::begin(), end = SuperClassMap::end();
+         
+         oss2=new ostringstream ;
+         *oss2<<"( "<<className<<"_id"  ;
+         for ( it=begin ; it != end; it++) 
+         {
+           *oss2<<", "<<it->second->getName() ;
+           if (oss2->str().size()>90) 
+           {
+             oss<<oss2->str()<<"  &"<<iendl ;
+             delete oss2 ;
+             oss2=new ostringstream ;
+           }
+         }
+         *oss2<<" )" ;
+         oss<<oss2->str()<<iendl ;
+         oss<<iendl ;
+         delete oss2 ; 
+         oss2=new ostringstream ;
+         
+         oss<<"IMPLICIT NONE"<<iendl++ ;
+
+         oss<<"TYPE(txios("<<className<<"))  :: "<<className<<"_hdl"<<iendl ;
+         oss<<"CHARACTER(LEN=*), INTENT(IN) ::"<<className<<"_id"<<iendl ;
+         
+         for (it=begin; it != end; it++)
+         {
+           it->second->generateFortranInterfaceIsDefinedDeclaration(oss,className) ;
+         }
+         
+         oss<<iendl ;
+         oss<<"CALL xios(get_"<<className<<"_handle)("<<className<<"_id,"<<className<<"_hdl)"<<iendl ; 
+         oss<<"CALL xios(is_defined_"<<className<<"_attr_hdl_)   &"<<iendl ;
+         *oss2<<"( "<<className<<"_hdl"  ;
+         for ( it=begin ; it != end; it++) 
+         {
+           *oss2<<", "<<it->second->getName() ;
+           if (oss2->str().size()>90) 
+           {
+             oss<<oss2->str()<<"  &"<<iendl ;
+             delete oss2 ;
+             oss2=new ostringstream ;
+           }
+         }
+         *oss2<<" )" ;
+         oss<<oss2->str() ;
+         delete oss2 ; 
+         
+         oss<<iendl--<<iendl-- ;
+         oss<<"END SUBROUTINE xios(is_defined_"<<className<<"_attr)"<<iendl ;
+         
+      }      
       ///--------------------------------------------------------------
   

XIOS/trunk/src/attribute_map.hpp

@@ -54 +54 @@
             virtual void generateFortranInterfaceGet_hdl(ostream& oss, const string& className) ;
             virtual void generateFortranInterfaceGet_id(ostream& oss, const string& className) ;
+            virtual void generateFortranInterfaceIsDefined_hdl_(ostream& oss, const string& className) ;
+            virtual void generateFortranInterfaceIsDefined_hdl(ostream& oss, const string& className) ;
+            virtual void generateFortranInterfaceIsDefined_id(ostream& oss, const string& className) ;
 
          protected :

XIOS/trunk/src/attribute_template.hpp

@@ -73 +73 @@
             virtual void generateFortranInterfaceGetBody_(ostream& oss,const string& className) ;
             virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) ;
+//            virtual void generateFortranInterfaceIsDefinedDeclaration_(ostream& oss,const string& className) ;
+//            virtual void generateFortranInterfaceIsDefinedBody_(ostream& oss,const string& className) ;
+//            virtual void generateFortranInterfaceIsDefinedDeclaration(ostream& oss,const string& className) ;
 
       

XIOS/trunk/src/attribute_template_impl.hpp

@@ -214 +214 @@
       {
         CInterface::AttributeCInterface<T>(oss, className, this->getName()) ;
+//        CInterface::AttributeIsDefinedCInterface(oss, className, this->getName()) ;
       }
       
@@ -220 +221 @@
       {
         CInterface::AttributeFortran2003Interface<T>(oss, className, this->getName()) ;
+//        CInterface::AttributeIsDefinedFortran2003Interface(oss, className, this->getName()) ;
       }
       
@@ -246 +248 @@
       }
  
+ 
       template <typename T>
       void CAttributeTemplate<T>::generateFortranInterfaceGetBody_(ostream& oss,const string& className)
@@ -257 +260 @@
         CInterface::AttributeFortranInterfaceGetDeclaration<T>(oss, className, this->getName()) ;
       }
+
  
 /*      

XIOS/trunk/src/generate_interface.hpp

@@ -12 +12 @@
     template <class T>
     static void AttributeCInterface(ostream& oss,const string& className,const string& name) ;
-   
+    static void AttributeIsDefinedCInterface(ostream& oss, const string& className,const string& name);
+  
    template <class T>
    static void AttributeFortran2003Interface(ostream& oss,const string& className,const string& name) ;
+   static void AttributeIsDefinedFortran2003Interface(ostream& oss,const string& className,const string& name);
    
    template <class T>
@@ -22 +24 @@
    static void AttributeFortranInterfaceGetDeclaration(ostream& oss,const string& className,const string& name) ;
 
+   static void AttributeFortranInterfaceIsDefinedDeclaration(ostream& oss,const string& className,const string& name) ;
+
    template <class T>
    static void AttributeFortranInterfaceBody(ostream& oss,const string& className,const string& name) ;
@@ -27 +31 @@
    template <class T>
    static void AttributeFortranInterfaceGetBody(ostream& oss,const string& className,const string& name) ;
-  
+ 
+   static void AttributeFortranInterfaceIsDefinedBody(ostream& oss,const string& className,const string& name) ;
+ 
    template <class T>
    static string getStrFortranType(void) ;

XIOS/trunk/src/generate_interface_impl.hpp

@@ -36 +36 @@
 // /////////////////////////////////////////////////
 
+  
+  void CInterface::AttributeIsDefinedCInterface(ostream& oss, const string& className,const string& name)
+  {
+    oss<<"bool cxios_is_defined_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl )"<<iendl ;
+    oss<<"{"<<iendl ;
+    oss<<"   CTimer::get(\"XIOS\").resume();"<<iendl ;
+    oss<<"  return !"<<className<<"_hdl->"<<name<<".isEmpty();"<<iendl ;
+    oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;
+    oss<<"}"<<iendl ;
+    oss<<iendl ;
+  }
   
   template <class T>
@@ -55 +66 @@
     oss<<"  *"<<name<<" = "<<className<<"_hdl->"<<name<<".getValue();"<<iendl ;
     oss<<"}"<<iendl ;
+    oss<<iendl ;
   }
     
@@ -81 +93 @@
     oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;
     oss<<"}"<<iendl ;
-  
+    oss<<iendl ;
+   
   }
 
@@ -107 +120 @@
     oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;
     oss<<"}"<<iendl ;
+    oss<<iendl ;
   
   }
@@ -193 +207 @@
 // //          Fortran 2003 Interface             //
 // /////////////////////////////////////////////////
-
+   void CInterface::AttributeIsDefinedFortran2003Interface(ostream& oss,const string& className,const string& name)
+   {
+     oss<<"FUNCTION cxios_is_defined_"<<className<<"_"<<name<<"("<<className<<"_hdl ) BIND(C)"<<iendl ;
+     oss<<"  USE ISO_C_BINDING"<<iendl ;
+     oss<<"  LOGICAL(kind=C_BOOL) :: cxios_is_defined_"<<className<<"_"<<name<<iendl;
+     oss<<"  INTEGER (kind = C_INTPTR_T), VALUE :: "<<className<<"_hdl"<<iendl ;
+     oss<<"END FUNCTION cxios_is_defined_"<<className<<"_"<<name<<iendl ;   
+   }
+   
    template <class T>
    void CInterface::AttributeFortran2003Interface(ostream& oss,const string& className,const string& name)
@@ -205 +227 @@
      oss<<"  "<<fortranType<<" "<<fortranKindC<<"      , VALUE :: "<<name<<iendl ;
      oss<<"END SUBROUTINE cxios_set_"<<className<<"_"<<name<<iendl ;
-     oss<<iendl ; \
+     oss<<iendl ; 
      oss<<"SUBROUTINE cxios_get_"<<className<<"_"<<name<<"("<<className<<"_hdl, "<<name<<") BIND(C)"<<iendl ;
      oss<<"  USE ISO_C_BINDING"<<iendl ;
@@ -211 +233 @@
      oss<<"  "<<fortranType<<" "<<fortranKindC<<"             :: "<<name<<iendl ;
      oss<<"END SUBROUTINE cxios_get_"<<className<<"_"<<name<<iendl ;
+     oss<<iendl ;
    }
    
@@ -231 +254 @@
      oss<<"  INTEGER  (kind = C_INT)     , VALUE        :: "<<name<<"_size"<<iendl ;
      oss<<"END SUBROUTINE cxios_get_"<<className<<"_"<<name<<iendl ;
-     
+     oss<<iendl ;
    }
 
@@ -324 +347 @@
      if (!matchingTypeCFortran<T>()) oss<<getStrFortranType<T>()<<" "<<getStrFortranKindC<T>()<<" :: "<<name<<"_tmp"<<iendl ;
    }
-  
+   
+   void CInterface::AttributeFortranInterfaceIsDefinedDeclaration(ostream& oss,const string& className,const string& name)
+   {
+     oss<<"LOGICAL, OPTIONAL, INTENT(OUT) :: "<<name<<iendl ;
+     oss<<"LOGICAL(KIND=C_BOOL) :: "<<name<<"_tmp"<<iendl ;
+   }
+    
    template <>
    void CInterface::AttributeFortranInterfaceDeclaration<string>(ostream& oss,const string& className,const string& name)
@@ -416 +445 @@
      oss<<"ENDIF"<<iendl ;
    }
-  
+
+   void CInterface::AttributeFortranInterfaceIsDefinedBody(ostream& oss,const string& className,const string& name)
+   {
+     string name_tmp=name+"__tmp" ;
+     
+     oss<<"IF (PRESENT("<<name<<"_)) THEN"<<iendl ;
+     oss<<"  "<<name<<"__tmp=cxios_is_defined_"<<className<<"_"<<name<<"("<<className<<"_hdl%daddr)"<<iendl ;
+     oss<<"  "<<name<<"_="<<name_tmp<<iendl ;
+     oss<<"ENDIF"<<iendl ;
+   }
+     
    template <>
    void CInterface::AttributeFortranInterfaceBody<string>(ostream& oss,const string& className,const string& name)
@@ -574 +613 @@
     oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;\
     oss<<"}"<<iendl ;\
+    oss<<iendl ;\
   }\
 \
@@ -597 +637 @@
     oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;\
     oss<<"}"<<iendl ;\
+    oss<<iendl ;\
   }\
 \
@@ -620 +661 @@
     oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;\
     oss<<"}"<<iendl ;\
+    oss<<iendl ;\
   }
 
@@ -654 +696 @@
      oss<<"  INTEGER (kind = C_INT), VALUE  :: extent1"<<iendl ; \
      oss<<"END SUBROUTINE cxios_get_"<<className<<"_"<<name<<iendl ; \
+     oss<<iendl ;\
    } \
  \
@@ -677 +720 @@
      oss<<"  INTEGER (kind = C_INT), VALUE  :: extent2"<<iendl ; \
      oss<<"END SUBROUTINE cxios_get_"<<className<<"_"<<name<<iendl ; \
+     oss<<iendl ;\
    } \
      \
@@ -702 +746 @@
      oss<<"  INTEGER (kind = C_INT), VALUE  :: extent3"<<iendl ; \
      oss<<"END SUBROUTINE cxios_get_"<<className<<"_"<<name<<iendl ; \
+     oss<<iendl ;\
    }
   

XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp

@@ -35 +35 @@
   }
   
+  bool cxios_is_defined_axis_long_name(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axis_hdl->long_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axis_name(axis_Ptr axis_hdl, const char * name, int name_size)
@@ -54 +62 @@
   }
   
+  bool cxios_is_defined_axis_name(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axis_hdl->name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axis_positive(axis_Ptr axis_hdl, const char * positive, int positive_size)
@@ -73 +89 @@
   }
   
+  bool cxios_is_defined_axis_positive(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axis_hdl->positive.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axis_size(axis_Ptr axis_hdl, int size)
@@ -87 +111 @@
   }
   
+  bool cxios_is_defined_axis_size(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axis_hdl->size.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axis_standard_name(axis_Ptr axis_hdl, const char * standard_name, int standard_name_size)
@@ -106 +138 @@
   }
   
+  bool cxios_is_defined_axis_standard_name(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axis_hdl->standard_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axis_unit(axis_Ptr axis_hdl, const char * unit, int unit_size)
@@ -124 +164 @@
      CTimer::get("XIOS").suspend();
   }
+  
+  bool cxios_is_defined_axis_unit(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axis_hdl->unit.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -143 +191 @@
   }
   
+  bool cxios_is_defined_axis_value(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axis_hdl->value.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axis_zoom_begin(axis_Ptr axis_hdl, int zoom_begin)
@@ -157 +213 @@
   }
   
+  bool cxios_is_defined_axis_zoom_begin(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axis_hdl->zoom_begin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axis_zoom_end(axis_Ptr axis_hdl, int zoom_end)
@@ -171 +235 @@
   }
   
+  bool cxios_is_defined_axis_zoom_end(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axis_hdl->zoom_end.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axis_zoom_size(axis_Ptr axis_hdl, int zoom_size)
@@ -185 +257 @@
   }
   
+  bool cxios_is_defined_axis_zoom_size(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axis_hdl->zoom_size.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   

XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp

@@ -35 +35 @@
   }
   
+  bool cxios_is_defined_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axisgroup_hdl->group_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, const char * long_name, int long_name_size)
@@ -54 +62 @@
   }
   
+  bool cxios_is_defined_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axisgroup_hdl->long_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axisgroup_name(axisgroup_Ptr axisgroup_hdl, const char * name, int name_size)
@@ -73 +89 @@
   }
   
+  bool cxios_is_defined_axisgroup_name(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axisgroup_hdl->name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, const char * positive, int positive_size)
@@ -92 +116 @@
   }
   
+  bool cxios_is_defined_axisgroup_positive(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axisgroup_hdl->positive.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int size)
@@ -106 +138 @@
   }
   
+  bool cxios_is_defined_axisgroup_size(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axisgroup_hdl->size.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, const char * standard_name, int standard_name_size)
@@ -125 +165 @@
   }
   
+  bool cxios_is_defined_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axisgroup_hdl->standard_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, const char * unit, int unit_size)
@@ -143 +191 @@
      CTimer::get("XIOS").suspend();
   }
+  
+  bool cxios_is_defined_axisgroup_unit(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axisgroup_hdl->unit.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -162 +218 @@
   }
   
+  bool cxios_is_defined_axisgroup_value(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axisgroup_hdl->value.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int zoom_begin)
@@ -176 +240 @@
   }
   
+  bool cxios_is_defined_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axisgroup_hdl->zoom_begin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int zoom_end)
@@ -190 +262 @@
   }
   
+  bool cxios_is_defined_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axisgroup_hdl->zoom_end.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int zoom_size)
@@ -204 +284 @@
   }
   
+  bool cxios_is_defined_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !axisgroup_hdl->zoom_size.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   

XIOS/trunk/src/interface/c_attr/iccontext_attr.cpp

@@ -35 +35 @@
   }
   
+  bool cxios_is_defined_context_calendar_type(context_Ptr context_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !context_hdl->calendar_type.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_context_output_dir(context_Ptr context_hdl, const char * output_dir, int output_dir_size)
@@ -53 +61 @@
      CTimer::get("XIOS").suspend();
   }
+  
+  bool cxios_is_defined_context_output_dir(context_Ptr context_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !context_hdl->output_dir.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -73 +89 @@
   }
   
+  bool cxios_is_defined_context_start_date(context_Ptr context_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !context_hdl->start_date.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_context_time_origin(context_Ptr context_hdl, const char * time_origin, int time_origin_size)
@@ -91 +115 @@
      CTimer::get("XIOS").suspend();
   }
+  
+  bool cxios_is_defined_context_time_origin(context_Ptr context_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !context_hdl->time_origin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -111 +143 @@
   }
   
+  bool cxios_is_defined_context_timestep(context_Ptr context_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !context_hdl->timestep.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   

XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp

@@ -30 +30 @@
   }
   
+  bool cxios_is_defined_domain_data_dim(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->data_dim.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1)
@@ -48 +56 @@
   }
   
+  bool cxios_is_defined_domain_data_i_index(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->data_i_index.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_data_ibegin(domain_Ptr domain_hdl, int data_ibegin)
@@ -61 +77 @@
     *data_ibegin = domain_hdl->data_ibegin.getValue();
   }
+  
+  bool cxios_is_defined_domain_data_ibegin(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->data_ibegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -80 +104 @@
   }
   
+  bool cxios_is_defined_domain_data_j_index(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->data_j_index.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_data_jbegin(domain_Ptr domain_hdl, int data_jbegin)
@@ -94 +126 @@
   }
   
+  bool cxios_is_defined_domain_data_jbegin(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->data_jbegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_data_n_index(domain_Ptr domain_hdl, int data_n_index)
@@ -108 +148 @@
   }
   
+  bool cxios_is_defined_domain_data_n_index(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->data_n_index.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_data_ni(domain_Ptr domain_hdl, int data_ni)
@@ -122 +170 @@
   }
   
+  bool cxios_is_defined_domain_data_ni(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->data_ni.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_data_nj(domain_Ptr domain_hdl, int data_nj)
@@ -136 +192 @@
   }
   
+  bool cxios_is_defined_domain_data_nj(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->data_nj.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_domain_group_ref(domain_Ptr domain_hdl, const char * domain_group_ref, int domain_group_ref_size)
@@ -155 +219 @@
   }
   
+  bool cxios_is_defined_domain_domain_group_ref(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->domain_group_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_ibegin(domain_Ptr domain_hdl, int ibegin)
@@ -169 +241 @@
   }
   
+  bool cxios_is_defined_domain_ibegin(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->ibegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_iend(domain_Ptr domain_hdl, int iend)
@@ -183 +263 @@
   }
   
+  bool cxios_is_defined_domain_iend(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->iend.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_jbegin(domain_Ptr domain_hdl, int jbegin)
@@ -197 +285 @@
   }
   
+  bool cxios_is_defined_domain_jbegin(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->jbegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_jend(domain_Ptr domain_hdl, int jend)
@@ -210 +306 @@
     *jend = domain_hdl->jend.getValue();
   }
+  
+  bool cxios_is_defined_domain_jend(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->jend.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -229 +333 @@
   }
   
+  bool cxios_is_defined_domain_latvalue(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->latvalue.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_long_name(domain_Ptr domain_hdl, const char * long_name, int long_name_size)
@@ -247 +359 @@
      CTimer::get("XIOS").suspend();
   }
+  
+  bool cxios_is_defined_domain_long_name(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->long_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -266 +386 @@
   }
   
+  bool cxios_is_defined_domain_lonvalue(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->lonvalue.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2)
@@ -284 +412 @@
   }
   
+  bool cxios_is_defined_domain_mask(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->mask.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_name(domain_Ptr domain_hdl, const char * name, int name_size)
@@ -303 +439 @@
   }
   
+  bool cxios_is_defined_domain_name(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_ni(domain_Ptr domain_hdl, int ni)
@@ -317 +461 @@
   }
   
+  bool cxios_is_defined_domain_ni(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->ni.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_ni_glo(domain_Ptr domain_hdl, int ni_glo)
@@ -331 +483 @@
   }
   
+  bool cxios_is_defined_domain_ni_glo(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->ni_glo.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_nj(domain_Ptr domain_hdl, int nj)
@@ -345 +505 @@
   }
   
+  bool cxios_is_defined_domain_nj(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->nj.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_nj_glo(domain_Ptr domain_hdl, int nj_glo)
@@ -359 +527 @@
   }
   
+  bool cxios_is_defined_domain_nj_glo(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->nj_glo.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_standard_name(domain_Ptr domain_hdl, const char * standard_name, int standard_name_size)
@@ -378 +554 @@
   }
   
+  bool cxios_is_defined_domain_standard_name(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->standard_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_zoom_ibegin(domain_Ptr domain_hdl, int zoom_ibegin)
@@ -392 +576 @@
   }
   
+  bool cxios_is_defined_domain_zoom_ibegin(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->zoom_ibegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_zoom_ibegin_loc(domain_Ptr domain_hdl, int zoom_ibegin_loc)
@@ -406 +598 @@
   }
   
+  bool cxios_is_defined_domain_zoom_ibegin_loc(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->zoom_ibegin_loc.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_zoom_jbegin(domain_Ptr domain_hdl, int zoom_jbegin)
@@ -420 +620 @@
   }
   
+  bool cxios_is_defined_domain_zoom_jbegin(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->zoom_jbegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_zoom_jbegin_loc(domain_Ptr domain_hdl, int zoom_jbegin_loc)
@@ -434 +642 @@
   }
   
+  bool cxios_is_defined_domain_zoom_jbegin_loc(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->zoom_jbegin_loc.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_zoom_ni(domain_Ptr domain_hdl, int zoom_ni)
@@ -448 +664 @@
   }
   
+  bool cxios_is_defined_domain_zoom_ni(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->zoom_ni.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_zoom_ni_loc(domain_Ptr domain_hdl, int zoom_ni_loc)
@@ -462 +686 @@
   }
   
+  bool cxios_is_defined_domain_zoom_ni_loc(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->zoom_ni_loc.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_zoom_nj(domain_Ptr domain_hdl, int zoom_nj)
@@ -476 +708 @@
   }
   
+  bool cxios_is_defined_domain_zoom_nj(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->zoom_nj.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domain_zoom_nj_loc(domain_Ptr domain_hdl, int zoom_nj_loc)
@@ -490 +730 @@
   }
   
+  bool cxios_is_defined_domain_zoom_nj_loc(domain_Ptr domain_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domain_hdl->zoom_nj_loc.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   

XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp

@@ -30 +30 @@
   }
   
+  bool cxios_is_defined_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->data_dim.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1)
@@ -48 +56 @@
   }
   
+  bool cxios_is_defined_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->data_i_index.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl, int data_ibegin)
@@ -61 +77 @@
     *data_ibegin = domaingroup_hdl->data_ibegin.getValue();
   }
+  
+  bool cxios_is_defined_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->data_ibegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -80 +104 @@
   }
   
+  bool cxios_is_defined_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->data_j_index.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl, int data_jbegin)
@@ -94 +126 @@
   }
   
+  bool cxios_is_defined_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->data_jbegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int data_n_index)
@@ -108 +148 @@
   }
   
+  bool cxios_is_defined_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->data_n_index.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int data_ni)
@@ -122 +170 @@
   }
   
+  bool cxios_is_defined_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->data_ni.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl, int data_nj)
@@ -136 +192 @@
   }
   
+  bool cxios_is_defined_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->data_nj.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, const char * domain_group_ref, int domain_group_ref_size)
@@ -155 +219 @@
   }
   
+  bool cxios_is_defined_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->domain_group_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, const char * group_ref, int group_ref_size)
@@ -174 +246 @@
   }
   
+  bool cxios_is_defined_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->group_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl, int ibegin)
@@ -188 +268 @@
   }
   
+  bool cxios_is_defined_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->ibegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_iend(domaingroup_Ptr domaingroup_hdl, int iend)
@@ -202 +290 @@
   }
   
+  bool cxios_is_defined_domaingroup_iend(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->iend.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl, int jbegin)
@@ -216 +312 @@
   }
   
+  bool cxios_is_defined_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->jbegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_jend(domaingroup_Ptr domaingroup_hdl, int jend)
@@ -229 +333 @@
     *jend = domaingroup_hdl->jend.getValue();
   }
+  
+  bool cxios_is_defined_domaingroup_jend(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->jend.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -248 +360 @@
   }
   
+  bool cxios_is_defined_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->latvalue.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, const char * long_name, int long_name_size)
@@ -266 +386 @@
      CTimer::get("XIOS").suspend();
   }
+  
+  bool cxios_is_defined_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->long_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -285 +413 @@
   }
   
+  bool cxios_is_defined_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->lonvalue.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2)
@@ -303 +439 @@
   }
   
+  bool cxios_is_defined_domaingroup_mask(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->mask.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_name(domaingroup_Ptr domaingroup_hdl, const char * name, int name_size)
@@ -322 +466 @@
   }
   
+  bool cxios_is_defined_domaingroup_name(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_ni(domaingroup_Ptr domaingroup_hdl, int ni)
@@ -336 +488 @@
   }
   
+  bool cxios_is_defined_domaingroup_ni(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->ni.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl, int ni_glo)
@@ -350 +510 @@
   }
   
+  bool cxios_is_defined_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->ni_glo.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_nj(domaingroup_Ptr domaingroup_hdl, int nj)
@@ -364 +532 @@
   }
   
+  bool cxios_is_defined_domaingroup_nj(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->nj.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl, int nj_glo)
@@ -378 +554 @@
   }
   
+  bool cxios_is_defined_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->nj_glo.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, const char * standard_name, int standard_name_size)
@@ -397 +581 @@
   }
   
+  bool cxios_is_defined_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->standard_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin)
@@ -411 +603 @@
   }
   
+  bool cxios_is_defined_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->zoom_ibegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin_loc)
@@ -425 +625 @@
   }
   
+  bool cxios_is_defined_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->zoom_ibegin_loc.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin)
@@ -439 +647 @@
   }
   
+  bool cxios_is_defined_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->zoom_jbegin.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin_loc)
@@ -453 +669 @@
   }
   
+  bool cxios_is_defined_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->zoom_jbegin_loc.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl, int zoom_ni)
@@ -467 +691 @@
   }
   
+  bool cxios_is_defined_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->zoom_ni.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ni_loc)
@@ -481 +713 @@
   }
   
+  bool cxios_is_defined_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->zoom_ni_loc.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl, int zoom_nj)
@@ -495 +735 @@
   }
   
+  bool cxios_is_defined_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->zoom_nj.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl, int zoom_nj_loc)
@@ -509 +757 @@
   }
   
+  bool cxios_is_defined_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !domaingroup_hdl->zoom_nj_loc.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   

XIOS/trunk/src/interface/c_attr/icfield_attr.cpp

@@ -35 +35 @@
   }
   
+  bool cxios_is_defined_field_axis_ref(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->axis_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_default_value(field_Ptr field_hdl, double default_value)
@@ -49 +57 @@
   }
   
+  bool cxios_is_defined_field_default_value(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->default_value.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_domain_ref(field_Ptr field_hdl, const char * domain_ref, int domain_ref_size)
@@ -68 +84 @@
   }
   
+  bool cxios_is_defined_field_domain_ref(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->domain_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_enabled(field_Ptr field_hdl, bool enabled)
@@ -82 +106 @@
   }
   
+  bool cxios_is_defined_field_enabled(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->enabled.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_field_ref(field_Ptr field_hdl, const char * field_ref, int field_ref_size)
@@ -101 +133 @@
   }
   
+  bool cxios_is_defined_field_field_ref(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->field_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_freq_offset(field_Ptr field_hdl, const char * freq_offset, int freq_offset_size)
@@ -120 +160 @@
   }
   
+  bool cxios_is_defined_field_freq_offset(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->freq_offset.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_freq_op(field_Ptr field_hdl, const char * freq_op, int freq_op_size)
@@ -139 +187 @@
   }
   
+  bool cxios_is_defined_field_freq_op(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->freq_op.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_grid_ref(field_Ptr field_hdl, const char * grid_ref, int grid_ref_size)
@@ -158 +214 @@
   }
   
+  bool cxios_is_defined_field_grid_ref(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->grid_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_level(field_Ptr field_hdl, int level)
@@ -172 +236 @@
   }
   
+  bool cxios_is_defined_field_level(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->level.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_long_name(field_Ptr field_hdl, const char * long_name, int long_name_size)
@@ -191 +263 @@
   }
   
+  bool cxios_is_defined_field_long_name(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->long_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_name(field_Ptr field_hdl, const char * name, int name_size)
@@ -210 +290 @@
   }
   
+  bool cxios_is_defined_field_name(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_operation(field_Ptr field_hdl, const char * operation, int operation_size)
@@ -229 +317 @@
   }
   
+  bool cxios_is_defined_field_operation(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->operation.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_prec(field_Ptr field_hdl, int prec)
@@ -243 +339 @@
   }
   
+  bool cxios_is_defined_field_prec(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->prec.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_standard_name(field_Ptr field_hdl, const char * standard_name, int standard_name_size)
@@ -262 +366 @@
   }
   
+  bool cxios_is_defined_field_standard_name(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->standard_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_field_unit(field_Ptr field_hdl, const char * unit, int unit_size)
@@ -281 +393 @@
   }
   
+  bool cxios_is_defined_field_unit(field_Ptr field_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !field_hdl->unit.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   

XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp

@@ -35 +35 @@
   }
   
+  bool cxios_is_defined_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->axis_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double default_value)
@@ -49 +57 @@
   }
   
+  bool cxios_is_defined_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->default_value.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, const char * domain_ref, int domain_ref_size)
@@ -68 +84 @@
   }
   
+  bool cxios_is_defined_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->domain_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool enabled)
@@ -82 +106 @@
   }
   
+  bool cxios_is_defined_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->enabled.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, const char * field_ref, int field_ref_size)
@@ -101 +133 @@
   }
   
+  bool cxios_is_defined_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->field_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, const char * freq_offset, int freq_offset_size)
@@ -120 +160 @@
   }
   
+  bool cxios_is_defined_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->freq_offset.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, const char * freq_op, int freq_op_size)
@@ -139 +187 @@
   }
   
+  bool cxios_is_defined_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->freq_op.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, const char * grid_ref, int grid_ref_size)
@@ -158 +214 @@
   }
   
+  bool cxios_is_defined_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->grid_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, const char * group_ref, int group_ref_size)
@@ -177 +241 @@
   }
   
+  bool cxios_is_defined_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->group_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int level)
@@ -191 +263 @@
   }
   
+  bool cxios_is_defined_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->level.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, const char * long_name, int long_name_size)
@@ -210 +290 @@
   }
   
+  bool cxios_is_defined_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->long_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, const char * name, int name_size)
@@ -229 +317 @@
   }
   
+  bool cxios_is_defined_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, const char * operation, int operation_size)
@@ -248 +344 @@
   }
   
+  bool cxios_is_defined_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->operation.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int prec)
@@ -262 +366 @@
   }
   
+  bool cxios_is_defined_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->prec.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, const char * standard_name, int standard_name_size)
@@ -281 +393 @@
   }
   
+  bool cxios_is_defined_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->standard_name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, const char * unit, int unit_size)
@@ -300 +420 @@
   }
   
+  bool cxios_is_defined_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !fieldgroup_hdl->unit.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   

XIOS/trunk/src/interface/c_attr/icfile_attr.cpp

@@ -35 +35 @@
   }
   
+  bool cxios_is_defined_file_description(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->description.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_file_enabled(file_Ptr file_hdl, bool enabled)
@@ -49 +57 @@
   }
   
+  bool cxios_is_defined_file_enabled(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->enabled.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_file_min_digits(file_Ptr file_hdl, int min_digits)
@@ -63 +79 @@
   }
   
+  bool cxios_is_defined_file_min_digits(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->min_digits.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_file_name(file_Ptr file_hdl, const char * name, int name_size)
@@ -82 +106 @@
   }
   
+  bool cxios_is_defined_file_name(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_file_name_suffix(file_Ptr file_hdl, const char * name_suffix, int name_suffix_size)
@@ -101 +133 @@
   }
   
+  bool cxios_is_defined_file_name_suffix(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->name_suffix.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_file_output_freq(file_Ptr file_hdl, const char * output_freq, int output_freq_size)
@@ -120 +160 @@
   }
   
+  bool cxios_is_defined_file_output_freq(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->output_freq.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_file_output_level(file_Ptr file_hdl, int output_level)
@@ -134 +182 @@
   }
   
+  bool cxios_is_defined_file_output_level(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->output_level.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_file_par_access(file_Ptr file_hdl, const char * par_access, int par_access_size)
@@ -153 +209 @@
   }
   
+  bool cxios_is_defined_file_par_access(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->par_access.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_file_split_freq(file_Ptr file_hdl, const char * split_freq, int split_freq_size)
@@ -172 +236 @@
   }
   
+  bool cxios_is_defined_file_split_freq(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->split_freq.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
+  void cxios_set_file_split_freq_format(file_Ptr file_hdl, const char * split_freq_format, int split_freq_format_size)
+  {
+    std::string split_freq_format_str;
+    if(!cstr2string(split_freq_format, split_freq_format_size, split_freq_format_str)) return;
+     CTimer::get("XIOS").resume();
+    file_hdl->split_freq_format.setValue(split_freq_format_str);
+    file_hdl->sendAttributToServer(file_hdl->split_freq_format);
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_file_split_freq_format(file_Ptr file_hdl, char * split_freq_format, int split_freq_format_size)
+  {
+     CTimer::get("XIOS").resume();
+    if(!string_copy(file_hdl->split_freq_format.getValue(),split_freq_format , split_freq_format_size))
+      ERROR("void cxios_get_file_split_freq_format(file_Ptr file_hdl, char * split_freq_format, int split_freq_format_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
+  }
+  
+  bool cxios_is_defined_file_split_freq_format(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->split_freq_format.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_file_sync_freq(file_Ptr file_hdl, const char * sync_freq, int sync_freq_size)
@@ -191 +290 @@
   }
   
+  bool cxios_is_defined_file_sync_freq(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->sync_freq.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_file_type(file_Ptr file_hdl, const char * type, int type_size)
@@ -210 +317 @@
   }
   
+  bool cxios_is_defined_file_type(file_Ptr file_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !file_hdl->type.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   

XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp

@@ -35 +35 @@
   }
   
+  bool cxios_is_defined_filegroup_description(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->description.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool enabled)
@@ -49 +57 @@
   }
   
+  bool cxios_is_defined_filegroup_enabled(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->enabled.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_filegroup_group_ref(filegroup_Ptr filegroup_hdl, const char * group_ref, int group_ref_size)
@@ -68 +84 @@
   }
   
+  bool cxios_is_defined_filegroup_group_ref(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->group_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_filegroup_min_digits(filegroup_Ptr filegroup_hdl, int min_digits)
@@ -82 +106 @@
   }
   
+  bool cxios_is_defined_filegroup_min_digits(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->min_digits.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_filegroup_name(filegroup_Ptr filegroup_hdl, const char * name, int name_size)
@@ -101 +133 @@
   }
   
+  bool cxios_is_defined_filegroup_name(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, const char * name_suffix, int name_suffix_size)
@@ -120 +160 @@
   }
   
+  bool cxios_is_defined_filegroup_name_suffix(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->name_suffix.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_filegroup_output_freq(filegroup_Ptr filegroup_hdl, const char * output_freq, int output_freq_size)
@@ -139 +187 @@
   }
   
+  bool cxios_is_defined_filegroup_output_freq(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->output_freq.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_filegroup_output_level(filegroup_Ptr filegroup_hdl, int output_level)
@@ -153 +209 @@
   }
   
+  bool cxios_is_defined_filegroup_output_level(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->output_level.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_filegroup_par_access(filegroup_Ptr filegroup_hdl, const char * par_access, int par_access_size)
@@ -172 +236 @@
   }
   
+  bool cxios_is_defined_filegroup_par_access(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->par_access.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_filegroup_split_freq(filegroup_Ptr filegroup_hdl, const char * split_freq, int split_freq_size)
@@ -191 +263 @@
   }
   
+  bool cxios_is_defined_filegroup_split_freq(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->split_freq.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
+  void cxios_set_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, const char * split_freq_format, int split_freq_format_size)
+  {
+    std::string split_freq_format_str;
+    if(!cstr2string(split_freq_format, split_freq_format_size, split_freq_format_str)) return;
+     CTimer::get("XIOS").resume();
+    filegroup_hdl->split_freq_format.setValue(split_freq_format_str);
+    filegroup_hdl->sendAttributToServer(filegroup_hdl->split_freq_format);
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, char * split_freq_format, int split_freq_format_size)
+  {
+     CTimer::get("XIOS").resume();
+    if(!string_copy(filegroup_hdl->split_freq_format.getValue(),split_freq_format , split_freq_format_size))
+      ERROR("void cxios_get_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, char * split_freq_format, int split_freq_format_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
+  }
+  
+  bool cxios_is_defined_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->split_freq_format.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, const char * sync_freq, int sync_freq_size)
@@ -210 +317 @@
   }
   
+  bool cxios_is_defined_filegroup_sync_freq(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->sync_freq.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_filegroup_type(filegroup_Ptr filegroup_hdl, const char * type, int type_size)
@@ -229 +344 @@
   }
   
+  bool cxios_is_defined_filegroup_type(filegroup_Ptr filegroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !filegroup_hdl->type.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   

XIOS/trunk/src/interface/c_attr/icgrid_attr.cpp

@@ -35 +35 @@
   }
   
+  bool cxios_is_defined_grid_axis_ref(grid_Ptr grid_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !grid_hdl->axis_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_grid_description(grid_Ptr grid_hdl, const char * description, int description_size)
@@ -53 +61 @@
      CTimer::get("XIOS").suspend();
   }
+  
+  bool cxios_is_defined_grid_description(grid_Ptr grid_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !grid_hdl->description.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -73 +89 @@
   }
   
+  bool cxios_is_defined_grid_domain_ref(grid_Ptr grid_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !grid_hdl->domain_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_grid_mask(grid_Ptr grid_hdl, bool* mask, int extent1, int extent2, int extent3)
@@ -90 +114 @@
      CTimer::get("XIOS").suspend();
   }
+  
+  bool cxios_is_defined_grid_mask(grid_Ptr grid_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !grid_hdl->mask.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -110 +142 @@
   }
   
+  bool cxios_is_defined_grid_name(grid_Ptr grid_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !grid_hdl->name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   

XIOS/trunk/src/interface/c_attr/icgridgroup_attr.cpp

@@ -35 +35 @@
   }
   
+  bool cxios_is_defined_gridgroup_axis_ref(gridgroup_Ptr gridgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !gridgroup_hdl->axis_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_gridgroup_description(gridgroup_Ptr gridgroup_hdl, const char * description, int description_size)
@@ -53 +61 @@
      CTimer::get("XIOS").suspend();
   }
+  
+  bool cxios_is_defined_gridgroup_description(gridgroup_Ptr gridgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !gridgroup_hdl->description.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -73 +89 @@
   }
   
+  bool cxios_is_defined_gridgroup_domain_ref(gridgroup_Ptr gridgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !gridgroup_hdl->domain_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, const char * group_ref, int group_ref_size)
@@ -92 +116 @@
   }
   
+  bool cxios_is_defined_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !gridgroup_hdl->group_ref.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   void cxios_set_gridgroup_mask(gridgroup_Ptr gridgroup_hdl, bool* mask, int extent1, int extent2, int extent3)
@@ -109 +141 @@
      CTimer::get("XIOS").suspend();
   }
+  
+  bool cxios_is_defined_gridgroup_mask(gridgroup_Ptr gridgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !gridgroup_hdl->mask.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
   
   
@@ -129 +169 @@
   }
   
+  bool cxios_is_defined_gridgroup_name(gridgroup_Ptr gridgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return !gridgroup_hdl->name.isEmpty();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
   
   

XIOS/trunk/src/interface/fortran/ixios.F90

@@ -8 +8 @@
 
 USE icontext_attr, ONLY : xios(set_context_attr), xios(set_context_attr_hdl), &
-                          xios(get_context_attr), xios(get_context_attr_hdl)
+                          xios(get_context_attr), xios(get_context_attr_hdl), &
+                          xios(is_defined_context_attr), xios(is_defined_context_attr_hdl)
                                                
 USE idata, ONLY : xios(initialize),xios(init_server), xios(finalize), xios(context_initialize),  &
@@ -23 +24 @@
 
 USE idomain_attr, ONLY :  xios(set_domain_attr), xios(set_domain_attr_hdl),  &
-                          xios(get_domain_attr), xios(get_domain_attr_hdl)
+                          xios(get_domain_attr), xios(get_domain_attr_hdl), &
+                          xios(is_defined_domain_attr), xios(is_defined_domain_attr_hdl)
 
 USE idomaingroup_attr, ONLY : xios(set_domaingroup_attr), xios(set_domaingroup_attr_hdl),  & 
-                              xios(get_domaingroup_attr), xios(get_domaingroup_attr_hdl) 
+                              xios(get_domaingroup_attr), xios(get_domaingroup_attr_hdl), & 
+                              xios(is_defined_domaingroup_attr), xios(is_defined_domaingroup_attr_hdl) 
                     
 USE ifield, ONLY : txios(field), txios(fieldgroup), xios(get_field_handle),  &
@@ -33 +36 @@
 
 USE ifield_attr, ONLY : xios(set_field_attr),xios(set_field_attr_hdl),    &
-                        xios(get_field_attr),xios(get_field_attr_hdl)
+                        xios(get_field_attr),xios(get_field_attr_hdl), &
+                        xios(is_defined_field_attr),xios(is_defined_field_attr_hdl)
   
 USE ifieldgroup_attr, ONLY : xios(set_fieldgroup_attr), xios(set_fieldgroup_attr_hdl),  &
-                             xios(get_fieldgroup_attr), xios(get_fieldgroup_attr_hdl)
+                             xios(get_fieldgroup_attr), xios(get_fieldgroup_attr_hdl), &
+                             xios(is_defined_fieldgroup_attr), xios(is_defined_fieldgroup_attr_hdl)
 
 USE ifile, ONLY : txios(file), txios(filegroup), xios(get_file_handle),    & 
@@ -42 +47 @@
 
 USE ifile_attr, ONLY : xios(set_file_attr),xios(set_file_attr_hdl), &
-                       xios(get_file_attr),xios(get_file_attr_hdl)
+                       xios(get_file_attr),xios(get_file_attr_hdl), &
+                       xios(is_defined_file_attr),xios(is_defined_file_attr_hdl)
 
 USE ifilegroup_attr, ONLY : xios(set_filegroup_attr), xios(set_filegroup_attr_hdl), &
-                            xios(get_filegroup_attr), xios(get_filegroup_attr_hdl)
+                            xios(get_filegroup_attr), xios(get_filegroup_attr_hdl), &
+                            xios(is_defined_filegroup_attr), xios(is_defined_filegroup_attr_hdl)
                   
 USE igrid, ONLY : txios(grid), txios(gridgroup), xios(get_grid_handle),     &
@@ -51 +58 @@
 
 USE igrid_attr, ONLY : xios(set_grid_attr_hdl), xios(set_grid_attr), &
-                       xios(get_grid_attr_hdl), xios(get_grid_attr)
+                       xios(get_grid_attr_hdl), xios(get_grid_attr), &
+                       xios(is_defined_grid_attr_hdl), xios(is_defined_grid_attr)
 
 USE igridgroup_attr, ONLY : xios(set_gridgroup_attr), xios(set_gridgroup_attr_hdl),  &
-                            xios(get_gridgroup_attr), xios(get_gridgroup_attr_hdl)
+                            xios(get_gridgroup_attr), xios(get_gridgroup_attr_hdl), &
+                            xios(is_defined_gridgroup_attr), xios(is_defined_gridgroup_attr_hdl)
 
 USE iaxis, ONLY : txios(axis), txios(axisgroup), xios(get_axis_handle),     &
@@ -60 +69 @@
 
 USE iaxis_attr, ONLY :  xios(set_axis_attr), xios(set_axis_attr_hdl), &
-                        xios(get_axis_attr), xios(get_axis_attr_hdl)
+                        xios(get_axis_attr), xios(get_axis_attr_hdl), &
+                        xios(is_defined_axis_attr), xios(is_defined_axis_attr_hdl)
 
 USE iaxisgroup_attr, ONLY : xios(set_axisgroup_attr), xios(set_axisgroup_attr_hdl), &
-                            xios(get_axisgroup_attr), xios(get_axisgroup_attr_hdl)
+                            xios(get_axisgroup_attr), xios(get_axisgroup_attr_hdl), &
+                            xios(is_defined_axisgroup_attr), xios(is_defined_axisgroup_attr_hdl)
 
 USE ixml_tree, ONLY : xios(add_axis), xios(add_file), xios(add_grid), xios(add_field), xios(add_domain),          &
@@ -86 +97 @@
                    xios(get_axisgroup_attr_hdl), xios(get_context_attr_hdl)
 END INTERFACE xios(get_attr)
+
+INTERFACE xios(is_defined_attr)
+  MODULE PROCEDURE xios(is_defined_domaingroup_attr_hdl), xios(is_defined_domain_attr_hdl), xios(is_defined_fieldgroup_attr_hdl), &
+                   xios(is_defined_field_attr_hdl), xios(is_defined_file_attr_hdl), xios(is_defined_filegroup_attr_hdl),          &
+                   xios(is_defined_grid_attr_hdl), xios(is_defined_gridgroup_attr_hdl), xios(is_defined_axis_attr_hdl) ,          &
+                   xios(is_defined_axisgroup_attr_hdl), xios(is_defined_context_attr_hdl)
+END INTERFACE xios(is_defined_attr)
 
 INTERFACE xios(get_handle)
@@ -123 +141 @@
           xios(get_axisgroup_attr), xios(get_context_attr)
 
+PUBLIC :: xios(is_defined_attr), xios(is_defined_domain_attr), xios(is_defined_domaingroup_attr), xios(is_defined_fieldgroup_attr), &
+          xios(is_defined_field_attr), xios(is_defined_file_attr), xios(is_defined_filegroup_attr),          &
+          xios(is_defined_grid_attr), xios(is_defined_gridgroup_attr), xios(is_defined_axis_attr) ,          &
+          xios(is_defined_axisgroup_attr), xios(is_defined_context_attr)
+
  PUBLIC :: xios(get_handle) 
  PUBLIC :: xios(add_child) 

XIOS/trunk/src/interface/fortran_attr/axis_interface_attr.f90

@@ -23 +23 @@
     END SUBROUTINE cxios_get_axis_long_name
     
+    FUNCTION cxios_is_defined_axis_long_name(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_long_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_long_name
+    
     
     SUBROUTINE cxios_set_axis_name(axis_hdl, name, name_size) BIND(C)
@@ -38 +44 @@
     END SUBROUTINE cxios_get_axis_name
     
+    FUNCTION cxios_is_defined_axis_name(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_name
+    
     
     SUBROUTINE cxios_set_axis_positive(axis_hdl, positive, positive_size) BIND(C)
@@ -53 +65 @@
     END SUBROUTINE cxios_get_axis_positive
     
+    FUNCTION cxios_is_defined_axis_positive(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_positive
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_positive
+    
     
     SUBROUTINE cxios_set_axis_size(axis_hdl, size) BIND(C)
@@ -65 +83 @@
       INTEGER (KIND=C_INT)             :: size
     END SUBROUTINE cxios_get_axis_size
+    
+    FUNCTION cxios_is_defined_axis_size(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_size
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_size
     
     
@@ -81 +105 @@
     END SUBROUTINE cxios_get_axis_standard_name
     
+    FUNCTION cxios_is_defined_axis_standard_name(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_standard_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_standard_name
+    
     
     SUBROUTINE cxios_set_axis_unit(axis_hdl, unit, unit_size) BIND(C)
@@ -95 +125 @@
       INTEGER  (kind = C_INT)     , VALUE        :: unit_size
     END SUBROUTINE cxios_get_axis_unit
+    
+    FUNCTION cxios_is_defined_axis_unit(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_unit
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_unit
     
     
@@ -111 +147 @@
     END SUBROUTINE cxios_get_axis_value
     
+    FUNCTION cxios_is_defined_axis_value(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_value
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_value
+    
     
     SUBROUTINE cxios_set_axis_zoom_begin(axis_hdl, zoom_begin) BIND(C)
@@ -124 +166 @@
     END SUBROUTINE cxios_get_axis_zoom_begin
     
+    FUNCTION cxios_is_defined_axis_zoom_begin(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_zoom_begin
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_zoom_begin
+    
     
     SUBROUTINE cxios_set_axis_zoom_end(axis_hdl, zoom_end) BIND(C)
@@ -137 +185 @@
     END SUBROUTINE cxios_get_axis_zoom_end
     
+    FUNCTION cxios_is_defined_axis_zoom_end(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_zoom_end
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_zoom_end
+    
     
     SUBROUTINE cxios_set_axis_zoom_size(axis_hdl, zoom_size) BIND(C)
@@ -149 +203 @@
       INTEGER (KIND=C_INT)             :: zoom_size
     END SUBROUTINE cxios_get_axis_zoom_size
+    
+    FUNCTION cxios_is_defined_axis_zoom_size(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_zoom_size
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_zoom_size
     
     

XIOS/trunk/src/interface/fortran_attr/axisgroup_interface_attr.f90

@@ -23 +23 @@
     END SUBROUTINE cxios_get_axisgroup_group_ref
     
+    FUNCTION cxios_is_defined_axisgroup_group_ref(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_group_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_group_ref
+    
     
     SUBROUTINE cxios_set_axisgroup_long_name(axisgroup_hdl, long_name, long_name_size) BIND(C)
@@ -38 +44 @@
     END SUBROUTINE cxios_get_axisgroup_long_name
     
+    FUNCTION cxios_is_defined_axisgroup_long_name(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_long_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_long_name
+    
     
     SUBROUTINE cxios_set_axisgroup_name(axisgroup_hdl, name, name_size) BIND(C)
@@ -53 +65 @@
     END SUBROUTINE cxios_get_axisgroup_name
     
+    FUNCTION cxios_is_defined_axisgroup_name(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_name
+    
     
     SUBROUTINE cxios_set_axisgroup_positive(axisgroup_hdl, positive, positive_size) BIND(C)
@@ -68 +86 @@
     END SUBROUTINE cxios_get_axisgroup_positive
     
+    FUNCTION cxios_is_defined_axisgroup_positive(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_positive
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_positive
+    
     
     SUBROUTINE cxios_set_axisgroup_size(axisgroup_hdl, size) BIND(C)
@@ -80 +104 @@
       INTEGER (KIND=C_INT)             :: size
     END SUBROUTINE cxios_get_axisgroup_size
+    
+    FUNCTION cxios_is_defined_axisgroup_size(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_size
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_size
     
     
@@ -96 +126 @@
     END SUBROUTINE cxios_get_axisgroup_standard_name
     
+    FUNCTION cxios_is_defined_axisgroup_standard_name(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_standard_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_standard_name
+    
     
     SUBROUTINE cxios_set_axisgroup_unit(axisgroup_hdl, unit, unit_size) BIND(C)
@@ -110 +146 @@
       INTEGER  (kind = C_INT)     , VALUE        :: unit_size
     END SUBROUTINE cxios_get_axisgroup_unit
+    
+    FUNCTION cxios_is_defined_axisgroup_unit(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_unit
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_unit
     
     
@@ -126 +168 @@
     END SUBROUTINE cxios_get_axisgroup_value
     
+    FUNCTION cxios_is_defined_axisgroup_value(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_value
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_value
+    
     
     SUBROUTINE cxios_set_axisgroup_zoom_begin(axisgroup_hdl, zoom_begin) BIND(C)
@@ -139 +187 @@
     END SUBROUTINE cxios_get_axisgroup_zoom_begin
     
+    FUNCTION cxios_is_defined_axisgroup_zoom_begin(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_zoom_begin
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_zoom_begin
+    
     
     SUBROUTINE cxios_set_axisgroup_zoom_end(axisgroup_hdl, zoom_end) BIND(C)
@@ -152 +206 @@
     END SUBROUTINE cxios_get_axisgroup_zoom_end
     
+    FUNCTION cxios_is_defined_axisgroup_zoom_end(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_zoom_end
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_zoom_end
+    
     
     SUBROUTINE cxios_set_axisgroup_zoom_size(axisgroup_hdl, zoom_size) BIND(C)
@@ -164 +224 @@
       INTEGER (KIND=C_INT)             :: zoom_size
     END SUBROUTINE cxios_get_axisgroup_zoom_size
+    
+    FUNCTION cxios_is_defined_axisgroup_zoom_size(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_zoom_size
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_zoom_size
     
     

XIOS/trunk/src/interface/fortran_attr/context_interface_attr.f90

@@ -23 +23 @@
     END SUBROUTINE cxios_get_context_calendar_type
     
+    FUNCTION cxios_is_defined_context_calendar_type(context_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_calendar_type
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_calendar_type
+    
     
     SUBROUTINE cxios_set_context_output_dir(context_hdl, output_dir, output_dir_size) BIND(C)
@@ -37 +43 @@
       INTEGER  (kind = C_INT)     , VALUE        :: output_dir_size
     END SUBROUTINE cxios_get_context_output_dir
+    
+    FUNCTION cxios_is_defined_context_output_dir(context_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_output_dir
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_output_dir
     
     
@@ -53 +65 @@
     END SUBROUTINE cxios_get_context_start_date
     
+    FUNCTION cxios_is_defined_context_start_date(context_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_start_date
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_start_date
+    
     
     SUBROUTINE cxios_set_context_time_origin(context_hdl, time_origin, time_origin_size) BIND(C)
@@ -67 +85 @@
       INTEGER  (kind = C_INT)     , VALUE        :: time_origin_size
     END SUBROUTINE cxios_get_context_time_origin
+    
+    FUNCTION cxios_is_defined_context_time_origin(context_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_time_origin
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_time_origin
     
     
@@ -83 +107 @@
     END SUBROUTINE cxios_get_context_timestep
     
+    FUNCTION cxios_is_defined_context_timestep(context_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_timestep
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_timestep
+    
     
     END INTERFACE

XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.f90

@@ -21 +21 @@
     END SUBROUTINE cxios_get_domain_data_dim
     
+    FUNCTION cxios_is_defined_domain_data_dim(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_data_dim
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_data_dim
+    
     
     SUBROUTINE cxios_set_domain_data_i_index(domain_hdl, data_i_index, extent1) BIND(C)
@@ -35 +41 @@
       INTEGER (kind = C_INT), VALUE  :: extent1
     END SUBROUTINE cxios_get_domain_data_i_index
+    
+    FUNCTION cxios_is_defined_domain_data_i_index(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_data_i_index
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_data_i_index
     
     
@@ -49 +61 @@
     END SUBROUTINE cxios_get_domain_data_ibegin
     
+    FUNCTION cxios_is_defined_domain_data_ibegin(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_data_ibegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_data_ibegin
+    
     
     SUBROUTINE cxios_set_domain_data_j_index(domain_hdl, data_j_index, extent1) BIND(C)
@@ -63 +81 @@
       INTEGER (kind = C_INT), VALUE  :: extent1
     END SUBROUTINE cxios_get_domain_data_j_index
+    
+    FUNCTION cxios_is_defined_domain_data_j_index(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_data_j_index
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_data_j_index
     
     
@@ -77 +101 @@
     END SUBROUTINE cxios_get_domain_data_jbegin
     
+    FUNCTION cxios_is_defined_domain_data_jbegin(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_data_jbegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_data_jbegin
+    
     
     SUBROUTINE cxios_set_domain_data_n_index(domain_hdl, data_n_index) BIND(C)
@@ -90 +120 @@
     END SUBROUTINE cxios_get_domain_data_n_index
     
+    FUNCTION cxios_is_defined_domain_data_n_index(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_data_n_index
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_data_n_index
+    
     
     SUBROUTINE cxios_set_domain_data_ni(domain_hdl, data_ni) BIND(C)
@@ -103 +139 @@
     END SUBROUTINE cxios_get_domain_data_ni
     
+    FUNCTION cxios_is_defined_domain_data_ni(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_data_ni
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_data_ni
+    
     
     SUBROUTINE cxios_set_domain_data_nj(domain_hdl, data_nj) BIND(C)
@@ -115 +157 @@
       INTEGER (KIND=C_INT)             :: data_nj
     END SUBROUTINE cxios_get_domain_data_nj
+    
+    FUNCTION cxios_is_defined_domain_data_nj(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_data_nj
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_data_nj
     
     
@@ -131 +179 @@
     END SUBROUTINE cxios_get_domain_domain_group_ref
     
+    FUNCTION cxios_is_defined_domain_domain_group_ref(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_domain_group_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_domain_group_ref
+    
     
     SUBROUTINE cxios_set_domain_ibegin(domain_hdl, ibegin) BIND(C)
@@ -144 +198 @@
     END SUBROUTINE cxios_get_domain_ibegin
     
+    FUNCTION cxios_is_defined_domain_ibegin(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_ibegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_ibegin
+    
     
     SUBROUTINE cxios_set_domain_iend(domain_hdl, iend) BIND(C)
@@ -157 +217 @@
     END SUBROUTINE cxios_get_domain_iend
     
+    FUNCTION cxios_is_defined_domain_iend(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_iend
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_iend
+    
     
     SUBROUTINE cxios_set_domain_jbegin(domain_hdl, jbegin) BIND(C)
@@ -170 +236 @@
     END SUBROUTINE cxios_get_domain_jbegin
     
+    FUNCTION cxios_is_defined_domain_jbegin(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_jbegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_jbegin
+    
     
     SUBROUTINE cxios_set_domain_jend(domain_hdl, jend) BIND(C)
@@ -183 +255 @@
     END SUBROUTINE cxios_get_domain_jend
     
+    FUNCTION cxios_is_defined_domain_jend(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_jend
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_jend
+    
     
     SUBROUTINE cxios_set_domain_latvalue(domain_hdl, latvalue, extent1) BIND(C)
@@ -197 +275 @@
       INTEGER (kind = C_INT), VALUE  :: extent1
     END SUBROUTINE cxios_get_domain_latvalue
+    
+    FUNCTION cxios_is_defined_domain_latvalue(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_latvalue
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_latvalue
     
     
@@ -213 +297 @@
     END SUBROUTINE cxios_get_domain_long_name
     
+    FUNCTION cxios_is_defined_domain_long_name(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_long_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_long_name
+    
     
     SUBROUTINE cxios_set_domain_lonvalue(domain_hdl, lonvalue, extent1) BIND(C)
@@ -227 +317 @@
       INTEGER (kind = C_INT), VALUE  :: extent1
     END SUBROUTINE cxios_get_domain_lonvalue
+    
+    FUNCTION cxios_is_defined_domain_lonvalue(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_lonvalue
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_lonvalue
     
     
@@ -244 +340 @@
       INTEGER (kind = C_INT), VALUE  :: extent2
     END SUBROUTINE cxios_get_domain_mask
+    
+    FUNCTION cxios_is_defined_domain_mask(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_mask
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_mask
     
     
@@ -260 +362 @@
     END SUBROUTINE cxios_get_domain_name
     
+    FUNCTION cxios_is_defined_domain_name(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_name
+    
     
     SUBROUTINE cxios_set_domain_ni(domain_hdl, ni) BIND(C)
@@ -273 +381 @@
     END SUBROUTINE cxios_get_domain_ni
     
+    FUNCTION cxios_is_defined_domain_ni(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_ni
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_ni
+    
     
     SUBROUTINE cxios_set_domain_ni_glo(domain_hdl, ni_glo) BIND(C)
@@ -286 +400 @@
     END SUBROUTINE cxios_get_domain_ni_glo
     
+    FUNCTION cxios_is_defined_domain_ni_glo(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_ni_glo
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_ni_glo
+    
     
     SUBROUTINE cxios_set_domain_nj(domain_hdl, nj) BIND(C)
@@ -299 +419 @@
     END SUBROUTINE cxios_get_domain_nj
     
+    FUNCTION cxios_is_defined_domain_nj(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_nj
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_nj
+    
     
     SUBROUTINE cxios_set_domain_nj_glo(domain_hdl, nj_glo) BIND(C)
@@ -311 +437 @@
       INTEGER (KIND=C_INT)             :: nj_glo
     END SUBROUTINE cxios_get_domain_nj_glo
+    
+    FUNCTION cxios_is_defined_domain_nj_glo(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_nj_glo
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_nj_glo
     
     
@@ -327 +459 @@
     END SUBROUTINE cxios_get_domain_standard_name
     
+    FUNCTION cxios_is_defined_domain_standard_name(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_standard_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_standard_name
+    
     
     SUBROUTINE cxios_set_domain_zoom_ibegin(domain_hdl, zoom_ibegin) BIND(C)
@@ -340 +478 @@
     END SUBROUTINE cxios_get_domain_zoom_ibegin
     
+    FUNCTION cxios_is_defined_domain_zoom_ibegin(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_zoom_ibegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_zoom_ibegin
+    
     
     SUBROUTINE cxios_set_domain_zoom_ibegin_loc(domain_hdl, zoom_ibegin_loc) BIND(C)
@@ -353 +497 @@
     END SUBROUTINE cxios_get_domain_zoom_ibegin_loc
     
+    FUNCTION cxios_is_defined_domain_zoom_ibegin_loc(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_zoom_ibegin_loc
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_zoom_ibegin_loc
+    
     
     SUBROUTINE cxios_set_domain_zoom_jbegin(domain_hdl, zoom_jbegin) BIND(C)
@@ -366 +516 @@
     END SUBROUTINE cxios_get_domain_zoom_jbegin
     
+    FUNCTION cxios_is_defined_domain_zoom_jbegin(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_zoom_jbegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_zoom_jbegin
+    
     
     SUBROUTINE cxios_set_domain_zoom_jbegin_loc(domain_hdl, zoom_jbegin_loc) BIND(C)
@@ -379 +535 @@
     END SUBROUTINE cxios_get_domain_zoom_jbegin_loc
     
+    FUNCTION cxios_is_defined_domain_zoom_jbegin_loc(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_zoom_jbegin_loc
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_zoom_jbegin_loc
+    
     
     SUBROUTINE cxios_set_domain_zoom_ni(domain_hdl, zoom_ni) BIND(C)
@@ -392 +554 @@
     END SUBROUTINE cxios_get_domain_zoom_ni
     
+    FUNCTION cxios_is_defined_domain_zoom_ni(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_zoom_ni
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_zoom_ni
+    
     
     SUBROUTINE cxios_set_domain_zoom_ni_loc(domain_hdl, zoom_ni_loc) BIND(C)
@@ -405 +573 @@
     END SUBROUTINE cxios_get_domain_zoom_ni_loc
     
+    FUNCTION cxios_is_defined_domain_zoom_ni_loc(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_zoom_ni_loc
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_zoom_ni_loc
+    
     
     SUBROUTINE cxios_set_domain_zoom_nj(domain_hdl, zoom_nj) BIND(C)
@@ -418 +592 @@
     END SUBROUTINE cxios_get_domain_zoom_nj
     
+    FUNCTION cxios_is_defined_domain_zoom_nj(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_zoom_nj
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_zoom_nj
+    
     
     SUBROUTINE cxios_set_domain_zoom_nj_loc(domain_hdl, zoom_nj_loc) BIND(C)
@@ -430 +610 @@
       INTEGER (KIND=C_INT)             :: zoom_nj_loc
     END SUBROUTINE cxios_get_domain_zoom_nj_loc
+    
+    FUNCTION cxios_is_defined_domain_zoom_nj_loc(domain_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_zoom_nj_loc
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_zoom_nj_loc
     
     

XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.f90

@@ -21 +21 @@
     END SUBROUTINE cxios_get_domaingroup_data_dim
     
+    FUNCTION cxios_is_defined_domaingroup_data_dim(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_data_dim
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_data_dim
+    
     
     SUBROUTINE cxios_set_domaingroup_data_i_index(domaingroup_hdl, data_i_index, extent1) BIND(C)
@@ -35 +41 @@
       INTEGER (kind = C_INT), VALUE  :: extent1
     END SUBROUTINE cxios_get_domaingroup_data_i_index
+    
+    FUNCTION cxios_is_defined_domaingroup_data_i_index(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_data_i_index
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_data_i_index
     
     
@@ -49 +61 @@
     END SUBROUTINE cxios_get_domaingroup_data_ibegin
     
+    FUNCTION cxios_is_defined_domaingroup_data_ibegin(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_data_ibegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_data_ibegin
+    
     
     SUBROUTINE cxios_set_domaingroup_data_j_index(domaingroup_hdl, data_j_index, extent1) BIND(C)
@@ -63 +81 @@
       INTEGER (kind = C_INT), VALUE  :: extent1
     END SUBROUTINE cxios_get_domaingroup_data_j_index
+    
+    FUNCTION cxios_is_defined_domaingroup_data_j_index(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_data_j_index
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_data_j_index
     
     
@@ -77 +101 @@
     END SUBROUTINE cxios_get_domaingroup_data_jbegin
     
+    FUNCTION cxios_is_defined_domaingroup_data_jbegin(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_data_jbegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_data_jbegin
+    
     
     SUBROUTINE cxios_set_domaingroup_data_n_index(domaingroup_hdl, data_n_index) BIND(C)
@@ -90 +120 @@
     END SUBROUTINE cxios_get_domaingroup_data_n_index
     
+    FUNCTION cxios_is_defined_domaingroup_data_n_index(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_data_n_index
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_data_n_index
+    
     
     SUBROUTINE cxios_set_domaingroup_data_ni(domaingroup_hdl, data_ni) BIND(C)
@@ -103 +139 @@
     END SUBROUTINE cxios_get_domaingroup_data_ni
     
+    FUNCTION cxios_is_defined_domaingroup_data_ni(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_data_ni
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_data_ni
+    
     
     SUBROUTINE cxios_set_domaingroup_data_nj(domaingroup_hdl, data_nj) BIND(C)
@@ -115 +157 @@
       INTEGER (KIND=C_INT)             :: data_nj
     END SUBROUTINE cxios_get_domaingroup_data_nj
+    
+    FUNCTION cxios_is_defined_domaingroup_data_nj(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_data_nj
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_data_nj
     
     
@@ -131 +179 @@
     END SUBROUTINE cxios_get_domaingroup_domain_group_ref
     
+    FUNCTION cxios_is_defined_domaingroup_domain_group_ref(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_domain_group_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_domain_group_ref
+    
     
     SUBROUTINE cxios_set_domaingroup_group_ref(domaingroup_hdl, group_ref, group_ref_size) BIND(C)
@@ -146 +200 @@
     END SUBROUTINE cxios_get_domaingroup_group_ref
     
+    FUNCTION cxios_is_defined_domaingroup_group_ref(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_group_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_group_ref
+    
     
     SUBROUTINE cxios_set_domaingroup_ibegin(domaingroup_hdl, ibegin) BIND(C)
@@ -159 +219 @@
     END SUBROUTINE cxios_get_domaingroup_ibegin
     
+    FUNCTION cxios_is_defined_domaingroup_ibegin(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_ibegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_ibegin
+    
     
     SUBROUTINE cxios_set_domaingroup_iend(domaingroup_hdl, iend) BIND(C)
@@ -172 +238 @@
     END SUBROUTINE cxios_get_domaingroup_iend
     
+    FUNCTION cxios_is_defined_domaingroup_iend(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_iend
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_iend
+    
     
     SUBROUTINE cxios_set_domaingroup_jbegin(domaingroup_hdl, jbegin) BIND(C)
@@ -185 +257 @@
     END SUBROUTINE cxios_get_domaingroup_jbegin
     
+    FUNCTION cxios_is_defined_domaingroup_jbegin(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_jbegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_jbegin
+    
     
     SUBROUTINE cxios_set_domaingroup_jend(domaingroup_hdl, jend) BIND(C)
@@ -198 +276 @@
     END SUBROUTINE cxios_get_domaingroup_jend
     
+    FUNCTION cxios_is_defined_domaingroup_jend(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_jend
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_jend
+    
     
     SUBROUTINE cxios_set_domaingroup_latvalue(domaingroup_hdl, latvalue, extent1) BIND(C)
@@ -212 +296 @@
       INTEGER (kind = C_INT), VALUE  :: extent1
     END SUBROUTINE cxios_get_domaingroup_latvalue
+    
+    FUNCTION cxios_is_defined_domaingroup_latvalue(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_latvalue
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_latvalue
     
     
@@ -228 +318 @@
     END SUBROUTINE cxios_get_domaingroup_long_name
     
+    FUNCTION cxios_is_defined_domaingroup_long_name(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_long_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_long_name
+    
     
     SUBROUTINE cxios_set_domaingroup_lonvalue(domaingroup_hdl, lonvalue, extent1) BIND(C)
@@ -242 +338 @@
       INTEGER (kind = C_INT), VALUE  :: extent1
     END SUBROUTINE cxios_get_domaingroup_lonvalue
+    
+    FUNCTION cxios_is_defined_domaingroup_lonvalue(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_lonvalue
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_lonvalue
     
     
@@ -259 +361 @@
       INTEGER (kind = C_INT), VALUE  :: extent2
     END SUBROUTINE cxios_get_domaingroup_mask
+    
+    FUNCTION cxios_is_defined_domaingroup_mask(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_mask
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_mask
     
     
@@ -275 +383 @@
     END SUBROUTINE cxios_get_domaingroup_name
     
+    FUNCTION cxios_is_defined_domaingroup_name(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_name
+    
     
     SUBROUTINE cxios_set_domaingroup_ni(domaingroup_hdl, ni) BIND(C)
@@ -288 +402 @@
     END SUBROUTINE cxios_get_domaingroup_ni
     
+    FUNCTION cxios_is_defined_domaingroup_ni(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_ni
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_ni
+    
     
     SUBROUTINE cxios_set_domaingroup_ni_glo(domaingroup_hdl, ni_glo) BIND(C)
@@ -301 +421 @@
     END SUBROUTINE cxios_get_domaingroup_ni_glo
     
+    FUNCTION cxios_is_defined_domaingroup_ni_glo(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_ni_glo
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_ni_glo
+    
     
     SUBROUTINE cxios_set_domaingroup_nj(domaingroup_hdl, nj) BIND(C)
@@ -314 +440 @@
     END SUBROUTINE cxios_get_domaingroup_nj
     
+    FUNCTION cxios_is_defined_domaingroup_nj(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_nj
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_nj
+    
     
     SUBROUTINE cxios_set_domaingroup_nj_glo(domaingroup_hdl, nj_glo) BIND(C)
@@ -326 +458 @@
       INTEGER (KIND=C_INT)             :: nj_glo
     END SUBROUTINE cxios_get_domaingroup_nj_glo
+    
+    FUNCTION cxios_is_defined_domaingroup_nj_glo(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_nj_glo
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_nj_glo
     
     
@@ -342 +480 @@
     END SUBROUTINE cxios_get_domaingroup_standard_name
     
+    FUNCTION cxios_is_defined_domaingroup_standard_name(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_standard_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_standard_name
+    
     
     SUBROUTINE cxios_set_domaingroup_zoom_ibegin(domaingroup_hdl, zoom_ibegin) BIND(C)
@@ -355 +499 @@
     END SUBROUTINE cxios_get_domaingroup_zoom_ibegin
     
+    FUNCTION cxios_is_defined_domaingroup_zoom_ibegin(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_zoom_ibegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_zoom_ibegin
+    
     
     SUBROUTINE cxios_set_domaingroup_zoom_ibegin_loc(domaingroup_hdl, zoom_ibegin_loc) BIND(C)
@@ -368 +518 @@
     END SUBROUTINE cxios_get_domaingroup_zoom_ibegin_loc
     
+    FUNCTION cxios_is_defined_domaingroup_zoom_ibegin_loc(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_zoom_ibegin_loc
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_zoom_ibegin_loc
+    
     
     SUBROUTINE cxios_set_domaingroup_zoom_jbegin(domaingroup_hdl, zoom_jbegin) BIND(C)
@@ -381 +537 @@
     END SUBROUTINE cxios_get_domaingroup_zoom_jbegin
     
+    FUNCTION cxios_is_defined_domaingroup_zoom_jbegin(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_zoom_jbegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_zoom_jbegin
+    
     
     SUBROUTINE cxios_set_domaingroup_zoom_jbegin_loc(domaingroup_hdl, zoom_jbegin_loc) BIND(C)
@@ -394 +556 @@
     END SUBROUTINE cxios_get_domaingroup_zoom_jbegin_loc
     
+    FUNCTION cxios_is_defined_domaingroup_zoom_jbegin_loc(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_zoom_jbegin_loc
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_zoom_jbegin_loc
+    
     
     SUBROUTINE cxios_set_domaingroup_zoom_ni(domaingroup_hdl, zoom_ni) BIND(C)
@@ -407 +575 @@
     END SUBROUTINE cxios_get_domaingroup_zoom_ni
     
+    FUNCTION cxios_is_defined_domaingroup_zoom_ni(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_zoom_ni
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_zoom_ni
+    
     
     SUBROUTINE cxios_set_domaingroup_zoom_ni_loc(domaingroup_hdl, zoom_ni_loc) BIND(C)
@@ -420 +594 @@
     END SUBROUTINE cxios_get_domaingroup_zoom_ni_loc
     
+    FUNCTION cxios_is_defined_domaingroup_zoom_ni_loc(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_zoom_ni_loc
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_zoom_ni_loc
+    
     
     SUBROUTINE cxios_set_domaingroup_zoom_nj(domaingroup_hdl, zoom_nj) BIND(C)
@@ -433 +613 @@
     END SUBROUTINE cxios_get_domaingroup_zoom_nj
     
+    FUNCTION cxios_is_defined_domaingroup_zoom_nj(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_zoom_nj
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_zoom_nj
+    
     
     SUBROUTINE cxios_set_domaingroup_zoom_nj_loc(domaingroup_hdl, zoom_nj_loc) BIND(C)
@@ -445 +631 @@
       INTEGER (KIND=C_INT)             :: zoom_nj_loc
     END SUBROUTINE cxios_get_domaingroup_zoom_nj_loc
+    
+    FUNCTION cxios_is_defined_domaingroup_zoom_nj_loc(domaingroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_zoom_nj_loc
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_zoom_nj_loc
     
     

XIOS/trunk/src/interface/fortran_attr/field_interface_attr.f90

@@ -23 +23 @@
     END SUBROUTINE cxios_get_field_axis_ref
     
+    FUNCTION cxios_is_defined_field_axis_ref(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_axis_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_axis_ref
+    
     
     SUBROUTINE cxios_set_field_default_value(field_hdl, default_value) BIND(C)
@@ -35 +41 @@
       REAL (KIND=C_DOUBLE)             :: default_value
     END SUBROUTINE cxios_get_field_default_value
+    
+    FUNCTION cxios_is_defined_field_default_value(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_default_value
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_default_value
     
     
@@ -51 +63 @@
     END SUBROUTINE cxios_get_field_domain_ref
     
+    FUNCTION cxios_is_defined_field_domain_ref(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_domain_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_domain_ref
+    
     
     SUBROUTINE cxios_set_field_enabled(field_hdl, enabled) BIND(C)
@@ -63 +81 @@
       LOGICAL (KIND=C_BOOL)             :: enabled
     END SUBROUTINE cxios_get_field_enabled
+    
+    FUNCTION cxios_is_defined_field_enabled(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_enabled
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_enabled
     
     
@@ -79 +103 @@
     END SUBROUTINE cxios_get_field_field_ref
     
+    FUNCTION cxios_is_defined_field_field_ref(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_field_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_field_ref
+    
     
     SUBROUTINE cxios_set_field_freq_offset(field_hdl, freq_offset, freq_offset_size) BIND(C)
@@ -94 +124 @@
     END SUBROUTINE cxios_get_field_freq_offset
     
+    FUNCTION cxios_is_defined_field_freq_offset(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_freq_offset
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_freq_offset
+    
     
     SUBROUTINE cxios_set_field_freq_op(field_hdl, freq_op, freq_op_size) BIND(C)
@@ -109 +145 @@
     END SUBROUTINE cxios_get_field_freq_op
     
+    FUNCTION cxios_is_defined_field_freq_op(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_freq_op
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_freq_op
+    
     
     SUBROUTINE cxios_set_field_grid_ref(field_hdl, grid_ref, grid_ref_size) BIND(C)
@@ -124 +166 @@
     END SUBROUTINE cxios_get_field_grid_ref
     
+    FUNCTION cxios_is_defined_field_grid_ref(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_grid_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_grid_ref
+    
     
     SUBROUTINE cxios_set_field_level(field_hdl, level) BIND(C)
@@ -136 +184 @@
       INTEGER (KIND=C_INT)             :: level
     END SUBROUTINE cxios_get_field_level
+    
+    FUNCTION cxios_is_defined_field_level(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_level
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_level
     
     
@@ -152 +206 @@
     END SUBROUTINE cxios_get_field_long_name
     
+    FUNCTION cxios_is_defined_field_long_name(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_long_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_long_name
+    
     
     SUBROUTINE cxios_set_field_name(field_hdl, name, name_size) BIND(C)
@@ -167 +227 @@
     END SUBROUTINE cxios_get_field_name
     
+    FUNCTION cxios_is_defined_field_name(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_name
+    
     
     SUBROUTINE cxios_set_field_operation(field_hdl, operation, operation_size) BIND(C)
@@ -182 +248 @@
     END SUBROUTINE cxios_get_field_operation
     
+    FUNCTION cxios_is_defined_field_operation(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_operation
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_operation
+    
     
     SUBROUTINE cxios_set_field_prec(field_hdl, prec) BIND(C)
@@ -194 +266 @@
       INTEGER (KIND=C_INT)             :: prec
     END SUBROUTINE cxios_get_field_prec
+    
+    FUNCTION cxios_is_defined_field_prec(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_prec
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_prec
     
     
@@ -210 +288 @@
     END SUBROUTINE cxios_get_field_standard_name
     
+    FUNCTION cxios_is_defined_field_standard_name(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_standard_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_standard_name
+    
     
     SUBROUTINE cxios_set_field_unit(field_hdl, unit, unit_size) BIND(C)
@@ -225 +309 @@
     END SUBROUTINE cxios_get_field_unit
     
+    FUNCTION cxios_is_defined_field_unit(field_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_unit
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_unit
+    
     
     END INTERFACE

XIOS/trunk/src/interface/fortran_attr/fieldgroup_interface_attr.f90

@@ -23 +23 @@
     END SUBROUTINE cxios_get_fieldgroup_axis_ref
     
+    FUNCTION cxios_is_defined_fieldgroup_axis_ref(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_axis_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_axis_ref
+    
     
     SUBROUTINE cxios_set_fieldgroup_default_value(fieldgroup_hdl, default_value) BIND(C)
@@ -35 +41 @@
       REAL (KIND=C_DOUBLE)             :: default_value
     END SUBROUTINE cxios_get_fieldgroup_default_value
+    
+    FUNCTION cxios_is_defined_fieldgroup_default_value(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_default_value
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_default_value
     
     
@@ -51 +63 @@
     END SUBROUTINE cxios_get_fieldgroup_domain_ref
     
+    FUNCTION cxios_is_defined_fieldgroup_domain_ref(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_domain_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_domain_ref
+    
     
     SUBROUTINE cxios_set_fieldgroup_enabled(fieldgroup_hdl, enabled) BIND(C)
@@ -63 +81 @@
       LOGICAL (KIND=C_BOOL)             :: enabled
     END SUBROUTINE cxios_get_fieldgroup_enabled
+    
+    FUNCTION cxios_is_defined_fieldgroup_enabled(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_enabled
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_enabled
     
     
@@ -79 +103 @@
     END SUBROUTINE cxios_get_fieldgroup_field_ref
     
+    FUNCTION cxios_is_defined_fieldgroup_field_ref(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_field_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_field_ref
+    
     
     SUBROUTINE cxios_set_fieldgroup_freq_offset(fieldgroup_hdl, freq_offset, freq_offset_size) BIND(C)
@@ -94 +124 @@
     END SUBROUTINE cxios_get_fieldgroup_freq_offset
     
+    FUNCTION cxios_is_defined_fieldgroup_freq_offset(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_freq_offset
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_freq_offset
+    
     
     SUBROUTINE cxios_set_fieldgroup_freq_op(fieldgroup_hdl, freq_op, freq_op_size) BIND(C)
@@ -109 +145 @@
     END SUBROUTINE cxios_get_fieldgroup_freq_op
     
+    FUNCTION cxios_is_defined_fieldgroup_freq_op(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_freq_op
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_freq_op
+    
     
     SUBROUTINE cxios_set_fieldgroup_grid_ref(fieldgroup_hdl, grid_ref, grid_ref_size) BIND(C)
@@ -124 +166 @@
     END SUBROUTINE cxios_get_fieldgroup_grid_ref
     
+    FUNCTION cxios_is_defined_fieldgroup_grid_ref(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_grid_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_grid_ref
+    
     
     SUBROUTINE cxios_set_fieldgroup_group_ref(fieldgroup_hdl, group_ref, group_ref_size) BIND(C)
@@ -139 +187 @@
     END SUBROUTINE cxios_get_fieldgroup_group_ref
     
+    FUNCTION cxios_is_defined_fieldgroup_group_ref(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_group_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_group_ref
+    
     
     SUBROUTINE cxios_set_fieldgroup_level(fieldgroup_hdl, level) BIND(C)
@@ -151 +205 @@
       INTEGER (KIND=C_INT)             :: level
     END SUBROUTINE cxios_get_fieldgroup_level
+    
+    FUNCTION cxios_is_defined_fieldgroup_level(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_level
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_level
     
     
@@ -167 +227 @@
     END SUBROUTINE cxios_get_fieldgroup_long_name
     
+    FUNCTION cxios_is_defined_fieldgroup_long_name(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_long_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_long_name
+    
     
     SUBROUTINE cxios_set_fieldgroup_name(fieldgroup_hdl, name, name_size) BIND(C)
@@ -182 +248 @@
     END SUBROUTINE cxios_get_fieldgroup_name
     
+    FUNCTION cxios_is_defined_fieldgroup_name(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_name
+    
     
     SUBROUTINE cxios_set_fieldgroup_operation(fieldgroup_hdl, operation, operation_size) BIND(C)
@@ -197 +269 @@
     END SUBROUTINE cxios_get_fieldgroup_operation
     
+    FUNCTION cxios_is_defined_fieldgroup_operation(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_operation
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_operation
+    
     
     SUBROUTINE cxios_set_fieldgroup_prec(fieldgroup_hdl, prec) BIND(C)
@@ -209 +287 @@
       INTEGER (KIND=C_INT)             :: prec
     END SUBROUTINE cxios_get_fieldgroup_prec
+    
+    FUNCTION cxios_is_defined_fieldgroup_prec(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_prec
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_prec
     
     
@@ -225 +309 @@
     END SUBROUTINE cxios_get_fieldgroup_standard_name
     
+    FUNCTION cxios_is_defined_fieldgroup_standard_name(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_standard_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_standard_name
+    
     
     SUBROUTINE cxios_set_fieldgroup_unit(fieldgroup_hdl, unit, unit_size) BIND(C)
@@ -240 +330 @@
     END SUBROUTINE cxios_get_fieldgroup_unit
     
+    FUNCTION cxios_is_defined_fieldgroup_unit(fieldgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_unit
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_unit
+    
     
     END INTERFACE

XIOS/trunk/src/interface/fortran_attr/file_interface_attr.f90

@@ -23 +23 @@
     END SUBROUTINE cxios_get_file_description
     
+    FUNCTION cxios_is_defined_file_description(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_description
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_description
+    
     
     SUBROUTINE cxios_set_file_enabled(file_hdl, enabled) BIND(C)
@@ -36 +42 @@
     END SUBROUTINE cxios_get_file_enabled
     
+    FUNCTION cxios_is_defined_file_enabled(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_enabled
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_enabled
+    
     
     SUBROUTINE cxios_set_file_min_digits(file_hdl, min_digits) BIND(C)
@@ -48 +60 @@
       INTEGER (KIND=C_INT)             :: min_digits
     END SUBROUTINE cxios_get_file_min_digits
+    
+    FUNCTION cxios_is_defined_file_min_digits(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_min_digits
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_min_digits
     
     
@@ -64 +82 @@
     END SUBROUTINE cxios_get_file_name
     
+    FUNCTION cxios_is_defined_file_name(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_name
+    
     
     SUBROUTINE cxios_set_file_name_suffix(file_hdl, name_suffix, name_suffix_size) BIND(C)
@@ -79 +103 @@
     END SUBROUTINE cxios_get_file_name_suffix
     
+    FUNCTION cxios_is_defined_file_name_suffix(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_name_suffix
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_name_suffix
+    
     
     SUBROUTINE cxios_set_file_output_freq(file_hdl, output_freq, output_freq_size) BIND(C)
@@ -94 +124 @@
     END SUBROUTINE cxios_get_file_output_freq
     
+    FUNCTION cxios_is_defined_file_output_freq(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_output_freq
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_output_freq
+    
     
     SUBROUTINE cxios_set_file_output_level(file_hdl, output_level) BIND(C)
@@ -106 +142 @@
       INTEGER (KIND=C_INT)             :: output_level
     END SUBROUTINE cxios_get_file_output_level
+    
+    FUNCTION cxios_is_defined_file_output_level(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_output_level
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_output_level
     
     
@@ -122 +164 @@
     END SUBROUTINE cxios_get_file_par_access
     
+    FUNCTION cxios_is_defined_file_par_access(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_par_access
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_par_access
+    
     
     SUBROUTINE cxios_set_file_split_freq(file_hdl, split_freq, split_freq_size) BIND(C)
@@ -137 +185 @@
     END SUBROUTINE cxios_get_file_split_freq
     
+    FUNCTION cxios_is_defined_file_split_freq(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_split_freq
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_split_freq
+    
+    
+    SUBROUTINE cxios_set_file_split_freq_format(file_hdl, split_freq_format, split_freq_format_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_freq_format
+      INTEGER  (kind = C_INT)     , VALUE        :: split_freq_format_size
+    END SUBROUTINE cxios_set_file_split_freq_format
+    
+    SUBROUTINE cxios_get_file_split_freq_format(file_hdl, split_freq_format, split_freq_format_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_freq_format
+      INTEGER  (kind = C_INT)     , VALUE        :: split_freq_format_size
+    END SUBROUTINE cxios_get_file_split_freq_format
+    
+    FUNCTION cxios_is_defined_file_split_freq_format(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_split_freq_format
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_split_freq_format
+    
     
     SUBROUTINE cxios_set_file_sync_freq(file_hdl, sync_freq, sync_freq_size) BIND(C)
@@ -152 +227 @@
     END SUBROUTINE cxios_get_file_sync_freq
     
+    FUNCTION cxios_is_defined_file_sync_freq(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_sync_freq
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_sync_freq
+    
     
     SUBROUTINE cxios_set_file_type(file_hdl, type, type_size) BIND(C)
@@ -167 +248 @@
     END SUBROUTINE cxios_get_file_type
     
+    FUNCTION cxios_is_defined_file_type(file_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_type
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_type
+    
     
     END INTERFACE

XIOS/trunk/src/interface/fortran_attr/filegroup_interface_attr.f90

@@ -23 +23 @@
     END SUBROUTINE cxios_get_filegroup_description
     
+    FUNCTION cxios_is_defined_filegroup_description(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_description
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_description
+    
     
     SUBROUTINE cxios_set_filegroup_enabled(filegroup_hdl, enabled) BIND(C)
@@ -35 +41 @@
       LOGICAL (KIND=C_BOOL)             :: enabled
     END SUBROUTINE cxios_get_filegroup_enabled
+    
+    FUNCTION cxios_is_defined_filegroup_enabled(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_enabled
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_enabled
     
     
@@ -51 +63 @@
     END SUBROUTINE cxios_get_filegroup_group_ref
     
+    FUNCTION cxios_is_defined_filegroup_group_ref(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_group_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_group_ref
+    
     
     SUBROUTINE cxios_set_filegroup_min_digits(filegroup_hdl, min_digits) BIND(C)
@@ -63 +81 @@
       INTEGER (KIND=C_INT)             :: min_digits
     END SUBROUTINE cxios_get_filegroup_min_digits
+    
+    FUNCTION cxios_is_defined_filegroup_min_digits(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_min_digits
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_min_digits
     
     
@@ -79 +103 @@
     END SUBROUTINE cxios_get_filegroup_name
     
+    FUNCTION cxios_is_defined_filegroup_name(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_name
+    
     
     SUBROUTINE cxios_set_filegroup_name_suffix(filegroup_hdl, name_suffix, name_suffix_size) BIND(C)
@@ -94 +124 @@
     END SUBROUTINE cxios_get_filegroup_name_suffix
     
+    FUNCTION cxios_is_defined_filegroup_name_suffix(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_name_suffix
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_name_suffix
+    
     
     SUBROUTINE cxios_set_filegroup_output_freq(filegroup_hdl, output_freq, output_freq_size) BIND(C)
@@ -109 +145 @@
     END SUBROUTINE cxios_get_filegroup_output_freq
     
+    FUNCTION cxios_is_defined_filegroup_output_freq(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_output_freq
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_output_freq
+    
     
     SUBROUTINE cxios_set_filegroup_output_level(filegroup_hdl, output_level) BIND(C)
@@ -121 +163 @@
       INTEGER (KIND=C_INT)             :: output_level
     END SUBROUTINE cxios_get_filegroup_output_level
+    
+    FUNCTION cxios_is_defined_filegroup_output_level(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_output_level
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_output_level
     
     
@@ -137 +185 @@
     END SUBROUTINE cxios_get_filegroup_par_access
     
+    FUNCTION cxios_is_defined_filegroup_par_access(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_par_access
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_par_access
+    
     
     SUBROUTINE cxios_set_filegroup_split_freq(filegroup_hdl, split_freq, split_freq_size) BIND(C)
@@ -152 +206 @@
     END SUBROUTINE cxios_get_filegroup_split_freq
     
+    FUNCTION cxios_is_defined_filegroup_split_freq(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_split_freq
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_split_freq
+    
+    
+    SUBROUTINE cxios_set_filegroup_split_freq_format(filegroup_hdl, split_freq_format, split_freq_format_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_freq_format
+      INTEGER  (kind = C_INT)     , VALUE        :: split_freq_format_size
+    END SUBROUTINE cxios_set_filegroup_split_freq_format
+    
+    SUBROUTINE cxios_get_filegroup_split_freq_format(filegroup_hdl, split_freq_format, split_freq_format_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_freq_format
+      INTEGER  (kind = C_INT)     , VALUE        :: split_freq_format_size
+    END SUBROUTINE cxios_get_filegroup_split_freq_format
+    
+    FUNCTION cxios_is_defined_filegroup_split_freq_format(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_split_freq_format
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_split_freq_format
+    
     
     SUBROUTINE cxios_set_filegroup_sync_freq(filegroup_hdl, sync_freq, sync_freq_size) BIND(C)
@@ -167 +248 @@
     END SUBROUTINE cxios_get_filegroup_sync_freq
     
+    FUNCTION cxios_is_defined_filegroup_sync_freq(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_sync_freq
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_sync_freq
+    
     
     SUBROUTINE cxios_set_filegroup_type(filegroup_hdl, type, type_size) BIND(C)
@@ -182 +269 @@
     END SUBROUTINE cxios_get_filegroup_type
     
+    FUNCTION cxios_is_defined_filegroup_type(filegroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_type
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_type
+    
     
     END INTERFACE

XIOS/trunk/src/interface/fortran_attr/grid_interface_attr.f90

@@ -23 +23 @@
     END SUBROUTINE cxios_get_grid_axis_ref
     
+    FUNCTION cxios_is_defined_grid_axis_ref(grid_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_axis_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
+    END FUNCTION cxios_is_defined_grid_axis_ref
+    
     
     SUBROUTINE cxios_set_grid_description(grid_hdl, description, description_size) BIND(C)
@@ -38 +44 @@
     END SUBROUTINE cxios_get_grid_description
     
+    FUNCTION cxios_is_defined_grid_description(grid_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_description
+      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
+    END FUNCTION cxios_is_defined_grid_description
+    
     
     SUBROUTINE cxios_set_grid_domain_ref(grid_hdl, domain_ref, domain_ref_size) BIND(C)
@@ -52 +64 @@
       INTEGER  (kind = C_INT)     , VALUE        :: domain_ref_size
     END SUBROUTINE cxios_get_grid_domain_ref
+    
+    FUNCTION cxios_is_defined_grid_domain_ref(grid_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_domain_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
+    END FUNCTION cxios_is_defined_grid_domain_ref
     
     
@@ -72 +90 @@
     END SUBROUTINE cxios_get_grid_mask
     
+    FUNCTION cxios_is_defined_grid_mask(grid_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_mask
+      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
+    END FUNCTION cxios_is_defined_grid_mask
+    
     
     SUBROUTINE cxios_set_grid_name(grid_hdl, name, name_size) BIND(C)
@@ -87 +111 @@
     END SUBROUTINE cxios_get_grid_name
     
+    FUNCTION cxios_is_defined_grid_name(grid_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
+    END FUNCTION cxios_is_defined_grid_name
+    
     
     END INTERFACE

XIOS/trunk/src/interface/fortran_attr/gridgroup_interface_attr.f90

@@ -23 +23 @@
     END SUBROUTINE cxios_get_gridgroup_axis_ref
     
+    FUNCTION cxios_is_defined_gridgroup_axis_ref(gridgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_axis_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl
+    END FUNCTION cxios_is_defined_gridgroup_axis_ref
+    
     
     SUBROUTINE cxios_set_gridgroup_description(gridgroup_hdl, description, description_size) BIND(C)
@@ -37 +43 @@
       INTEGER  (kind = C_INT)     , VALUE        :: description_size
     END SUBROUTINE cxios_get_gridgroup_description
+    
+    FUNCTION cxios_is_defined_gridgroup_description(gridgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_description
+      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl
+    END FUNCTION cxios_is_defined_gridgroup_description
     
     
@@ -53 +65 @@
     END SUBROUTINE cxios_get_gridgroup_domain_ref
     
+    FUNCTION cxios_is_defined_gridgroup_domain_ref(gridgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_domain_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl
+    END FUNCTION cxios_is_defined_gridgroup_domain_ref
+    
     
     SUBROUTINE cxios_set_gridgroup_group_ref(gridgroup_hdl, group_ref, group_ref_size) BIND(C)
@@ -67 +85 @@
       INTEGER  (kind = C_INT)     , VALUE        :: group_ref_size
     END SUBROUTINE cxios_get_gridgroup_group_ref
+    
+    FUNCTION cxios_is_defined_gridgroup_group_ref(gridgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_group_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl
+    END FUNCTION cxios_is_defined_gridgroup_group_ref
     
     
@@ -87 +111 @@
     END SUBROUTINE cxios_get_gridgroup_mask
     
+    FUNCTION cxios_is_defined_gridgroup_mask(gridgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_mask
+      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl
+    END FUNCTION cxios_is_defined_gridgroup_mask
+    
     
     SUBROUTINE cxios_set_gridgroup_name(gridgroup_hdl, name, name_size) BIND(C)
@@ -102 +132 @@
     END SUBROUTINE cxios_get_gridgroup_name
     
+    FUNCTION cxios_is_defined_gridgroup_name(gridgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl
+    END FUNCTION cxios_is_defined_gridgroup_name
+    
     
     END INTERFACE

XIOS/trunk/src/interface/fortran_attr/iaxis_attr.F90

@@ -229 +229 @@
   END SUBROUTINE xios(get_axis_attr_hdl_)
   
+  SUBROUTINE xios(is_defined_axis_attr)  &
+    ( axis_id, long_name, name, positive, size, standard_name, unit, value, zoom_begin, zoom_end  &
+    , zoom_size )
+    
+    IMPLICIT NONE
+      TYPE(txios(axis))  :: axis_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::axis_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: positive
+      LOGICAL(KIND=C_BOOL) :: positive_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: size
+      LOGICAL(KIND=C_BOOL) :: size_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value
+      LOGICAL(KIND=C_BOOL) :: value_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin
+      LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end
+      LOGICAL(KIND=C_BOOL) :: zoom_end_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size
+      LOGICAL(KIND=C_BOOL) :: zoom_size_tmp
+      
+      CALL xios(get_axis_handle)(axis_id,axis_hdl)
+      CALL xios(is_defined_axis_attr_hdl_)   &
+      ( axis_hdl, long_name, name, positive, size, standard_name, unit, value, zoom_begin, zoom_end  &
+      , zoom_size )
+    
+  END SUBROUTINE xios(is_defined_axis_attr)
+  
+  SUBROUTINE xios(is_defined_axis_attr_hdl)  &
+    ( axis_hdl, long_name, name, positive, size, standard_name, unit, value, zoom_begin, zoom_end  &
+    , zoom_size )
+    
+    IMPLICIT NONE
+      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: positive
+      LOGICAL(KIND=C_BOOL) :: positive_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: size
+      LOGICAL(KIND=C_BOOL) :: size_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value
+      LOGICAL(KIND=C_BOOL) :: value_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin
+      LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end
+      LOGICAL(KIND=C_BOOL) :: zoom_end_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size
+      LOGICAL(KIND=C_BOOL) :: zoom_size_tmp
+      
+      CALL xios(is_defined_axis_attr_hdl_)  &
+      ( axis_hdl, long_name, name, positive, size, standard_name, unit, value, zoom_begin, zoom_end  &
+      , zoom_size )
+    
+  END SUBROUTINE xios(is_defined_axis_attr_hdl)
+  
+  SUBROUTINE xios(is_defined_axis_attr_hdl_)   &
+    ( axis_hdl, long_name_, name_, positive_, size_, standard_name_, unit_, value_, zoom_begin_  &
+    , zoom_end_, zoom_size_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
+      LOGICAL(KIND=C_BOOL) :: long_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: positive_
+      LOGICAL(KIND=C_BOOL) :: positive__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: size_
+      LOGICAL(KIND=C_BOOL) :: size__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
+      LOGICAL(KIND=C_BOOL) :: standard_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit_
+      LOGICAL(KIND=C_BOOL) :: unit__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value_
+      LOGICAL(KIND=C_BOOL) :: value__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin_
+      LOGICAL(KIND=C_BOOL) :: zoom_begin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end_
+      LOGICAL(KIND=C_BOOL) :: zoom_end__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size_
+      LOGICAL(KIND=C_BOOL) :: zoom_size__tmp
+      
+      IF (PRESENT(long_name_)) THEN
+        long_name__tmp=cxios_is_defined_axis_long_name(axis_hdl%daddr)
+        long_name_=long_name__tmp
+      ENDIF
+      
+      IF (PRESENT(name_)) THEN
+        name__tmp=cxios_is_defined_axis_name(axis_hdl%daddr)
+        name_=name__tmp
+      ENDIF
+      
+      IF (PRESENT(positive_)) THEN
+        positive__tmp=cxios_is_defined_axis_positive(axis_hdl%daddr)
+        positive_=positive__tmp
+      ENDIF
+      
+      IF (PRESENT(size_)) THEN
+        size__tmp=cxios_is_defined_axis_size(axis_hdl%daddr)
+        size_=size__tmp
+      ENDIF
+      
+      IF (PRESENT(standard_name_)) THEN
+        standard_name__tmp=cxios_is_defined_axis_standard_name(axis_hdl%daddr)
+        standard_name_=standard_name__tmp
+      ENDIF
+      
+      IF (PRESENT(unit_)) THEN
+        unit__tmp=cxios_is_defined_axis_unit(axis_hdl%daddr)
+        unit_=unit__tmp
+      ENDIF
+      
+      IF (PRESENT(value_)) THEN
+        value__tmp=cxios_is_defined_axis_value(axis_hdl%daddr)
+        value_=value__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_begin_)) THEN
+        zoom_begin__tmp=cxios_is_defined_axis_zoom_begin(axis_hdl%daddr)
+        zoom_begin_=zoom_begin__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_end_)) THEN
+        zoom_end__tmp=cxios_is_defined_axis_zoom_end(axis_hdl%daddr)
+        zoom_end_=zoom_end__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_size_)) THEN
+        zoom_size__tmp=cxios_is_defined_axis_zoom_size(axis_hdl%daddr)
+        zoom_size_=zoom_size__tmp
+      ENDIF
+      
+      
+    
+  END SUBROUTINE xios(is_defined_axis_attr_hdl_)
+  
 END MODULE iaxis_attr

XIOS/trunk/src/interface/fortran_attr/iaxisgroup_attr.F90

@@ -243 +243 @@
   END SUBROUTINE xios(get_axisgroup_attr_hdl_)
   
+  SUBROUTINE xios(is_defined_axisgroup_attr)  &
+    ( axisgroup_id, group_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
+    , zoom_end, zoom_size )
+    
+    IMPLICIT NONE
+      TYPE(txios(axisgroup))  :: axisgroup_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::axisgroup_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: positive
+      LOGICAL(KIND=C_BOOL) :: positive_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: size
+      LOGICAL(KIND=C_BOOL) :: size_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value
+      LOGICAL(KIND=C_BOOL) :: value_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin
+      LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end
+      LOGICAL(KIND=C_BOOL) :: zoom_end_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size
+      LOGICAL(KIND=C_BOOL) :: zoom_size_tmp
+      
+      CALL xios(get_axisgroup_handle)(axisgroup_id,axisgroup_hdl)
+      CALL xios(is_defined_axisgroup_attr_hdl_)   &
+      ( axisgroup_hdl, group_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
+      , zoom_end, zoom_size )
+    
+  END SUBROUTINE xios(is_defined_axisgroup_attr)
+  
+  SUBROUTINE xios(is_defined_axisgroup_attr_hdl)  &
+    ( axisgroup_hdl, group_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
+    , zoom_end, zoom_size )
+    
+    IMPLICIT NONE
+      TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: positive
+      LOGICAL(KIND=C_BOOL) :: positive_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: size
+      LOGICAL(KIND=C_BOOL) :: size_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value
+      LOGICAL(KIND=C_BOOL) :: value_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin
+      LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end
+      LOGICAL(KIND=C_BOOL) :: zoom_end_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size
+      LOGICAL(KIND=C_BOOL) :: zoom_size_tmp
+      
+      CALL xios(is_defined_axisgroup_attr_hdl_)  &
+      ( axisgroup_hdl, group_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
+      , zoom_end, zoom_size )
+    
+  END SUBROUTINE xios(is_defined_axisgroup_attr_hdl)
+  
+  SUBROUTINE xios(is_defined_axisgroup_attr_hdl_)   &
+    ( axisgroup_hdl, group_ref_, long_name_, name_, positive_, size_, standard_name_, unit_, value_  &
+    , zoom_begin_, zoom_end_, zoom_size_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_
+      LOGICAL(KIND=C_BOOL) :: group_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
+      LOGICAL(KIND=C_BOOL) :: long_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: positive_
+      LOGICAL(KIND=C_BOOL) :: positive__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: size_
+      LOGICAL(KIND=C_BOOL) :: size__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
+      LOGICAL(KIND=C_BOOL) :: standard_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit_
+      LOGICAL(KIND=C_BOOL) :: unit__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value_
+      LOGICAL(KIND=C_BOOL) :: value__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin_
+      LOGICAL(KIND=C_BOOL) :: zoom_begin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end_
+      LOGICAL(KIND=C_BOOL) :: zoom_end__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size_
+      LOGICAL(KIND=C_BOOL) :: zoom_size__tmp
+      
+      IF (PRESENT(group_ref_)) THEN
+        group_ref__tmp=cxios_is_defined_axisgroup_group_ref(axisgroup_hdl%daddr)
+        group_ref_=group_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(long_name_)) THEN
+        long_name__tmp=cxios_is_defined_axisgroup_long_name(axisgroup_hdl%daddr)
+        long_name_=long_name__tmp
+      ENDIF
+      
+      IF (PRESENT(name_)) THEN
+        name__tmp=cxios_is_defined_axisgroup_name(axisgroup_hdl%daddr)
+        name_=name__tmp
+      ENDIF
+      
+      IF (PRESENT(positive_)) THEN
+        positive__tmp=cxios_is_defined_axisgroup_positive(axisgroup_hdl%daddr)
+        positive_=positive__tmp
+      ENDIF
+      
+      IF (PRESENT(size_)) THEN
+        size__tmp=cxios_is_defined_axisgroup_size(axisgroup_hdl%daddr)
+        size_=size__tmp
+      ENDIF
+      
+      IF (PRESENT(standard_name_)) THEN
+        standard_name__tmp=cxios_is_defined_axisgroup_standard_name(axisgroup_hdl%daddr)
+        standard_name_=standard_name__tmp
+      ENDIF
+      
+      IF (PRESENT(unit_)) THEN
+        unit__tmp=cxios_is_defined_axisgroup_unit(axisgroup_hdl%daddr)
+        unit_=unit__tmp
+      ENDIF
+      
+      IF (PRESENT(value_)) THEN
+        value__tmp=cxios_is_defined_axisgroup_value(axisgroup_hdl%daddr)
+        value_=value__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_begin_)) THEN
+        zoom_begin__tmp=cxios_is_defined_axisgroup_zoom_begin(axisgroup_hdl%daddr)
+        zoom_begin_=zoom_begin__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_end_)) THEN
+        zoom_end__tmp=cxios_is_defined_axisgroup_zoom_end(axisgroup_hdl%daddr)
+        zoom_end_=zoom_end__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_size_)) THEN
+        zoom_size__tmp=cxios_is_defined_axisgroup_zoom_size(axisgroup_hdl%daddr)
+        zoom_size_=zoom_size__tmp
+      ENDIF
+      
+      
+    
+  END SUBROUTINE xios(is_defined_axisgroup_attr_hdl_)
+  
 END MODULE iaxisgroup_attr

XIOS/trunk/src/interface/fortran_attr/icontext_attr.F90

@@ -149 +149 @@
   END SUBROUTINE xios(get_context_attr_hdl_)
   
+  SUBROUTINE xios(is_defined_context_attr)  &
+    ( context_id, calendar_type, output_dir, start_date, time_origin, timestep )
+    
+    IMPLICIT NONE
+      TYPE(txios(context))  :: context_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::context_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: calendar_type
+      LOGICAL(KIND=C_BOOL) :: calendar_type_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_dir
+      LOGICAL(KIND=C_BOOL) :: output_dir_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: start_date
+      LOGICAL(KIND=C_BOOL) :: start_date_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: time_origin
+      LOGICAL(KIND=C_BOOL) :: time_origin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: timestep
+      LOGICAL(KIND=C_BOOL) :: timestep_tmp
+      
+      CALL xios(get_context_handle)(context_id,context_hdl)
+      CALL xios(is_defined_context_attr_hdl_)   &
+      ( context_hdl, calendar_type, output_dir, start_date, time_origin, timestep )
+    
+  END SUBROUTINE xios(is_defined_context_attr)
+  
+  SUBROUTINE xios(is_defined_context_attr_hdl)  &
+    ( context_hdl, calendar_type, output_dir, start_date, time_origin, timestep )
+    
+    IMPLICIT NONE
+      TYPE(txios(context)) , INTENT(IN) :: context_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: calendar_type
+      LOGICAL(KIND=C_BOOL) :: calendar_type_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_dir
+      LOGICAL(KIND=C_BOOL) :: output_dir_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: start_date
+      LOGICAL(KIND=C_BOOL) :: start_date_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: time_origin
+      LOGICAL(KIND=C_BOOL) :: time_origin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: timestep
+      LOGICAL(KIND=C_BOOL) :: timestep_tmp
+      
+      CALL xios(is_defined_context_attr_hdl_)  &
+      ( context_hdl, calendar_type, output_dir, start_date, time_origin, timestep )
+    
+  END SUBROUTINE xios(is_defined_context_attr_hdl)
+  
+  SUBROUTINE xios(is_defined_context_attr_hdl_)   &
+    ( context_hdl, calendar_type_, output_dir_, start_date_, time_origin_, timestep_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(context)) , INTENT(IN) :: context_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: calendar_type_
+      LOGICAL(KIND=C_BOOL) :: calendar_type__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_dir_
+      LOGICAL(KIND=C_BOOL) :: output_dir__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: start_date_
+      LOGICAL(KIND=C_BOOL) :: start_date__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: time_origin_
+      LOGICAL(KIND=C_BOOL) :: time_origin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: timestep_
+      LOGICAL(KIND=C_BOOL) :: timestep__tmp
+      
+      IF (PRESENT(calendar_type_)) THEN
+        calendar_type__tmp=cxios_is_defined_context_calendar_type(context_hdl%daddr)
+        calendar_type_=calendar_type__tmp
+      ENDIF
+      
+      IF (PRESENT(output_dir_)) THEN
+        output_dir__tmp=cxios_is_defined_context_output_dir(context_hdl%daddr)
+        output_dir_=output_dir__tmp
+      ENDIF
+      
+      IF (PRESENT(start_date_)) THEN
+        start_date__tmp=cxios_is_defined_context_start_date(context_hdl%daddr)
+        start_date_=start_date__tmp
+      ENDIF
+      
+      IF (PRESENT(time_origin_)) THEN
+        time_origin__tmp=cxios_is_defined_context_time_origin(context_hdl%daddr)
+        time_origin_=time_origin__tmp
+      ENDIF
+      
+      IF (PRESENT(timestep_)) THEN
+        timestep__tmp=cxios_is_defined_context_timestep(context_hdl%daddr)
+        timestep_=timestep__tmp
+      ENDIF
+      
+      
+    
+  END SUBROUTINE xios(is_defined_context_attr_hdl_)
+  
 END MODULE icontext_attr

XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90

@@ -553 +553 @@
   END SUBROUTINE xios(get_domain_attr_hdl_)
   
+  SUBROUTINE xios(is_defined_domain_attr)  &
+    ( domain_id, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni  &
+    , data_nj, domain_group_ref, ibegin, iend, jbegin, jend, latvalue, long_name, lonvalue, mask  &
+    , name, ni, ni_glo, nj, nj_glo, standard_name, zoom_ibegin, zoom_ibegin_loc, zoom_jbegin, zoom_jbegin_loc  &
+    , zoom_ni, zoom_ni_loc, zoom_nj, zoom_nj_loc )
+    
+    IMPLICIT NONE
+      TYPE(txios(domain))  :: domain_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::domain_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim
+      LOGICAL(KIND=C_BOOL) :: data_dim_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_i_index
+      LOGICAL(KIND=C_BOOL) :: data_i_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ibegin
+      LOGICAL(KIND=C_BOOL) :: data_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_j_index
+      LOGICAL(KIND=C_BOOL) :: data_j_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin
+      LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index
+      LOGICAL(KIND=C_BOOL) :: data_n_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni
+      LOGICAL(KIND=C_BOOL) :: data_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_nj
+      LOGICAL(KIND=C_BOOL) :: data_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_group_ref
+      LOGICAL(KIND=C_BOOL) :: domain_group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin
+      LOGICAL(KIND=C_BOOL) :: ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: iend
+      LOGICAL(KIND=C_BOOL) :: iend_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin
+      LOGICAL(KIND=C_BOOL) :: jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jend
+      LOGICAL(KIND=C_BOOL) :: jend_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue
+      LOGICAL(KIND=C_BOOL) :: latvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue
+      LOGICAL(KIND=C_BOOL) :: lonvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni
+      LOGICAL(KIND=C_BOOL) :: ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni_glo
+      LOGICAL(KIND=C_BOOL) :: ni_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj
+      LOGICAL(KIND=C_BOOL) :: nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo
+      LOGICAL(KIND=C_BOOL) :: nj_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni
+      LOGICAL(KIND=C_BOOL) :: zoom_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_ni_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj
+      LOGICAL(KIND=C_BOOL) :: zoom_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_nj_loc_tmp
+      
+      CALL xios(get_domain_handle)(domain_id,domain_hdl)
+      CALL xios(is_defined_domain_attr_hdl_)   &
+      ( domain_hdl, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni  &
+      , data_nj, domain_group_ref, ibegin, iend, jbegin, jend, latvalue, long_name, lonvalue, mask  &
+      , name, ni, ni_glo, nj, nj_glo, standard_name, zoom_ibegin, zoom_ibegin_loc, zoom_jbegin, zoom_jbegin_loc  &
+      , zoom_ni, zoom_ni_loc, zoom_nj, zoom_nj_loc )
+    
+  END SUBROUTINE xios(is_defined_domain_attr)
+  
+  SUBROUTINE xios(is_defined_domain_attr_hdl)  &
+    ( domain_hdl, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni  &
+    , data_nj, domain_group_ref, ibegin, iend, jbegin, jend, latvalue, long_name, lonvalue, mask  &
+    , name, ni, ni_glo, nj, nj_glo, standard_name, zoom_ibegin, zoom_ibegin_loc, zoom_jbegin, zoom_jbegin_loc  &
+    , zoom_ni, zoom_ni_loc, zoom_nj, zoom_nj_loc )
+    
+    IMPLICIT NONE
+      TYPE(txios(domain)) , INTENT(IN) :: domain_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim
+      LOGICAL(KIND=C_BOOL) :: data_dim_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_i_index
+      LOGICAL(KIND=C_BOOL) :: data_i_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ibegin
+      LOGICAL(KIND=C_BOOL) :: data_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_j_index
+      LOGICAL(KIND=C_BOOL) :: data_j_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin
+      LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index
+      LOGICAL(KIND=C_BOOL) :: data_n_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni
+      LOGICAL(KIND=C_BOOL) :: data_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_nj
+      LOGICAL(KIND=C_BOOL) :: data_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_group_ref
+      LOGICAL(KIND=C_BOOL) :: domain_group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin
+      LOGICAL(KIND=C_BOOL) :: ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: iend
+      LOGICAL(KIND=C_BOOL) :: iend_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin
+      LOGICAL(KIND=C_BOOL) :: jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jend
+      LOGICAL(KIND=C_BOOL) :: jend_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue
+      LOGICAL(KIND=C_BOOL) :: latvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue
+      LOGICAL(KIND=C_BOOL) :: lonvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni
+      LOGICAL(KIND=C_BOOL) :: ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni_glo
+      LOGICAL(KIND=C_BOOL) :: ni_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj
+      LOGICAL(KIND=C_BOOL) :: nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo
+      LOGICAL(KIND=C_BOOL) :: nj_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni
+      LOGICAL(KIND=C_BOOL) :: zoom_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_ni_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj
+      LOGICAL(KIND=C_BOOL) :: zoom_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_nj_loc_tmp
+      
+      CALL xios(is_defined_domain_attr_hdl_)  &
+      ( domain_hdl, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni  &
+      , data_nj, domain_group_ref, ibegin, iend, jbegin, jend, latvalue, long_name, lonvalue, mask  &
+      , name, ni, ni_glo, nj, nj_glo, standard_name, zoom_ibegin, zoom_ibegin_loc, zoom_jbegin, zoom_jbegin_loc  &
+      , zoom_ni, zoom_ni_loc, zoom_nj, zoom_nj_loc )
+    
+  END SUBROUTINE xios(is_defined_domain_attr_hdl)
+  
+  SUBROUTINE xios(is_defined_domain_attr_hdl_)   &
+    ( domain_hdl, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_  &
+    , data_ni_, data_nj_, domain_group_ref_, ibegin_, iend_, jbegin_, jend_, latvalue_, long_name_  &
+    , lonvalue_, mask_, name_, ni_, ni_glo_, nj_, nj_glo_, standard_name_, zoom_ibegin_, zoom_ibegin_loc_  &
+    , zoom_jbegin_, zoom_jbegin_loc_, zoom_ni_, zoom_ni_loc_, zoom_nj_, zoom_nj_loc_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(domain)) , INTENT(IN) :: domain_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim_
+      LOGICAL(KIND=C_BOOL) :: data_dim__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_i_index_
+      LOGICAL(KIND=C_BOOL) :: data_i_index__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ibegin_
+      LOGICAL(KIND=C_BOOL) :: data_ibegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_j_index_
+      LOGICAL(KIND=C_BOOL) :: data_j_index__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin_
+      LOGICAL(KIND=C_BOOL) :: data_jbegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index_
+      LOGICAL(KIND=C_BOOL) :: data_n_index__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni_
+      LOGICAL(KIND=C_BOOL) :: data_ni__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_nj_
+      LOGICAL(KIND=C_BOOL) :: data_nj__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_group_ref_
+      LOGICAL(KIND=C_BOOL) :: domain_group_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin_
+      LOGICAL(KIND=C_BOOL) :: ibegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: iend_
+      LOGICAL(KIND=C_BOOL) :: iend__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin_
+      LOGICAL(KIND=C_BOOL) :: jbegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jend_
+      LOGICAL(KIND=C_BOOL) :: jend__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_
+      LOGICAL(KIND=C_BOOL) :: latvalue__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
+      LOGICAL(KIND=C_BOOL) :: long_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_
+      LOGICAL(KIND=C_BOOL) :: lonvalue__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
+      LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni_
+      LOGICAL(KIND=C_BOOL) :: ni__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni_glo_
+      LOGICAL(KIND=C_BOOL) :: ni_glo__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj_
+      LOGICAL(KIND=C_BOOL) :: nj__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo_
+      LOGICAL(KIND=C_BOOL) :: nj_glo__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
+      LOGICAL(KIND=C_BOOL) :: standard_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin_
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin_loc_
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin_loc__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin_
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin_loc_
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin_loc__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni_
+      LOGICAL(KIND=C_BOOL) :: zoom_ni__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni_loc_
+      LOGICAL(KIND=C_BOOL) :: zoom_ni_loc__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj_
+      LOGICAL(KIND=C_BOOL) :: zoom_nj__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj_loc_
+      LOGICAL(KIND=C_BOOL) :: zoom_nj_loc__tmp
+      
+      IF (PRESENT(data_dim_)) THEN
+        data_dim__tmp=cxios_is_defined_domain_data_dim(domain_hdl%daddr)
+        data_dim_=data_dim__tmp
+      ENDIF
+      
+      IF (PRESENT(data_i_index_)) THEN
+        data_i_index__tmp=cxios_is_defined_domain_data_i_index(domain_hdl%daddr)
+        data_i_index_=data_i_index__tmp
+      ENDIF
+      
+      IF (PRESENT(data_ibegin_)) THEN
+        data_ibegin__tmp=cxios_is_defined_domain_data_ibegin(domain_hdl%daddr)
+        data_ibegin_=data_ibegin__tmp
+      ENDIF
+      
+      IF (PRESENT(data_j_index_)) THEN
+        data_j_index__tmp=cxios_is_defined_domain_data_j_index(domain_hdl%daddr)
+        data_j_index_=data_j_index__tmp
+      ENDIF
+      
+      IF (PRESENT(data_jbegin_)) THEN
+        data_jbegin__tmp=cxios_is_defined_domain_data_jbegin(domain_hdl%daddr)
+        data_jbegin_=data_jbegin__tmp
+      ENDIF
+      
+      IF (PRESENT(data_n_index_)) THEN
+        data_n_index__tmp=cxios_is_defined_domain_data_n_index(domain_hdl%daddr)
+        data_n_index_=data_n_index__tmp
+      ENDIF
+      
+      IF (PRESENT(data_ni_)) THEN
+        data_ni__tmp=cxios_is_defined_domain_data_ni(domain_hdl%daddr)
+        data_ni_=data_ni__tmp
+      ENDIF
+      
+      IF (PRESENT(data_nj_)) THEN
+        data_nj__tmp=cxios_is_defined_domain_data_nj(domain_hdl%daddr)
+        data_nj_=data_nj__tmp
+      ENDIF
+      
+      IF (PRESENT(domain_group_ref_)) THEN
+        domain_group_ref__tmp=cxios_is_defined_domain_domain_group_ref(domain_hdl%daddr)
+        domain_group_ref_=domain_group_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(ibegin_)) THEN
+        ibegin__tmp=cxios_is_defined_domain_ibegin(domain_hdl%daddr)
+        ibegin_=ibegin__tmp
+      ENDIF
+      
+      IF (PRESENT(iend_)) THEN
+        iend__tmp=cxios_is_defined_domain_iend(domain_hdl%daddr)
+        iend_=iend__tmp
+      ENDIF
+      
+      IF (PRESENT(jbegin_)) THEN
+        jbegin__tmp=cxios_is_defined_domain_jbegin(domain_hdl%daddr)
+        jbegin_=jbegin__tmp
+      ENDIF
+      
+      IF (PRESENT(jend_)) THEN
+        jend__tmp=cxios_is_defined_domain_jend(domain_hdl%daddr)
+        jend_=jend__tmp
+      ENDIF
+      
+      IF (PRESENT(latvalue_)) THEN
+        latvalue__tmp=cxios_is_defined_domain_latvalue(domain_hdl%daddr)
+        latvalue_=latvalue__tmp
+      ENDIF
+      
+      IF (PRESENT(long_name_)) THEN
+        long_name__tmp=cxios_is_defined_domain_long_name(domain_hdl%daddr)
+        long_name_=long_name__tmp
+      ENDIF
+      
+      IF (PRESENT(lonvalue_)) THEN
+        lonvalue__tmp=cxios_is_defined_domain_lonvalue(domain_hdl%daddr)
+        lonvalue_=lonvalue__tmp
+      ENDIF
+      
+      IF (PRESENT(mask_)) THEN
+        mask__tmp=cxios_is_defined_domain_mask(domain_hdl%daddr)
+        mask_=mask__tmp
+      ENDIF
+      
+      IF (PRESENT(name_)) THEN
+        name__tmp=cxios_is_defined_domain_name(domain_hdl%daddr)
+        name_=name__tmp
+      ENDIF
+      
+      IF (PRESENT(ni_)) THEN
+        ni__tmp=cxios_is_defined_domain_ni(domain_hdl%daddr)
+        ni_=ni__tmp
+      ENDIF
+      
+      IF (PRESENT(ni_glo_)) THEN
+        ni_glo__tmp=cxios_is_defined_domain_ni_glo(domain_hdl%daddr)
+        ni_glo_=ni_glo__tmp
+      ENDIF
+      
+      IF (PRESENT(nj_)) THEN
+        nj__tmp=cxios_is_defined_domain_nj(domain_hdl%daddr)
+        nj_=nj__tmp
+      ENDIF
+      
+      IF (PRESENT(nj_glo_)) THEN
+        nj_glo__tmp=cxios_is_defined_domain_nj_glo(domain_hdl%daddr)
+        nj_glo_=nj_glo__tmp
+      ENDIF
+      
+      IF (PRESENT(standard_name_)) THEN
+        standard_name__tmp=cxios_is_defined_domain_standard_name(domain_hdl%daddr)
+        standard_name_=standard_name__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_ibegin_)) THEN
+        zoom_ibegin__tmp=cxios_is_defined_domain_zoom_ibegin(domain_hdl%daddr)
+        zoom_ibegin_=zoom_ibegin__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_ibegin_loc_)) THEN
+        zoom_ibegin_loc__tmp=cxios_is_defined_domain_zoom_ibegin_loc(domain_hdl%daddr)
+        zoom_ibegin_loc_=zoom_ibegin_loc__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_jbegin_)) THEN
+        zoom_jbegin__tmp=cxios_is_defined_domain_zoom_jbegin(domain_hdl%daddr)
+        zoom_jbegin_=zoom_jbegin__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_jbegin_loc_)) THEN
+        zoom_jbegin_loc__tmp=cxios_is_defined_domain_zoom_jbegin_loc(domain_hdl%daddr)
+        zoom_jbegin_loc_=zoom_jbegin_loc__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_ni_)) THEN
+        zoom_ni__tmp=cxios_is_defined_domain_zoom_ni(domain_hdl%daddr)
+        zoom_ni_=zoom_ni__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_ni_loc_)) THEN
+        zoom_ni_loc__tmp=cxios_is_defined_domain_zoom_ni_loc(domain_hdl%daddr)
+        zoom_ni_loc_=zoom_ni_loc__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_nj_)) THEN
+        zoom_nj__tmp=cxios_is_defined_domain_zoom_nj(domain_hdl%daddr)
+        zoom_nj_=zoom_nj__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_nj_loc_)) THEN
+        zoom_nj_loc__tmp=cxios_is_defined_domain_zoom_nj_loc(domain_hdl%daddr)
+        zoom_nj_loc_=zoom_nj_loc__tmp
+      ENDIF
+      
+      
+    
+  END SUBROUTINE xios(is_defined_domain_attr_hdl_)
+  
 END MODULE idomain_attr

XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90

@@ -569 +569 @@
   END SUBROUTINE xios(get_domaingroup_attr_hdl_)
   
+  SUBROUTINE xios(is_defined_domaingroup_attr)  &
+    ( domaingroup_id, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index  &
+    , data_ni, data_nj, domain_group_ref, group_ref, ibegin, iend, jbegin, jend, latvalue, long_name  &
+    , lonvalue, mask, name, ni, ni_glo, nj, nj_glo, standard_name, zoom_ibegin, zoom_ibegin_loc  &
+    , zoom_jbegin, zoom_jbegin_loc, zoom_ni, zoom_ni_loc, zoom_nj, zoom_nj_loc )
+    
+    IMPLICIT NONE
+      TYPE(txios(domaingroup))  :: domaingroup_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::domaingroup_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim
+      LOGICAL(KIND=C_BOOL) :: data_dim_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_i_index
+      LOGICAL(KIND=C_BOOL) :: data_i_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ibegin
+      LOGICAL(KIND=C_BOOL) :: data_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_j_index
+      LOGICAL(KIND=C_BOOL) :: data_j_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin
+      LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index
+      LOGICAL(KIND=C_BOOL) :: data_n_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni
+      LOGICAL(KIND=C_BOOL) :: data_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_nj
+      LOGICAL(KIND=C_BOOL) :: data_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_group_ref
+      LOGICAL(KIND=C_BOOL) :: domain_group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin
+      LOGICAL(KIND=C_BOOL) :: ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: iend
+      LOGICAL(KIND=C_BOOL) :: iend_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin
+      LOGICAL(KIND=C_BOOL) :: jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jend
+      LOGICAL(KIND=C_BOOL) :: jend_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue
+      LOGICAL(KIND=C_BOOL) :: latvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue
+      LOGICAL(KIND=C_BOOL) :: lonvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni
+      LOGICAL(KIND=C_BOOL) :: ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni_glo
+      LOGICAL(KIND=C_BOOL) :: ni_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj
+      LOGICAL(KIND=C_BOOL) :: nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo
+      LOGICAL(KIND=C_BOOL) :: nj_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni
+      LOGICAL(KIND=C_BOOL) :: zoom_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_ni_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj
+      LOGICAL(KIND=C_BOOL) :: zoom_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_nj_loc_tmp
+      
+      CALL xios(get_domaingroup_handle)(domaingroup_id,domaingroup_hdl)
+      CALL xios(is_defined_domaingroup_attr_hdl_)   &
+      ( domaingroup_hdl, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index  &
+      , data_ni, data_nj, domain_group_ref, group_ref, ibegin, iend, jbegin, jend, latvalue, long_name  &
+      , lonvalue, mask, name, ni, ni_glo, nj, nj_glo, standard_name, zoom_ibegin, zoom_ibegin_loc  &
+      , zoom_jbegin, zoom_jbegin_loc, zoom_ni, zoom_ni_loc, zoom_nj, zoom_nj_loc )
+    
+  END SUBROUTINE xios(is_defined_domaingroup_attr)
+  
+  SUBROUTINE xios(is_defined_domaingroup_attr_hdl)  &
+    ( domaingroup_hdl, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index  &
+    , data_ni, data_nj, domain_group_ref, group_ref, ibegin, iend, jbegin, jend, latvalue, long_name  &
+    , lonvalue, mask, name, ni, ni_glo, nj, nj_glo, standard_name, zoom_ibegin, zoom_ibegin_loc  &
+    , zoom_jbegin, zoom_jbegin_loc, zoom_ni, zoom_ni_loc, zoom_nj, zoom_nj_loc )
+    
+    IMPLICIT NONE
+      TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim
+      LOGICAL(KIND=C_BOOL) :: data_dim_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_i_index
+      LOGICAL(KIND=C_BOOL) :: data_i_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ibegin
+      LOGICAL(KIND=C_BOOL) :: data_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_j_index
+      LOGICAL(KIND=C_BOOL) :: data_j_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin
+      LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index
+      LOGICAL(KIND=C_BOOL) :: data_n_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni
+      LOGICAL(KIND=C_BOOL) :: data_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_nj
+      LOGICAL(KIND=C_BOOL) :: data_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_group_ref
+      LOGICAL(KIND=C_BOOL) :: domain_group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin
+      LOGICAL(KIND=C_BOOL) :: ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: iend
+      LOGICAL(KIND=C_BOOL) :: iend_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin
+      LOGICAL(KIND=C_BOOL) :: jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jend
+      LOGICAL(KIND=C_BOOL) :: jend_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue
+      LOGICAL(KIND=C_BOOL) :: latvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue
+      LOGICAL(KIND=C_BOOL) :: lonvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni
+      LOGICAL(KIND=C_BOOL) :: ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni_glo
+      LOGICAL(KIND=C_BOOL) :: ni_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj
+      LOGICAL(KIND=C_BOOL) :: nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo
+      LOGICAL(KIND=C_BOOL) :: nj_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni
+      LOGICAL(KIND=C_BOOL) :: zoom_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_ni_loc_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj
+      LOGICAL(KIND=C_BOOL) :: zoom_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj_loc
+      LOGICAL(KIND=C_BOOL) :: zoom_nj_loc_tmp
+      
+      CALL xios(is_defined_domaingroup_attr_hdl_)  &
+      ( domaingroup_hdl, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index  &
+      , data_ni, data_nj, domain_group_ref, group_ref, ibegin, iend, jbegin, jend, latvalue, long_name  &
+      , lonvalue, mask, name, ni, ni_glo, nj, nj_glo, standard_name, zoom_ibegin, zoom_ibegin_loc  &
+      , zoom_jbegin, zoom_jbegin_loc, zoom_ni, zoom_ni_loc, zoom_nj, zoom_nj_loc )
+    
+  END SUBROUTINE xios(is_defined_domaingroup_attr_hdl)
+  
+  SUBROUTINE xios(is_defined_domaingroup_attr_hdl_)   &
+    ( domaingroup_hdl, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_  &
+    , data_ni_, data_nj_, domain_group_ref_, group_ref_, ibegin_, iend_, jbegin_, jend_, latvalue_  &
+    , long_name_, lonvalue_, mask_, name_, ni_, ni_glo_, nj_, nj_glo_, standard_name_, zoom_ibegin_  &
+    , zoom_ibegin_loc_, zoom_jbegin_, zoom_jbegin_loc_, zoom_ni_, zoom_ni_loc_, zoom_nj_, zoom_nj_loc_  &
+     )
+    
+    IMPLICIT NONE
+      TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim_
+      LOGICAL(KIND=C_BOOL) :: data_dim__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_i_index_
+      LOGICAL(KIND=C_BOOL) :: data_i_index__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ibegin_
+      LOGICAL(KIND=C_BOOL) :: data_ibegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_j_index_
+      LOGICAL(KIND=C_BOOL) :: data_j_index__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin_
+      LOGICAL(KIND=C_BOOL) :: data_jbegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index_
+      LOGICAL(KIND=C_BOOL) :: data_n_index__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni_
+      LOGICAL(KIND=C_BOOL) :: data_ni__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_nj_
+      LOGICAL(KIND=C_BOOL) :: data_nj__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_group_ref_
+      LOGICAL(KIND=C_BOOL) :: domain_group_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_
+      LOGICAL(KIND=C_BOOL) :: group_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin_
+      LOGICAL(KIND=C_BOOL) :: ibegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: iend_
+      LOGICAL(KIND=C_BOOL) :: iend__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin_
+      LOGICAL(KIND=C_BOOL) :: jbegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: jend_
+      LOGICAL(KIND=C_BOOL) :: jend__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_
+      LOGICAL(KIND=C_BOOL) :: latvalue__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
+      LOGICAL(KIND=C_BOOL) :: long_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_
+      LOGICAL(KIND=C_BOOL) :: lonvalue__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
+      LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni_
+      LOGICAL(KIND=C_BOOL) :: ni__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ni_glo_
+      LOGICAL(KIND=C_BOOL) :: ni_glo__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj_
+      LOGICAL(KIND=C_BOOL) :: nj__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo_
+      LOGICAL(KIND=C_BOOL) :: nj_glo__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
+      LOGICAL(KIND=C_BOOL) :: standard_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin_
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ibegin_loc_
+      LOGICAL(KIND=C_BOOL) :: zoom_ibegin_loc__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin_
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_jbegin_loc_
+      LOGICAL(KIND=C_BOOL) :: zoom_jbegin_loc__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni_
+      LOGICAL(KIND=C_BOOL) :: zoom_ni__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_ni_loc_
+      LOGICAL(KIND=C_BOOL) :: zoom_ni_loc__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj_
+      LOGICAL(KIND=C_BOOL) :: zoom_nj__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_nj_loc_
+      LOGICAL(KIND=C_BOOL) :: zoom_nj_loc__tmp
+      
+      IF (PRESENT(data_dim_)) THEN
+        data_dim__tmp=cxios_is_defined_domaingroup_data_dim(domaingroup_hdl%daddr)
+        data_dim_=data_dim__tmp
+      ENDIF
+      
+      IF (PRESENT(data_i_index_)) THEN
+        data_i_index__tmp=cxios_is_defined_domaingroup_data_i_index(domaingroup_hdl%daddr)
+        data_i_index_=data_i_index__tmp
+      ENDIF
+      
+      IF (PRESENT(data_ibegin_)) THEN
+        data_ibegin__tmp=cxios_is_defined_domaingroup_data_ibegin(domaingroup_hdl%daddr)
+        data_ibegin_=data_ibegin__tmp
+      ENDIF
+      
+      IF (PRESENT(data_j_index_)) THEN
+        data_j_index__tmp=cxios_is_defined_domaingroup_data_j_index(domaingroup_hdl%daddr)
+        data_j_index_=data_j_index__tmp
+      ENDIF
+      
+      IF (PRESENT(data_jbegin_)) THEN
+        data_jbegin__tmp=cxios_is_defined_domaingroup_data_jbegin(domaingroup_hdl%daddr)
+        data_jbegin_=data_jbegin__tmp
+      ENDIF
+      
+      IF (PRESENT(data_n_index_)) THEN
+        data_n_index__tmp=cxios_is_defined_domaingroup_data_n_index(domaingroup_hdl%daddr)
+        data_n_index_=data_n_index__tmp
+      ENDIF
+      
+      IF (PRESENT(data_ni_)) THEN
+        data_ni__tmp=cxios_is_defined_domaingroup_data_ni(domaingroup_hdl%daddr)
+        data_ni_=data_ni__tmp
+      ENDIF
+      
+      IF (PRESENT(data_nj_)) THEN
+        data_nj__tmp=cxios_is_defined_domaingroup_data_nj(domaingroup_hdl%daddr)
+        data_nj_=data_nj__tmp
+      ENDIF
+      
+      IF (PRESENT(domain_group_ref_)) THEN
+        domain_group_ref__tmp=cxios_is_defined_domaingroup_domain_group_ref(domaingroup_hdl%daddr)
+        domain_group_ref_=domain_group_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(group_ref_)) THEN
+        group_ref__tmp=cxios_is_defined_domaingroup_group_ref(domaingroup_hdl%daddr)
+        group_ref_=group_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(ibegin_)) THEN
+        ibegin__tmp=cxios_is_defined_domaingroup_ibegin(domaingroup_hdl%daddr)
+        ibegin_=ibegin__tmp
+      ENDIF
+      
+      IF (PRESENT(iend_)) THEN
+        iend__tmp=cxios_is_defined_domaingroup_iend(domaingroup_hdl%daddr)
+        iend_=iend__tmp
+      ENDIF
+      
+      IF (PRESENT(jbegin_)) THEN
+        jbegin__tmp=cxios_is_defined_domaingroup_jbegin(domaingroup_hdl%daddr)
+        jbegin_=jbegin__tmp
+      ENDIF
+      
+      IF (PRESENT(jend_)) THEN
+        jend__tmp=cxios_is_defined_domaingroup_jend(domaingroup_hdl%daddr)
+        jend_=jend__tmp
+      ENDIF
+      
+      IF (PRESENT(latvalue_)) THEN
+        latvalue__tmp=cxios_is_defined_domaingroup_latvalue(domaingroup_hdl%daddr)
+        latvalue_=latvalue__tmp
+      ENDIF
+      
+      IF (PRESENT(long_name_)) THEN
+        long_name__tmp=cxios_is_defined_domaingroup_long_name(domaingroup_hdl%daddr)
+        long_name_=long_name__tmp
+      ENDIF
+      
+      IF (PRESENT(lonvalue_)) THEN
+        lonvalue__tmp=cxios_is_defined_domaingroup_lonvalue(domaingroup_hdl%daddr)
+        lonvalue_=lonvalue__tmp
+      ENDIF
+      
+      IF (PRESENT(mask_)) THEN
+        mask__tmp=cxios_is_defined_domaingroup_mask(domaingroup_hdl%daddr)
+        mask_=mask__tmp
+      ENDIF
+      
+      IF (PRESENT(name_)) THEN
+        name__tmp=cxios_is_defined_domaingroup_name(domaingroup_hdl%daddr)
+        name_=name__tmp
+      ENDIF
+      
+      IF (PRESENT(ni_)) THEN
+        ni__tmp=cxios_is_defined_domaingroup_ni(domaingroup_hdl%daddr)
+        ni_=ni__tmp
+      ENDIF
+      
+      IF (PRESENT(ni_glo_)) THEN
+        ni_glo__tmp=cxios_is_defined_domaingroup_ni_glo(domaingroup_hdl%daddr)
+        ni_glo_=ni_glo__tmp
+      ENDIF
+      
+      IF (PRESENT(nj_)) THEN
+        nj__tmp=cxios_is_defined_domaingroup_nj(domaingroup_hdl%daddr)
+        nj_=nj__tmp
+      ENDIF
+      
+      IF (PRESENT(nj_glo_)) THEN
+        nj_glo__tmp=cxios_is_defined_domaingroup_nj_glo(domaingroup_hdl%daddr)
+        nj_glo_=nj_glo__tmp
+      ENDIF
+      
+      IF (PRESENT(standard_name_)) THEN
+        standard_name__tmp=cxios_is_defined_domaingroup_standard_name(domaingroup_hdl%daddr)
+        standard_name_=standard_name__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_ibegin_)) THEN
+        zoom_ibegin__tmp=cxios_is_defined_domaingroup_zoom_ibegin(domaingroup_hdl%daddr)
+        zoom_ibegin_=zoom_ibegin__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_ibegin_loc_)) THEN
+        zoom_ibegin_loc__tmp=cxios_is_defined_domaingroup_zoom_ibegin_loc(domaingroup_hdl%daddr)
+        zoom_ibegin_loc_=zoom_ibegin_loc__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_jbegin_)) THEN
+        zoom_jbegin__tmp=cxios_is_defined_domaingroup_zoom_jbegin(domaingroup_hdl%daddr)
+        zoom_jbegin_=zoom_jbegin__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_jbegin_loc_)) THEN
+        zoom_jbegin_loc__tmp=cxios_is_defined_domaingroup_zoom_jbegin_loc(domaingroup_hdl%daddr)
+        zoom_jbegin_loc_=zoom_jbegin_loc__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_ni_)) THEN
+        zoom_ni__tmp=cxios_is_defined_domaingroup_zoom_ni(domaingroup_hdl%daddr)
+        zoom_ni_=zoom_ni__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_ni_loc_)) THEN
+        zoom_ni_loc__tmp=cxios_is_defined_domaingroup_zoom_ni_loc(domaingroup_hdl%daddr)
+        zoom_ni_loc_=zoom_ni_loc__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_nj_)) THEN
+        zoom_nj__tmp=cxios_is_defined_domaingroup_zoom_nj(domaingroup_hdl%daddr)
+        zoom_nj_=zoom_nj__tmp
+      ENDIF
+      
+      IF (PRESENT(zoom_nj_loc_)) THEN
+        zoom_nj_loc__tmp=cxios_is_defined_domaingroup_zoom_nj_loc(domaingroup_hdl%daddr)
+        zoom_nj_loc_=zoom_nj_loc__tmp
+      ENDIF
+      
+      
+    
+  END SUBROUTINE xios(is_defined_domaingroup_attr_hdl_)
+  
 END MODULE idomaingroup_attr

XIOS/trunk/src/interface/fortran_attr/ifield_attr.F90

@@ -307 +307 @@
   END SUBROUTINE xios(get_field_attr_hdl_)
   
+  SUBROUTINE xios(is_defined_field_attr)  &
+    ( field_id, axis_ref, default_value, domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref  &
+    , level, long_name, name, operation, prec, standard_name, unit )
+    
+    IMPLICIT NONE
+      TYPE(txios(field))  :: field_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::field_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
+      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_value
+      LOGICAL(KIND=C_BOOL) :: default_value_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref
+      LOGICAL(KIND=C_BOOL) :: domain_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled
+      LOGICAL(KIND=C_BOOL) :: enabled_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: field_ref
+      LOGICAL(KIND=C_BOOL) :: field_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_offset
+      LOGICAL(KIND=C_BOOL) :: freq_offset_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_op
+      LOGICAL(KIND=C_BOOL) :: freq_op_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: grid_ref
+      LOGICAL(KIND=C_BOOL) :: grid_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: level
+      LOGICAL(KIND=C_BOOL) :: level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: operation
+      LOGICAL(KIND=C_BOOL) :: operation_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: prec
+      LOGICAL(KIND=C_BOOL) :: prec_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      
+      CALL xios(get_field_handle)(field_id,field_hdl)
+      CALL xios(is_defined_field_attr_hdl_)   &
+      ( field_hdl, axis_ref, default_value, domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref  &
+      , level, long_name, name, operation, prec, standard_name, unit )
+    
+  END SUBROUTINE xios(is_defined_field_attr)
+  
+  SUBROUTINE xios(is_defined_field_attr_hdl)  &
+    ( field_hdl, axis_ref, default_value, domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref  &
+    , level, long_name, name, operation, prec, standard_name, unit )
+    
+    IMPLICIT NONE
+      TYPE(txios(field)) , INTENT(IN) :: field_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
+      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_value
+      LOGICAL(KIND=C_BOOL) :: default_value_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref
+      LOGICAL(KIND=C_BOOL) :: domain_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled
+      LOGICAL(KIND=C_BOOL) :: enabled_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: field_ref
+      LOGICAL(KIND=C_BOOL) :: field_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_offset
+      LOGICAL(KIND=C_BOOL) :: freq_offset_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_op
+      LOGICAL(KIND=C_BOOL) :: freq_op_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: grid_ref
+      LOGICAL(KIND=C_BOOL) :: grid_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: level
+      LOGICAL(KIND=C_BOOL) :: level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: operation
+      LOGICAL(KIND=C_BOOL) :: operation_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: prec
+      LOGICAL(KIND=C_BOOL) :: prec_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      
+      CALL xios(is_defined_field_attr_hdl_)  &
+      ( field_hdl, axis_ref, default_value, domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref  &
+      , level, long_name, name, operation, prec, standard_name, unit )
+    
+  END SUBROUTINE xios(is_defined_field_attr_hdl)
+  
+  SUBROUTINE xios(is_defined_field_attr_hdl_)   &
+    ( field_hdl, axis_ref_, default_value_, domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_  &
+    , grid_ref_, level_, long_name_, name_, operation_, prec_, standard_name_, unit_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(field)) , INTENT(IN) :: field_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_
+      LOGICAL(KIND=C_BOOL) :: axis_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_value_
+      LOGICAL(KIND=C_BOOL) :: default_value__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref_
+      LOGICAL(KIND=C_BOOL) :: domain_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled_
+      LOGICAL(KIND=C_BOOL) :: enabled__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: field_ref_
+      LOGICAL(KIND=C_BOOL) :: field_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_offset_
+      LOGICAL(KIND=C_BOOL) :: freq_offset__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_op_
+      LOGICAL(KIND=C_BOOL) :: freq_op__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: grid_ref_
+      LOGICAL(KIND=C_BOOL) :: grid_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: level_
+      LOGICAL(KIND=C_BOOL) :: level__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
+      LOGICAL(KIND=C_BOOL) :: long_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: operation_
+      LOGICAL(KIND=C_BOOL) :: operation__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: prec_
+      LOGICAL(KIND=C_BOOL) :: prec__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
+      LOGICAL(KIND=C_BOOL) :: standard_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit_
+      LOGICAL(KIND=C_BOOL) :: unit__tmp
+      
+      IF (PRESENT(axis_ref_)) THEN
+        axis_ref__tmp=cxios_is_defined_field_axis_ref(field_hdl%daddr)
+        axis_ref_=axis_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(default_value_)) THEN
+        default_value__tmp=cxios_is_defined_field_default_value(field_hdl%daddr)
+        default_value_=default_value__tmp
+      ENDIF
+      
+      IF (PRESENT(domain_ref_)) THEN
+        domain_ref__tmp=cxios_is_defined_field_domain_ref(field_hdl%daddr)
+        domain_ref_=domain_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(enabled_)) THEN
+        enabled__tmp=cxios_is_defined_field_enabled(field_hdl%daddr)
+        enabled_=enabled__tmp
+      ENDIF
+      
+      IF (PRESENT(field_ref_)) THEN
+        field_ref__tmp=cxios_is_defined_field_field_ref(field_hdl%daddr)
+        field_ref_=field_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(freq_offset_)) THEN
+        freq_offset__tmp=cxios_is_defined_field_freq_offset(field_hdl%daddr)
+        freq_offset_=freq_offset__tmp
+      ENDIF
+      
+      IF (PRESENT(freq_op_)) THEN
+        freq_op__tmp=cxios_is_defined_field_freq_op(field_hdl%daddr)
+        freq_op_=freq_op__tmp
+      ENDIF
+      
+      IF (PRESENT(grid_ref_)) THEN
+        grid_ref__tmp=cxios_is_defined_field_grid_ref(field_hdl%daddr)
+        grid_ref_=grid_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(level_)) THEN
+        level__tmp=cxios_is_defined_field_level(field_hdl%daddr)
+        level_=level__tmp
+      ENDIF
+      
+      IF (PRESENT(long_name_)) THEN
+        long_name__tmp=cxios_is_defined_field_long_name(field_hdl%daddr)
+        long_name_=long_name__tmp
+      ENDIF
+      
+      IF (PRESENT(name_)) THEN
+        name__tmp=cxios_is_defined_field_name(field_hdl%daddr)
+        name_=name__tmp
+      ENDIF
+      
+      IF (PRESENT(operation_)) THEN
+        operation__tmp=cxios_is_defined_field_operation(field_hdl%daddr)
+        operation_=operation__tmp
+      ENDIF
+      
+      IF (PRESENT(prec_)) THEN
+        prec__tmp=cxios_is_defined_field_prec(field_hdl%daddr)
+        prec_=prec__tmp
+      ENDIF
+      
+      IF (PRESENT(standard_name_)) THEN
+        standard_name__tmp=cxios_is_defined_field_standard_name(field_hdl%daddr)
+        standard_name_=standard_name__tmp
+      ENDIF
+      
+      IF (PRESENT(unit_)) THEN
+        unit__tmp=cxios_is_defined_field_unit(field_hdl%daddr)
+        unit_=unit__tmp
+      ENDIF
+      
+      
+    
+  END SUBROUTINE xios(is_defined_field_attr_hdl_)
+  
 END MODULE ifield_attr

XIOS/trunk/src/interface/fortran_attr/ifieldgroup_attr.F90

@@ -323 +323 @@
   END SUBROUTINE xios(get_fieldgroup_attr_hdl_)
   
+  SUBROUTINE xios(is_defined_fieldgroup_attr)  &
+    ( fieldgroup_id, axis_ref, default_value, domain_ref, enabled, field_ref, freq_offset, freq_op  &
+    , grid_ref, group_ref, level, long_name, name, operation, prec, standard_name, unit )
+    
+    IMPLICIT NONE
+      TYPE(txios(fieldgroup))  :: fieldgroup_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::fieldgroup_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
+      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_value
+      LOGICAL(KIND=C_BOOL) :: default_value_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref
+      LOGICAL(KIND=C_BOOL) :: domain_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled
+      LOGICAL(KIND=C_BOOL) :: enabled_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: field_ref
+      LOGICAL(KIND=C_BOOL) :: field_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_offset
+      LOGICAL(KIND=C_BOOL) :: freq_offset_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_op
+      LOGICAL(KIND=C_BOOL) :: freq_op_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: grid_ref
+      LOGICAL(KIND=C_BOOL) :: grid_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: level
+      LOGICAL(KIND=C_BOOL) :: level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: operation
+      LOGICAL(KIND=C_BOOL) :: operation_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: prec
+      LOGICAL(KIND=C_BOOL) :: prec_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      
+      CALL xios(get_fieldgroup_handle)(fieldgroup_id,fieldgroup_hdl)
+      CALL xios(is_defined_fieldgroup_attr_hdl_)   &
+      ( fieldgroup_hdl, axis_ref, default_value, domain_ref, enabled, field_ref, freq_offset, freq_op  &
+      , grid_ref, group_ref, level, long_name, name, operation, prec, standard_name, unit )
+    
+  END SUBROUTINE xios(is_defined_fieldgroup_attr)
+  
+  SUBROUTINE xios(is_defined_fieldgroup_attr_hdl)  &
+    ( fieldgroup_hdl, axis_ref, default_value, domain_ref, enabled, field_ref, freq_offset, freq_op  &
+    , grid_ref, group_ref, level, long_name, name, operation, prec, standard_name, unit )
+    
+    IMPLICIT NONE
+      TYPE(txios(fieldgroup)) , INTENT(IN) :: fieldgroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
+      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_value
+      LOGICAL(KIND=C_BOOL) :: default_value_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref
+      LOGICAL(KIND=C_BOOL) :: domain_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled
+      LOGICAL(KIND=C_BOOL) :: enabled_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: field_ref
+      LOGICAL(KIND=C_BOOL) :: field_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_offset
+      LOGICAL(KIND=C_BOOL) :: freq_offset_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_op
+      LOGICAL(KIND=C_BOOL) :: freq_op_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: grid_ref
+      LOGICAL(KIND=C_BOOL) :: grid_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: level
+      LOGICAL(KIND=C_BOOL) :: level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: operation
+      LOGICAL(KIND=C_BOOL) :: operation_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: prec
+      LOGICAL(KIND=C_BOOL) :: prec_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      
+      CALL xios(is_defined_fieldgroup_attr_hdl_)  &
+      ( fieldgroup_hdl, axis_ref, default_value, domain_ref, enabled, field_ref, freq_offset, freq_op  &
+      , grid_ref, group_ref, level, long_name, name, operation, prec, standard_name, unit )
+    
+  END SUBROUTINE xios(is_defined_fieldgroup_attr_hdl)
+  
+  SUBROUTINE xios(is_defined_fieldgroup_attr_hdl_)   &
+    ( fieldgroup_hdl, axis_ref_, default_value_, domain_ref_, enabled_, field_ref_, freq_offset_  &
+    , freq_op_, grid_ref_, group_ref_, level_, long_name_, name_, operation_, prec_, standard_name_  &
+    , unit_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(fieldgroup)) , INTENT(IN) :: fieldgroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_
+      LOGICAL(KIND=C_BOOL) :: axis_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_value_
+      LOGICAL(KIND=C_BOOL) :: default_value__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref_
+      LOGICAL(KIND=C_BOOL) :: domain_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled_
+      LOGICAL(KIND=C_BOOL) :: enabled__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: field_ref_
+      LOGICAL(KIND=C_BOOL) :: field_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_offset_
+      LOGICAL(KIND=C_BOOL) :: freq_offset__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: freq_op_
+      LOGICAL(KIND=C_BOOL) :: freq_op__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: grid_ref_
+      LOGICAL(KIND=C_BOOL) :: grid_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_
+      LOGICAL(KIND=C_BOOL) :: group_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: level_
+      LOGICAL(KIND=C_BOOL) :: level__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
+      LOGICAL(KIND=C_BOOL) :: long_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: operation_
+      LOGICAL(KIND=C_BOOL) :: operation__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: prec_
+      LOGICAL(KIND=C_BOOL) :: prec__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
+      LOGICAL(KIND=C_BOOL) :: standard_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit_
+      LOGICAL(KIND=C_BOOL) :: unit__tmp
+      
+      IF (PRESENT(axis_ref_)) THEN
+        axis_ref__tmp=cxios_is_defined_fieldgroup_axis_ref(fieldgroup_hdl%daddr)
+        axis_ref_=axis_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(default_value_)) THEN
+        default_value__tmp=cxios_is_defined_fieldgroup_default_value(fieldgroup_hdl%daddr)
+        default_value_=default_value__tmp
+      ENDIF
+      
+      IF (PRESENT(domain_ref_)) THEN
+        domain_ref__tmp=cxios_is_defined_fieldgroup_domain_ref(fieldgroup_hdl%daddr)
+        domain_ref_=domain_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(enabled_)) THEN
+        enabled__tmp=cxios_is_defined_fieldgroup_enabled(fieldgroup_hdl%daddr)
+        enabled_=enabled__tmp
+      ENDIF
+      
+      IF (PRESENT(field_ref_)) THEN
+        field_ref__tmp=cxios_is_defined_fieldgroup_field_ref(fieldgroup_hdl%daddr)
+        field_ref_=field_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(freq_offset_)) THEN
+        freq_offset__tmp=cxios_is_defined_fieldgroup_freq_offset(fieldgroup_hdl%daddr)
+        freq_offset_=freq_offset__tmp
+      ENDIF
+      
+      IF (PRESENT(freq_op_)) THEN
+        freq_op__tmp=cxios_is_defined_fieldgroup_freq_op(fieldgroup_hdl%daddr)
+        freq_op_=freq_op__tmp
+      ENDIF
+      
+      IF (PRESENT(grid_ref_)) THEN
+        grid_ref__tmp=cxios_is_defined_fieldgroup_grid_ref(fieldgroup_hdl%daddr)
+        grid_ref_=grid_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(group_ref_)) THEN
+        group_ref__tmp=cxios_is_defined_fieldgroup_group_ref(fieldgroup_hdl%daddr)
+        group_ref_=group_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(level_)) THEN
+        level__tmp=cxios_is_defined_fieldgroup_level(fieldgroup_hdl%daddr)
+        level_=level__tmp
+      ENDIF
+      
+      IF (PRESENT(long_name_)) THEN
+        long_name__tmp=cxios_is_defined_fieldgroup_long_name(fieldgroup_hdl%daddr)
+        long_name_=long_name__tmp
+      ENDIF
+      
+      IF (PRESENT(name_)) THEN
+        name__tmp=cxios_is_defined_fieldgroup_name(fieldgroup_hdl%daddr)
+        name_=name__tmp
+      ENDIF
+      
+      IF (PRESENT(operation_)) THEN
+        operation__tmp=cxios_is_defined_fieldgroup_operation(fieldgroup_hdl%daddr)
+        operation_=operation__tmp
+      ENDIF
+      
+      IF (PRESENT(prec_)) THEN
+        prec__tmp=cxios_is_defined_fieldgroup_prec(fieldgroup_hdl%daddr)
+        prec_=prec__tmp
+      ENDIF
+      
+      IF (PRESENT(standard_name_)) THEN
+        standard_name__tmp=cxios_is_defined_fieldgroup_standard_name(fieldgroup_hdl%daddr)
+        standard_name_=standard_name__tmp
+      ENDIF
+      
+      IF (PRESENT(unit_)) THEN
+        unit__tmp=cxios_is_defined_fieldgroup_unit(fieldgroup_hdl%daddr)
+        unit_=unit__tmp
+      ENDIF
+      
+      
+    
+  END SUBROUTINE xios(is_defined_fieldgroup_attr_hdl_)
+  
 END MODULE ifieldgroup_attr

XIOS/trunk/src/interface/fortran_attr/ifile_attr.F90

@@ -13 +13 @@
   SUBROUTINE xios(set_file_attr)  &
     ( file_id, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
-    , split_freq, sync_freq, type )
+    , split_freq, split_freq_format, sync_freq, type )
     
     IMPLICIT NONE
@@ -28 +28 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq_format
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: sync_freq
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
@@ -34 +35 @@
       CALL xios(set_file_attr_hdl_)   &
       ( file_hdl, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
-      , split_freq, sync_freq, type )
+      , split_freq, split_freq_format, sync_freq, type )
     
   END SUBROUTINE xios(set_file_attr)
@@ -40 +41 @@
   SUBROUTINE xios(set_file_attr_hdl)  &
     ( file_hdl, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
-    , split_freq, sync_freq, type )
+    , split_freq, split_freq_format, sync_freq, type )
     
     IMPLICIT NONE
@@ -54 +55 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq_format
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: sync_freq
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
@@ -59 +61 @@
       CALL xios(set_file_attr_hdl_)  &
       ( file_hdl, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
-      , split_freq, sync_freq, type )
+      , split_freq, split_freq_format, sync_freq, type )
     
   END SUBROUTINE xios(set_file_attr_hdl)
@@ -65 +67 @@
   SUBROUTINE xios(set_file_attr_hdl_)   &
     ( file_hdl, description_, enabled_, min_digits_, name_, name_suffix_, output_freq_, output_level_  &
-    , par_access_, split_freq_, sync_freq_, type_ )
+    , par_access_, split_freq_, split_freq_format_, sync_freq_, type_ )
     
     IMPLICIT NONE
@@ -79 +81 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq_format_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: sync_freq_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_
@@ -119 +122 @@
       ENDIF
       
+      IF (PRESENT(split_freq_format_)) THEN
+        CALL cxios_set_file_split_freq_format(file_hdl%daddr, split_freq_format_, len(split_freq_format_))
+      ENDIF
+      
       IF (PRESENT(sync_freq_)) THEN
         CALL cxios_set_file_sync_freq(file_hdl%daddr, sync_freq_, len(sync_freq_))
@@ -133 +140 @@
   SUBROUTINE xios(get_file_attr)  &
     ( file_id, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
-    , split_freq, sync_freq, type )
+    , split_freq, split_freq_format, sync_freq, type )
     
     IMPLICIT NONE
@@ -148 +155 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq_format
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: sync_freq
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
@@ -154 +162 @@
       CALL xios(get_file_attr_hdl_)   &
       ( file_hdl, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
-      , split_freq, sync_freq, type )
+      , split_freq, split_freq_format, sync_freq, type )
     
   END SUBROUTINE xios(get_file_attr)
@@ -160 +168 @@
   SUBROUTINE xios(get_file_attr_hdl)  &
     ( file_hdl, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
-    , split_freq, sync_freq, type )
+    , split_freq, split_freq_format, sync_freq, type )
     
     IMPLICIT NONE
@@ -174 +182 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq_format
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: sync_freq
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
@@ -179 +188 @@
       CALL xios(get_file_attr_hdl_)  &
       ( file_hdl, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
-      , split_freq, sync_freq, type )
+      , split_freq, split_freq_format, sync_freq, type )
     
   END SUBROUTINE xios(get_file_attr_hdl)
@@ -185 +194 @@
   SUBROUTINE xios(get_file_attr_hdl_)   &
     ( file_hdl, description_, enabled_, min_digits_, name_, name_suffix_, output_freq_, output_level_  &
-    , par_access_, split_freq_, sync_freq_, type_ )
+    , par_access_, split_freq_, split_freq_format_, sync_freq_, type_ )
     
     IMPLICIT NONE
@@ -199 +208 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq_format_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: sync_freq_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_
@@ -239 +249 @@
       ENDIF
       
+      IF (PRESENT(split_freq_format_)) THEN
+        CALL cxios_get_file_split_freq_format(file_hdl%daddr, split_freq_format_, len(split_freq_format_))
+      ENDIF
+      
       IF (PRESENT(sync_freq_)) THEN
         CALL cxios_get_file_sync_freq(file_hdl%daddr, sync_freq_, len(sync_freq_))
@@ -251 +265 @@
   END SUBROUTINE xios(get_file_attr_hdl_)
   
+  SUBROUTINE xios(is_defined_file_attr)  &
+    ( file_id, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
+    , split_freq, split_freq_format, sync_freq, type )
+    
+    IMPLICIT NONE
+      TYPE(txios(file))  :: file_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::file_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description
+      LOGICAL(KIND=C_BOOL) :: description_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled
+      LOGICAL(KIND=C_BOOL) :: enabled_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: min_digits
+      LOGICAL(KIND=C_BOOL) :: min_digits_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_suffix
+      LOGICAL(KIND=C_BOOL) :: name_suffix_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_freq
+      LOGICAL(KIND=C_BOOL) :: output_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_level
+      LOGICAL(KIND=C_BOOL) :: output_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: par_access
+      LOGICAL(KIND=C_BOOL) :: par_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq
+      LOGICAL(KIND=C_BOOL) :: split_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq_format
+      LOGICAL(KIND=C_BOOL) :: split_freq_format_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: sync_freq
+      LOGICAL(KIND=C_BOOL) :: sync_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type
+      LOGICAL(KIND=C_BOOL) :: type_tmp
+      
+      CALL xios(get_file_handle)(file_id,file_hdl)
+      CALL xios(is_defined_file_attr_hdl_)   &
+      ( file_hdl, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
+      , split_freq, split_freq_format, sync_freq, type )
+    
+  END SUBROUTINE xios(is_defined_file_attr)
+  
+  SUBROUTINE xios(is_defined_file_attr_hdl)  &
+    ( file_hdl, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
+    , split_freq, split_freq_format, sync_freq, type )
+    
+    IMPLICIT NONE
+      TYPE(txios(file)) , INTENT(IN) :: file_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description
+      LOGICAL(KIND=C_BOOL) :: description_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled
+      LOGICAL(KIND=C_BOOL) :: enabled_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: min_digits
+      LOGICAL(KIND=C_BOOL) :: min_digits_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_suffix
+      LOGICAL(KIND=C_BOOL) :: name_suffix_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_freq
+      LOGICAL(KIND=C_BOOL) :: output_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_level
+      LOGICAL(KIND=C_BOOL) :: output_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: par_access
+      LOGICAL(KIND=C_BOOL) :: par_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq
+      LOGICAL(KIND=C_BOOL) :: split_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq_format
+      LOGICAL(KIND=C_BOOL) :: split_freq_format_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: sync_freq
+      LOGICAL(KIND=C_BOOL) :: sync_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type
+      LOGICAL(KIND=C_BOOL) :: type_tmp
+      
+      CALL xios(is_defined_file_attr_hdl_)  &
+      ( file_hdl, description, enabled, min_digits, name, name_suffix, output_freq, output_level, par_access  &
+      , split_freq, split_freq_format, sync_freq, type )
+    
+  END SUBROUTINE xios(is_defined_file_attr_hdl)
+  
+  SUBROUTINE xios(is_defined_file_attr_hdl_)   &
+    ( file_hdl, description_, enabled_, min_digits_, name_, name_suffix_, output_freq_, output_level_  &
+    , par_access_, split_freq_, split_freq_format_, sync_freq_, type_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(file)) , INTENT(IN) :: file_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description_
+      LOGICAL(KIND=C_BOOL) :: description__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled_
+      LOGICAL(KIND=C_BOOL) :: enabled__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: min_digits_
+      LOGICAL(KIND=C_BOOL) :: min_digits__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_suffix_
+      LOGICAL(KIND=C_BOOL) :: name_suffix__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_freq_
+      LOGICAL(KIND=C_BOOL) :: output_freq__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_level_
+      LOGICAL(KIND=C_BOOL) :: output_level__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: par_access_
+      LOGICAL(KIND=C_BOOL) :: par_access__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq_
+      LOGICAL(KIND=C_BOOL) :: split_freq__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq_format_
+      LOGICAL(KIND=C_BOOL) :: split_freq_format__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: sync_freq_
+      LOGICAL(KIND=C_BOOL) :: sync_freq__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type_
+      LOGICAL(KIND=C_BOOL) :: type__tmp
+      
+      IF (PRESENT(description_)) THEN
+        description__tmp=cxios_is_defined_file_description(file_hdl%daddr)
+        description_=description__tmp
+      ENDIF
+      
+      IF (PRESENT(enabled_)) THEN
+        enabled__tmp=cxios_is_defined_file_enabled(file_hdl%daddr)
+        enabled_=enabled__tmp
+      ENDIF
+      
+      IF (PRESENT(min_digits_)) THEN
+        min_digits__tmp=cxios_is_defined_file_min_digits(file_hdl%daddr)
+        min_digits_=min_digits__tmp
+      ENDIF
+      
+      IF (PRESENT(name_)) THEN
+        name__tmp=cxios_is_defined_file_name(file_hdl%daddr)
+        name_=name__tmp
+      ENDIF
+      
+      IF (PRESENT(name_suffix_)) THEN
+        name_suffix__tmp=cxios_is_defined_file_name_suffix(file_hdl%daddr)
+        name_suffix_=name_suffix__tmp
+      ENDIF
+      
+      IF (PRESENT(output_freq_)) THEN
+        output_freq__tmp=cxios_is_defined_file_output_freq(file_hdl%daddr)
+        output_freq_=output_freq__tmp
+      ENDIF
+      
+      IF (PRESENT(output_level_)) THEN
+        output_level__tmp=cxios_is_defined_file_output_level(file_hdl%daddr)
+        output_level_=output_level__tmp
+      ENDIF
+      
+      IF (PRESENT(par_access_)) THEN
+        par_access__tmp=cxios_is_defined_file_par_access(file_hdl%daddr)
+        par_access_=par_access__tmp
+      ENDIF
+      
+      IF (PRESENT(split_freq_)) THEN
+        split_freq__tmp=cxios_is_defined_file_split_freq(file_hdl%daddr)
+        split_freq_=split_freq__tmp
+      ENDIF
+      
+      IF (PRESENT(split_freq_format_)) THEN
+        split_freq_format__tmp=cxios_is_defined_file_split_freq_format(file_hdl%daddr)
+        split_freq_format_=split_freq_format__tmp
+      ENDIF
+      
+      IF (PRESENT(sync_freq_)) THEN
+        sync_freq__tmp=cxios_is_defined_file_sync_freq(file_hdl%daddr)
+        sync_freq_=sync_freq__tmp
+      ENDIF
+      
+      IF (PRESENT(type_)) THEN
+        type__tmp=cxios_is_defined_file_type(file_hdl%daddr)
+        type_=type__tmp
+      ENDIF
+      
+      
+    
+  END SUBROUTINE xios(is_defined_file_attr_hdl_)
+  
 END MODULE ifile_attr

XIOS/trunk/src/interface/fortran_attr/ifilegroup_attr.F90

@@ -13 +13 @@
   SUBROUTINE xios(set_filegroup_attr)  &
     ( filegroup_id, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
-    , output_level, par_access, split_freq, sync_freq, type )
+    , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
     
     IMPLICIT NONE
@@ -29 +29 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq_format
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: sync_freq
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
@@ -35 +36 @@
       CALL xios(set_filegroup_attr_hdl_)   &
       ( filegroup_hdl, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
-      , output_level, par_access, split_freq, sync_freq, type )
+      , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
     
   END SUBROUTINE xios(set_filegroup_attr)
@@ -41 +42 @@
   SUBROUTINE xios(set_filegroup_attr_hdl)  &
     ( filegroup_hdl, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
-    , output_level, par_access, split_freq, sync_freq, type )
+    , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
     
     IMPLICIT NONE
@@ -56 +57 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq_format
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: sync_freq
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
@@ -61 +63 @@
       CALL xios(set_filegroup_attr_hdl_)  &
       ( filegroup_hdl, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
-      , output_level, par_access, split_freq, sync_freq, type )
+      , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
     
   END SUBROUTINE xios(set_filegroup_attr_hdl)
@@ -67 +69 @@
   SUBROUTINE xios(set_filegroup_attr_hdl_)   &
     ( filegroup_hdl, description_, enabled_, group_ref_, min_digits_, name_, name_suffix_, output_freq_  &
-    , output_level_, par_access_, split_freq_, sync_freq_, type_ )
+    , output_level_, par_access_, split_freq_, split_freq_format_, sync_freq_, type_ )
     
     IMPLICIT NONE
@@ -82 +84 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: split_freq_format_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: sync_freq_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_
@@ -126 +129 @@
       ENDIF
       
+      IF (PRESENT(split_freq_format_)) THEN
+        CALL cxios_set_filegroup_split_freq_format(filegroup_hdl%daddr, split_freq_format_, len(split_freq_format_))
+      ENDIF
+      
       IF (PRESENT(sync_freq_)) THEN
         CALL cxios_set_filegroup_sync_freq(filegroup_hdl%daddr, sync_freq_, len(sync_freq_))
@@ -140 +147 @@
   SUBROUTINE xios(get_filegroup_attr)  &
     ( filegroup_id, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
-    , output_level, par_access, split_freq, sync_freq, type )
+    , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
     
     IMPLICIT NONE
@@ -156 +163 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq_format
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: sync_freq
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
@@ -162 +170 @@
       CALL xios(get_filegroup_attr_hdl_)   &
       ( filegroup_hdl, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
-      , output_level, par_access, split_freq, sync_freq, type )
+      , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
     
   END SUBROUTINE xios(get_filegroup_attr)
@@ -168 +176 @@
   SUBROUTINE xios(get_filegroup_attr_hdl)  &
     ( filegroup_hdl, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
-    , output_level, par_access, split_freq, sync_freq, type )
+    , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
     
     IMPLICIT NONE
@@ -183 +191 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq_format
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: sync_freq
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
@@ -188 +197 @@
       CALL xios(get_filegroup_attr_hdl_)  &
       ( filegroup_hdl, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
-      , output_level, par_access, split_freq, sync_freq, type )
+      , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
     
   END SUBROUTINE xios(get_filegroup_attr_hdl)
@@ -194 +203 @@
   SUBROUTINE xios(get_filegroup_attr_hdl_)   &
     ( filegroup_hdl, description_, enabled_, group_ref_, min_digits_, name_, name_suffix_, output_freq_  &
-    , output_level_, par_access_, split_freq_, sync_freq_, type_ )
+    , output_level_, par_access_, split_freq_, split_freq_format_, sync_freq_, type_ )
     
     IMPLICIT NONE
@@ -209 +218 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: split_freq_format_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: sync_freq_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_
@@ -253 +263 @@
       ENDIF
       
+      IF (PRESENT(split_freq_format_)) THEN
+        CALL cxios_get_filegroup_split_freq_format(filegroup_hdl%daddr, split_freq_format_, len(split_freq_format_))
+      ENDIF
+      
       IF (PRESENT(sync_freq_)) THEN
         CALL cxios_get_filegroup_sync_freq(filegroup_hdl%daddr, sync_freq_, len(sync_freq_))
@@ -265 +279 @@
   END SUBROUTINE xios(get_filegroup_attr_hdl_)
   
+  SUBROUTINE xios(is_defined_filegroup_attr)  &
+    ( filegroup_id, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
+    , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
+    
+    IMPLICIT NONE
+      TYPE(txios(filegroup))  :: filegroup_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::filegroup_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description
+      LOGICAL(KIND=C_BOOL) :: description_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled
+      LOGICAL(KIND=C_BOOL) :: enabled_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: min_digits
+      LOGICAL(KIND=C_BOOL) :: min_digits_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_suffix
+      LOGICAL(KIND=C_BOOL) :: name_suffix_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_freq
+      LOGICAL(KIND=C_BOOL) :: output_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_level
+      LOGICAL(KIND=C_BOOL) :: output_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: par_access
+      LOGICAL(KIND=C_BOOL) :: par_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq
+      LOGICAL(KIND=C_BOOL) :: split_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq_format
+      LOGICAL(KIND=C_BOOL) :: split_freq_format_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: sync_freq
+      LOGICAL(KIND=C_BOOL) :: sync_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type
+      LOGICAL(KIND=C_BOOL) :: type_tmp
+      
+      CALL xios(get_filegroup_handle)(filegroup_id,filegroup_hdl)
+      CALL xios(is_defined_filegroup_attr_hdl_)   &
+      ( filegroup_hdl, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
+      , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
+    
+  END SUBROUTINE xios(is_defined_filegroup_attr)
+  
+  SUBROUTINE xios(is_defined_filegroup_attr_hdl)  &
+    ( filegroup_hdl, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
+    , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
+    
+    IMPLICIT NONE
+      TYPE(txios(filegroup)) , INTENT(IN) :: filegroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description
+      LOGICAL(KIND=C_BOOL) :: description_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled
+      LOGICAL(KIND=C_BOOL) :: enabled_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: min_digits
+      LOGICAL(KIND=C_BOOL) :: min_digits_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_suffix
+      LOGICAL(KIND=C_BOOL) :: name_suffix_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_freq
+      LOGICAL(KIND=C_BOOL) :: output_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_level
+      LOGICAL(KIND=C_BOOL) :: output_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: par_access
+      LOGICAL(KIND=C_BOOL) :: par_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq
+      LOGICAL(KIND=C_BOOL) :: split_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq_format
+      LOGICAL(KIND=C_BOOL) :: split_freq_format_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: sync_freq
+      LOGICAL(KIND=C_BOOL) :: sync_freq_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type
+      LOGICAL(KIND=C_BOOL) :: type_tmp
+      
+      CALL xios(is_defined_filegroup_attr_hdl_)  &
+      ( filegroup_hdl, description, enabled, group_ref, min_digits, name, name_suffix, output_freq  &
+      , output_level, par_access, split_freq, split_freq_format, sync_freq, type )
+    
+  END SUBROUTINE xios(is_defined_filegroup_attr_hdl)
+  
+  SUBROUTINE xios(is_defined_filegroup_attr_hdl_)   &
+    ( filegroup_hdl, description_, enabled_, group_ref_, min_digits_, name_, name_suffix_, output_freq_  &
+    , output_level_, par_access_, split_freq_, split_freq_format_, sync_freq_, type_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(filegroup)) , INTENT(IN) :: filegroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description_
+      LOGICAL(KIND=C_BOOL) :: description__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: enabled_
+      LOGICAL(KIND=C_BOOL) :: enabled__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_
+      LOGICAL(KIND=C_BOOL) :: group_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: min_digits_
+      LOGICAL(KIND=C_BOOL) :: min_digits__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_suffix_
+      LOGICAL(KIND=C_BOOL) :: name_suffix__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_freq_
+      LOGICAL(KIND=C_BOOL) :: output_freq__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: output_level_
+      LOGICAL(KIND=C_BOOL) :: output_level__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: par_access_
+      LOGICAL(KIND=C_BOOL) :: par_access__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq_
+      LOGICAL(KIND=C_BOOL) :: split_freq__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: split_freq_format_
+      LOGICAL(KIND=C_BOOL) :: split_freq_format__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: sync_freq_
+      LOGICAL(KIND=C_BOOL) :: sync_freq__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type_
+      LOGICAL(KIND=C_BOOL) :: type__tmp
+      
+      IF (PRESENT(description_)) THEN
+        description__tmp=cxios_is_defined_filegroup_description(filegroup_hdl%daddr)
+        description_=description__tmp
+      ENDIF
+      
+      IF (PRESENT(enabled_)) THEN
+        enabled__tmp=cxios_is_defined_filegroup_enabled(filegroup_hdl%daddr)
+        enabled_=enabled__tmp
+      ENDIF
+      
+      IF (PRESENT(group_ref_)) THEN
+        group_ref__tmp=cxios_is_defined_filegroup_group_ref(filegroup_hdl%daddr)
+        group_ref_=group_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(min_digits_)) THEN
+        min_digits__tmp=cxios_is_defined_filegroup_min_digits(filegroup_hdl%daddr)
+        min_digits_=min_digits__tmp
+      ENDIF
+      
+      IF (PRESENT(name_)) THEN
+        name__tmp=cxios_is_defined_filegroup_name(filegroup_hdl%daddr)
+        name_=name__tmp
+      ENDIF
+      
+      IF (PRESENT(name_suffix_)) THEN
+        name_suffix__tmp=cxios_is_defined_filegroup_name_suffix(filegroup_hdl%daddr)
+        name_suffix_=name_suffix__tmp
+      ENDIF
+      
+      IF (PRESENT(output_freq_)) THEN
+        output_freq__tmp=cxios_is_defined_filegroup_output_freq(filegroup_hdl%daddr)
+        output_freq_=output_freq__tmp
+      ENDIF
+      
+      IF (PRESENT(output_level_)) THEN
+        output_level__tmp=cxios_is_defined_filegroup_output_level(filegroup_hdl%daddr)
+        output_level_=output_level__tmp
+      ENDIF
+      
+      IF (PRESENT(par_access_)) THEN
+        par_access__tmp=cxios_is_defined_filegroup_par_access(filegroup_hdl%daddr)
+        par_access_=par_access__tmp
+      ENDIF
+      
+      IF (PRESENT(split_freq_)) THEN
+        split_freq__tmp=cxios_is_defined_filegroup_split_freq(filegroup_hdl%daddr)
+        split_freq_=split_freq__tmp
+      ENDIF
+      
+      IF (PRESENT(split_freq_format_)) THEN
+        split_freq_format__tmp=cxios_is_defined_filegroup_split_freq_format(filegroup_hdl%daddr)
+        split_freq_format_=split_freq_format__tmp
+      ENDIF
+      
+      IF (PRESENT(sync_freq_)) THEN
+        sync_freq__tmp=cxios_is_defined_filegroup_sync_freq(filegroup_hdl%daddr)
+        sync_freq_=sync_freq__tmp
+      ENDIF
+      
+      IF (PRESENT(type_)) THEN
+        type__tmp=cxios_is_defined_filegroup_type(filegroup_hdl%daddr)
+        type_=type__tmp
+      ENDIF
+      
+      
+    
+  END SUBROUTINE xios(is_defined_filegroup_attr_hdl_)
+  
 END MODULE ifilegroup_attr

XIOS/trunk/src/interface/fortran_attr/igrid_attr.F90

@@ -159 +159 @@
   END SUBROUTINE xios(get_grid_attr_hdl_)
   
+  SUBROUTINE xios(is_defined_grid_attr)  &
+    ( grid_id, axis_ref, description, domain_ref, mask, name )
+    
+    IMPLICIT NONE
+      TYPE(txios(grid))  :: grid_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::grid_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
+      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description
+      LOGICAL(KIND=C_BOOL) :: description_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref
+      LOGICAL(KIND=C_BOOL) :: domain_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      
+      CALL xios(get_grid_handle)(grid_id,grid_hdl)
+      CALL xios(is_defined_grid_attr_hdl_)   &
+      ( grid_hdl, axis_ref, description, domain_ref, mask, name )
+    
+  END SUBROUTINE xios(is_defined_grid_attr)
+  
+  SUBROUTINE xios(is_defined_grid_attr_hdl)  &
+    ( grid_hdl, axis_ref, description, domain_ref, mask, name )
+    
+    IMPLICIT NONE
+      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
+      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description
+      LOGICAL(KIND=C_BOOL) :: description_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref
+      LOGICAL(KIND=C_BOOL) :: domain_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      
+      CALL xios(is_defined_grid_attr_hdl_)  &
+      ( grid_hdl, axis_ref, description, domain_ref, mask, name )
+    
+  END SUBROUTINE xios(is_defined_grid_attr_hdl)
+  
+  SUBROUTINE xios(is_defined_grid_attr_hdl_)   &
+    ( grid_hdl, axis_ref_, description_, domain_ref_, mask_, name_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_
+      LOGICAL(KIND=C_BOOL) :: axis_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description_
+      LOGICAL(KIND=C_BOOL) :: description__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref_
+      LOGICAL(KIND=C_BOOL) :: domain_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
+      LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      
+      IF (PRESENT(axis_ref_)) THEN
+        axis_ref__tmp=cxios_is_defined_grid_axis_ref(grid_hdl%daddr)
+        axis_ref_=axis_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(description_)) THEN
+        description__tmp=cxios_is_defined_grid_description(grid_hdl%daddr)
+        description_=description__tmp
+      ENDIF
+      
+      IF (PRESENT(domain_ref_)) THEN
+        domain_ref__tmp=cxios_is_defined_grid_domain_ref(grid_hdl%daddr)
+        domain_ref_=domain_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(mask_)) THEN
+        mask__tmp=cxios_is_defined_grid_mask(grid_hdl%daddr)
+        mask_=mask__tmp
+      ENDIF
+      
+      IF (PRESENT(name_)) THEN
+        name__tmp=cxios_is_defined_grid_name(grid_hdl%daddr)
+        name_=name__tmp
+      ENDIF
+      
+      
+    
+  END SUBROUTINE xios(is_defined_grid_attr_hdl_)
+  
 END MODULE igrid_attr

XIOS/trunk/src/interface/fortran_attr/igridgroup_attr.F90

@@ -173 +173 @@
   END SUBROUTINE xios(get_gridgroup_attr_hdl_)
   
+  SUBROUTINE xios(is_defined_gridgroup_attr)  &
+    ( gridgroup_id, axis_ref, description, domain_ref, group_ref, mask, name )
+    
+    IMPLICIT NONE
+      TYPE(txios(gridgroup))  :: gridgroup_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::gridgroup_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
+      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description
+      LOGICAL(KIND=C_BOOL) :: description_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref
+      LOGICAL(KIND=C_BOOL) :: domain_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      
+      CALL xios(get_gridgroup_handle)(gridgroup_id,gridgroup_hdl)
+      CALL xios(is_defined_gridgroup_attr_hdl_)   &
+      ( gridgroup_hdl, axis_ref, description, domain_ref, group_ref, mask, name )
+    
+  END SUBROUTINE xios(is_defined_gridgroup_attr)
+  
+  SUBROUTINE xios(is_defined_gridgroup_attr_hdl)  &
+    ( gridgroup_hdl, axis_ref, description, domain_ref, group_ref, mask, name )
+    
+    IMPLICIT NONE
+      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
+      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description
+      LOGICAL(KIND=C_BOOL) :: description_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref
+      LOGICAL(KIND=C_BOOL) :: domain_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      
+      CALL xios(is_defined_gridgroup_attr_hdl_)  &
+      ( gridgroup_hdl, axis_ref, description, domain_ref, group_ref, mask, name )
+    
+  END SUBROUTINE xios(is_defined_gridgroup_attr_hdl)
+  
+  SUBROUTINE xios(is_defined_gridgroup_attr_hdl_)   &
+    ( gridgroup_hdl, axis_ref_, description_, domain_ref_, group_ref_, mask_, name_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_
+      LOGICAL(KIND=C_BOOL) :: axis_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: description_
+      LOGICAL(KIND=C_BOOL) :: description__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref_
+      LOGICAL(KIND=C_BOOL) :: domain_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_
+      LOGICAL(KIND=C_BOOL) :: group_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
+      LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      
+      IF (PRESENT(axis_ref_)) THEN
+        axis_ref__tmp=cxios_is_defined_gridgroup_axis_ref(gridgroup_hdl%daddr)
+        axis_ref_=axis_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(description_)) THEN
+        description__tmp=cxios_is_defined_gridgroup_description(gridgroup_hdl%daddr)
+        description_=description__tmp
+      ENDIF
+      
+      IF (PRESENT(domain_ref_)) THEN
+        domain_ref__tmp=cxios_is_defined_gridgroup_domain_ref(gridgroup_hdl%daddr)
+        domain_ref_=domain_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(group_ref_)) THEN
+        group_ref__tmp=cxios_is_defined_gridgroup_group_ref(gridgroup_hdl%daddr)
+        group_ref_=group_ref__tmp
+      ENDIF
+      
+      IF (PRESENT(mask_)) THEN
+        mask__tmp=cxios_is_defined_gridgroup_mask(gridgroup_hdl%daddr)
+        mask_=mask__tmp
+      ENDIF
+      
+      IF (PRESENT(name_)) THEN
+        name__tmp=cxios_is_defined_gridgroup_name(gridgroup_hdl%daddr)
+        name_=name__tmp
+      ENDIF
+      
+      
+    
+  END SUBROUTINE xios(is_defined_gridgroup_attr_hdl_)
+  
 END MODULE igridgroup_attr

XIOS/trunk/src/object_template_impl.hpp

@@ -393 +393 @@
      oss<<iendl ;
      SuperClassMap::generateFortranInterfaceGet_hdl_(oss,className) ;
+     oss<<iendl ;
+     SuperClassMap::generateFortranInterfaceIsDefined_id(oss,className) ;
+     oss<<iendl ;
+     SuperClassMap::generateFortranInterfaceIsDefined_hdl(oss,className) ;
+     oss<<iendl ;
+     SuperClassMap::generateFortranInterfaceIsDefined_hdl_(oss,className) ;     
      oss<<iendl-- ;
      oss<<"END MODULE i"<<className<<"_attr"<<iendl ;

XIOS/trunk/src/test/test_client.f90

@@ -13 +13 @@
   TYPE(xios_time)      :: dtime
   TYPE(xios_context) :: ctx_hdl
-  INTEGER,PARAMETER :: ni_glo=100 
+  INTEGER,PARAMETER :: ni_glo=100
   INTEGER,PARAMETER :: nj_glo=100 
-  INTEGER,PARAMETER :: llm=3 
-  DOUBLE PRECISION  :: lval(llm)=(/1.0,2.0,3.0/)
+  INTEGER,PARAMETER :: llm=5 
+  DOUBLE PRECISION  :: lval(llm)=1
   TYPE(xios_field) :: field_hdl
   TYPE(xios_fieldgroup) :: fieldgroup_hdl
   TYPE(xios_file) :: file_hdl
-  
+  LOGICAL :: ok
   
   DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo
@@ -98 +98 @@
     print *,"lonvalue",lonvalue ;
 
+    CALL xios_is_defined_field_attr("field_A",enabled=ok)
+    PRINT *,"field_A : attribute enabled is defined ? ",ok
     CALL xios_close_context_definition()