Changeset 313


Ignore:
Timestamp:
02/18/12 22:43:24 (9 years ago)
Author:
ymipsl
Message:

Fortran attribut interface are now automaticaly generated.
Add get attribut fonctionnality from fortran.

YM

Location:
XIOS/trunk
Files:
7 added
41 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/bld.cfg

    r300 r313  
    2828bld::target libxios.a 
    2929#bld::target main_server.exe test_xios.exe  
    30 bld::target server_main.exe test_cs.exe  
     30bld::target generate_fortran_interface.exe server_main.exe test_cs.exe  
    3131bld::exe_dep 
    3232 
  • XIOS/trunk/make_xios

    r301 r313  
    44compil_full="false" 
    55use_oasis="false" 
     6job="1" 
    67 
    78# Traitement de la ligne de commande 
     
    1718         "--debug") compil_mode="debug" ; shift ;; 
    1819         "--arch")  arch=$2     ; shift ; shift ;; 
    19          "--full")  compil_full="true"  ; shift ; shift ;; 
     20         "--full")  compil_full="true"  ; shift ;; 
    2021         "--use_oasis")  use_oasis="true"  ; shift  ;; 
    2122         "--doc")   doc="true"          ; shift ;; 
     23         "--job")   job=$2              ; shift ; shift ;; 
    2224         *)         code="$1"           ; shift ;; 
    2325      esac 
     
    117119if [[ "$compil_full" == "true" ]] 
    118120   then 
    119    fcm build -f 
     121   fcm build -f -j $job 
    120122else 
    121   fcm build 
     123  fcm build -j $job 
    122124fi 
    123125 
  • XIOS/trunk/src/attribute.hpp

    r300 r313  
    5353            virtual void toBinary  (StdOStream & os) const = 0; 
    5454            virtual void fromBinary(StdIStream & is) = 0; 
     55            virtual void generateCInterface(ostream& oss, const string& className) = 0 ; 
     56            virtual void generateFortran2003Interface(ostream& oss, const string& className) = 0 ; 
     57            virtual void generateFortranInterfaceDeclaration_(ostream& oss,const string& className) = 0 ; 
     58            virtual void generateFortranInterfaceDeclaration(ostream& oss,const string& className) = 0 ; 
     59            virtual void generateFortranInterfaceBody_(ostream& oss,const string& className) = 0 ; 
     60            virtual void generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) = 0 ; 
     61            virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) = 0 ; 
     62            virtual void generateFortranInterfaceGetBody_(ostream& oss,const string& className) = 0 ; 
    5563 
     64 
     65             
    5666         protected : 
    5767 
  • XIOS/trunk/src/attribute_map.cpp

    r278 r313  
    11#include "attribute_map.hpp" 
     2#include "indent.hpp" 
    23 
    34namespace xmlioserver 
     
    186187      } 
    187188       
     189      void CAttributeMap::generateCInterface(ostream& oss, const string& className) 
     190      { 
     191         SuperClassMap::const_iterator it = SuperClassMap::begin(), end = SuperClassMap::end(); 
     192         for (; it != end; it++) 
     193         { 
     194           it->second->generateCInterface(oss,className) ; 
     195           oss<<iendl<<iendl ; 
     196         } 
     197      } 
     198 
     199      void CAttributeMap::generateFortran2003Interface(ostream& oss, const string& className) 
     200      { 
     201         SuperClassMap::const_iterator it = SuperClassMap::begin(), end = SuperClassMap::end(); 
     202         for (; it != end; it++) 
     203         { 
     204           it->second->generateFortran2003Interface(oss,className) ; 
     205           oss<<iendl<<iendl ; 
     206         } 
     207      }       
     208       
    188209      ///-------------------------------------------------------------- 
     210 
     211      void CAttributeMap::generateFortranInterface_hdl_(ostream& oss, const string& className) 
     212      { 
     213         oss<<"SUBROUTINE xios(set_"<<className<<"_attr_hdl_)   &"<<iendl++ ; 
     214         ostringstream* oss2 ; 
     215         SuperClassMap::const_iterator it ; 
     216         SuperClassMap::const_iterator begin = SuperClassMap::begin(), end = SuperClassMap::end(); 
     217          
     218         oss2=new ostringstream ; 
     219          
     220         *oss2<<"( "<<className<<"_hdl"  ; 
     221          
     222         for ( it=begin ; it != end; it++)  
     223         { 
     224           *oss2<<", "<<it->second->getName()<<"_" ; 
     225           if (oss2->str().size()>90)  
     226           { 
     227             oss<<oss2->str()<<"  &"<<iendl ; 
     228             delete oss2 ; 
     229             oss2=new ostringstream ; 
     230           } 
     231         } 
     232         *oss2<<" )" ; 
     233         oss<<oss2->str()<<iendl ; 
     234         oss<<iendl ; 
     235         delete oss2 ;  
     236          
     237         oss<<"IMPLICIT NONE"<<iendl++ ; 
     238         oss<<"TYPE(txios("<<className<<")) , INTENT(IN) :: "<<className<<"_hdl"<<iendl ; 
     239          
     240         for (it=begin; it != end; it++) 
     241         { 
     242           it->second->generateFortranInterfaceDeclaration_(oss,className) ; 
     243         } 
     244          
     245         oss<<iendl ; 
     246          
     247         for (it=begin; it != end; it++) 
     248         { 
     249           it->second->generateFortranInterfaceBody_(oss,className) ; 
     250           oss<<iendl ; 
     251         } 
     252          
     253         oss<<iendl--<<iendl-- ; 
     254         oss<<"END SUBROUTINE xios(set_"<<className<<"_attr_hdl_)"<<iendl ; 
     255          
     256      }       
     257 
     258      void CAttributeMap::generateFortranInterfaceGet_hdl_(ostream& oss, const string& className) 
     259      { 
     260         oss<<"SUBROUTINE xios(get_"<<className<<"_attr_hdl_)   &"<<iendl++ ; 
     261         ostringstream* oss2 ; 
     262         SuperClassMap::const_iterator it ; 
     263         SuperClassMap::const_iterator begin = SuperClassMap::begin(), end = SuperClassMap::end(); 
     264          
     265         oss2=new ostringstream ; 
     266          
     267         *oss2<<"( "<<className<<"_hdl"  ; 
     268          
     269         for ( it=begin ; it != end; it++)  
     270         { 
     271           *oss2<<", "<<it->second->getName()<<"_" ; 
     272           if (oss2->str().size()>90)  
     273           { 
     274             oss<<oss2->str()<<"  &"<<iendl ; 
     275             delete oss2 ; 
     276             oss2=new ostringstream ; 
     277           } 
     278         } 
     279         *oss2<<" )" ; 
     280         oss<<oss2->str()<<iendl ; 
     281         oss<<iendl ; 
     282         delete oss2 ;  
     283          
     284         oss<<"IMPLICIT NONE"<<iendl++ ; 
     285         oss<<"TYPE(txios("<<className<<")) , INTENT(IN) :: "<<className<<"_hdl"<<iendl ; 
     286          
     287         for (it=begin; it != end; it++) 
     288         { 
     289           it->second->generateFortranInterfaceGetDeclaration_(oss,className) ; 
     290         } 
     291          
     292         oss<<iendl ; 
     293          
     294         for (it=begin; it != end; it++) 
     295         { 
     296           it->second->generateFortranInterfaceGetBody_(oss,className) ; 
     297           oss<<iendl ; 
     298         } 
     299          
     300         oss<<iendl--<<iendl-- ; 
     301         oss<<"END SUBROUTINE xios(get_"<<className<<"_attr_hdl_)"<<iendl ; 
     302          
     303      }       
     304 
     305      void CAttributeMap::generateFortranInterface_hdl(ostream& oss, const string& className) 
     306      { 
     307         oss<<"SUBROUTINE xios(set_"<<className<<"_attr_hdl)  &"<<iendl++ ; 
     308         ostringstream* oss2 ; 
     309         SuperClassMap::const_iterator it ; 
     310         SuperClassMap::const_iterator begin = SuperClassMap::begin(), end = SuperClassMap::end(); 
     311          
     312         oss2=new ostringstream ; 
     313         *oss2<<"( "<<className<<"_hdl"  ; 
     314         for ( it=begin ; it != end; it++)  
     315         { 
     316           *oss2<<", "<<it->second->getName() ; 
     317           if (oss2->str().size()>90)  
     318           { 
     319             oss<<oss2->str()<<"  &"<<iendl ; 
     320             delete oss2 ; 
     321             oss2=new ostringstream ; 
     322           } 
     323         } 
     324         *oss2<<" )" ; 
     325         oss<<oss2->str()<<iendl ; 
     326         oss<<iendl ; 
     327         delete oss2 ;  
     328         oss2=new ostringstream ; 
     329          
     330         oss<<"IMPLICIT NONE"<<iendl++ ; 
     331         oss<<"TYPE(txios("<<className<<")) , INTENT(IN) :: "<<className<<"_hdl"<<iendl ; 
     332          
     333         for (it=begin; it != end; it++) 
     334         { 
     335           it->second->generateFortranInterfaceDeclaration(oss,className) ; 
     336         } 
     337          
     338         oss<<iendl ; 
     339          
     340         oss<<"CALL xios(set_"<<className<<"_attr_hdl_)  &"<<iendl ; 
     341          
     342         *oss2<<"( "<<className<<"_hdl"  ; 
     343         for ( it=begin ; it != end; it++)  
     344         { 
     345           *oss2<<", "<<it->second->getName() ; 
     346           if (oss2->str().size()>90)  
     347           { 
     348             oss<<oss2->str()<<"  &"<<iendl ; 
     349             delete oss2 ; 
     350             oss2=new ostringstream ; 
     351           } 
     352         } 
     353         *oss2<<" )" ; 
     354         oss<<oss2->str() ; 
     355         delete oss2 ;  
     356          
     357         oss<<iendl--<<iendl-- ; 
     358         oss<<"END SUBROUTINE xios(set_"<<className<<"_attr_hdl)"<<iendl ; 
     359      }       
     360       
     361  
     362      void CAttributeMap::generateFortranInterfaceGet_hdl(ostream& oss, const string& className) 
     363      { 
     364         oss<<"SUBROUTINE xios(get_"<<className<<"_attr_hdl)  &"<<iendl++ ; 
     365         ostringstream* oss2 ; 
     366         SuperClassMap::const_iterator it ; 
     367         SuperClassMap::const_iterator begin = SuperClassMap::begin(), end = SuperClassMap::end(); 
     368          
     369         oss2=new ostringstream ; 
     370         *oss2<<"( "<<className<<"_hdl"  ; 
     371         for ( it=begin ; it != end; it++)  
     372         { 
     373           *oss2<<", "<<it->second->getName() ; 
     374           if (oss2->str().size()>90)  
     375           { 
     376             oss<<oss2->str()<<"  &"<<iendl ; 
     377             delete oss2 ; 
     378             oss2=new ostringstream ; 
     379           } 
     380         } 
     381         *oss2<<" )" ; 
     382         oss<<oss2->str()<<iendl ; 
     383         oss<<iendl ; 
     384         delete oss2 ;  
     385         oss2=new ostringstream ; 
     386          
     387         oss<<"IMPLICIT NONE"<<iendl++ ; 
     388         oss<<"TYPE(txios("<<className<<")) , INTENT(IN) :: "<<className<<"_hdl"<<iendl ; 
     389          
     390         for (it=begin; it != end; it++) 
     391         { 
     392           it->second->generateFortranInterfaceGetDeclaration(oss,className) ; 
     393         } 
     394          
     395         oss<<iendl ; 
     396          
     397         oss<<"CALL xios(get_"<<className<<"_attr_hdl_)  &"<<iendl ; 
     398          
     399         *oss2<<"( "<<className<<"_hdl"  ; 
     400         for ( it=begin ; it != end; it++)  
     401         { 
     402           *oss2<<", "<<it->second->getName() ; 
     403           if (oss2->str().size()>90)  
     404           { 
     405             oss<<oss2->str()<<"  &"<<iendl ; 
     406             delete oss2 ; 
     407             oss2=new ostringstream ; 
     408           } 
     409         } 
     410         *oss2<<" )" ; 
     411         oss<<oss2->str() ; 
     412         delete oss2 ;  
     413          
     414         oss<<iendl--<<iendl-- ; 
     415         oss<<"END SUBROUTINE xios(get_"<<className<<"_attr_hdl)"<<iendl ; 
     416      }       
     417       
     418      void CAttributeMap::generateFortranInterface_id(ostream& oss, const string& className) 
     419      { 
     420         oss<<"SUBROUTINE xios(set_"<<className<<"_attr)  &"<<iendl++ ; 
     421         ostringstream* oss2 ; 
     422         SuperClassMap::const_iterator it ; 
     423         SuperClassMap::const_iterator begin = SuperClassMap::begin(), end = SuperClassMap::end(); 
     424          
     425         oss2=new ostringstream ; 
     426         *oss2<<"( "<<className<<"_id"  ; 
     427         for ( it=begin ; it != end; it++)  
     428         { 
     429           *oss2<<", "<<it->second->getName() ; 
     430           if (oss2->str().size()>90)  
     431           { 
     432             oss<<oss2->str()<<"  &"<<iendl ; 
     433             delete oss2 ; 
     434             oss2=new ostringstream ; 
     435           } 
     436         } 
     437         *oss2<<" )" ; 
     438         oss<<oss2->str()<<iendl ; 
     439         oss<<iendl ; 
     440         delete oss2 ;  
     441         oss2=new ostringstream ; 
     442          
     443         oss<<"IMPLICIT NONE"<<iendl++ ; 
     444 
     445         oss<<"TYPE(txios("<<className<<"))  :: "<<className<<"_hdl"<<iendl ; 
     446         oss<<"CHARACTER(LEN=*), INTENT(IN) ::"<<className<<"_id"<<iendl ; 
     447          
     448         for (it=begin; it != end; it++) 
     449         { 
     450           it->second->generateFortranInterfaceDeclaration(oss,className) ; 
     451         } 
     452          
     453         oss<<iendl ; 
     454         oss<<"CALL xios(get_"<<className<<"_handle)("<<className<<"_id,"<<className<<"_hdl)"<<iendl ;  
     455         oss<<"CALL xios(set_"<<className<<"_attr_hdl_)   &"<<iendl ; 
     456         *oss2<<"( "<<className<<"_hdl"  ; 
     457         for ( it=begin ; it != end; it++)  
     458         { 
     459           *oss2<<", "<<it->second->getName() ; 
     460           if (oss2->str().size()>90)  
     461           { 
     462             oss<<oss2->str()<<"  &"<<iendl ; 
     463             delete oss2 ; 
     464             oss2=new ostringstream ; 
     465           } 
     466         } 
     467         *oss2<<" )" ; 
     468         oss<<oss2->str() ; 
     469         delete oss2 ;  
     470          
     471         oss<<iendl--<<iendl-- ; 
     472         oss<<"END SUBROUTINE xios(set_"<<className<<"_attr)"<<iendl ; 
     473          
     474      }       
     475       
     476      void CAttributeMap::generateFortranInterfaceGet_id(ostream& oss, const string& className) 
     477      { 
     478         oss<<"SUBROUTINE xios(get_"<<className<<"_attr)  &"<<iendl++ ; 
     479         ostringstream* oss2 ; 
     480         SuperClassMap::const_iterator it ; 
     481         SuperClassMap::const_iterator begin = SuperClassMap::begin(), end = SuperClassMap::end(); 
     482          
     483         oss2=new ostringstream ; 
     484         *oss2<<"( "<<className<<"_id"  ; 
     485         for ( it=begin ; it != end; it++)  
     486         { 
     487           *oss2<<", "<<it->second->getName() ; 
     488           if (oss2->str().size()>90)  
     489           { 
     490             oss<<oss2->str()<<"  &"<<iendl ; 
     491             delete oss2 ; 
     492             oss2=new ostringstream ; 
     493           } 
     494         } 
     495         *oss2<<" )" ; 
     496         oss<<oss2->str()<<iendl ; 
     497         oss<<iendl ; 
     498         delete oss2 ;  
     499         oss2=new ostringstream ; 
     500          
     501         oss<<"IMPLICIT NONE"<<iendl++ ; 
     502 
     503         oss<<"TYPE(txios("<<className<<"))  :: "<<className<<"_hdl"<<iendl ; 
     504         oss<<"CHARACTER(LEN=*), INTENT(IN) ::"<<className<<"_id"<<iendl ; 
     505          
     506         for (it=begin; it != end; it++) 
     507         { 
     508           it->second->generateFortranInterfaceGetDeclaration(oss,className) ; 
     509         } 
     510          
     511         oss<<iendl ; 
     512         oss<<"CALL xios(get_"<<className<<"_handle)("<<className<<"_id,"<<className<<"_hdl)"<<iendl ;  
     513         oss<<"CALL xios(get_"<<className<<"_attr_hdl_)   &"<<iendl ; 
     514         *oss2<<"( "<<className<<"_hdl"  ; 
     515         for ( it=begin ; it != end; it++)  
     516         { 
     517           *oss2<<", "<<it->second->getName() ; 
     518           if (oss2->str().size()>90)  
     519           { 
     520             oss<<oss2->str()<<"  &"<<iendl ; 
     521             delete oss2 ; 
     522             oss2=new ostringstream ; 
     523           } 
     524         } 
     525         *oss2<<" )" ; 
     526         oss<<oss2->str() ; 
     527         delete oss2 ;  
     528          
     529         oss<<iendl--<<iendl-- ; 
     530         oss<<"END SUBROUTINE xios(get_"<<className<<"_attr)"<<iendl ; 
     531          
     532      }       
     533      ///-------------------------------------------------------------- 
     534   
    189535 
    190536   } // namespace tree 
  • XIOS/trunk/src/attribute_map.hpp

    r219 r313  
    4848            virtual void toBinary  (StdOStream & os) const; 
    4949            virtual void fromBinary(StdIStream & is); 
     50            virtual void generateCInterface(ostream& oss, const string& className) ; 
     51            virtual void generateFortran2003Interface(ostream& oss, const string& className) ; 
     52            virtual void generateFortranInterface_hdl_(ostream& oss, const string& className) ; 
     53            virtual void generateFortranInterface_hdl(ostream& oss, const string& className) ; 
     54            virtual void generateFortranInterface_id(ostream& oss, const string& className) ; 
     55            virtual void generateFortranInterfaceGet_hdl_(ostream& oss, const string& className) ; 
     56            virtual void generateFortranInterfaceGet_hdl(ostream& oss, const string& className) ; 
     57            virtual void generateFortranInterfaceGet_id(ostream& oss, const string& className) ; 
    5058 
    5159         protected : 
  • XIOS/trunk/src/attribute_template.hpp

    r300 r313  
    6464            virtual bool fromBuffer(CBufferIn& buffer) ; 
    6565            virtual size_t size(void) const; 
    66     
     66            virtual void generateCInterface(ostream& oss,const string& className) ; 
     67            virtual void generateFortran2003Interface(ostream& oss,const string& className) ; 
     68            virtual void generateFortranInterfaceDeclaration_(ostream& oss,const string& className) ; 
     69            virtual void generateFortranInterfaceBody_(ostream& oss,const string& className) ; 
     70            virtual void generateFortranInterfaceDeclaration(ostream& oss,const string& className) ; 
     71            virtual void generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) ; 
     72            virtual void generateFortranInterfaceGetBody_(ostream& oss,const string& className) ; 
     73            virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) ; 
    6774 
     75       
    6876         protected : 
    6977 
  • XIOS/trunk/src/attribute_template_impl.hpp

    r300 r313  
    66#include "buffer_in.hpp" 
    77#include "buffer_out.hpp" 
    8  
     8#include "generate_interface_impl.hpp" 
     9 
     10 
     11   
    912namespace xmlioserver 
    1013{ 
     14 
    1115   namespace tree 
    1216   { 
     
    181185      } 
    182186 
     187      template <typename T> 
     188      void CAttributeTemplate<T>::generateCInterface(ostream& oss,const string& className) 
     189      { 
     190        CInterface::AttributeCInterface<T>(oss, className, this->getName()) ; 
     191      } 
     192       
     193      template <typename T> 
     194      void CAttributeTemplate<T>::generateFortran2003Interface(ostream& oss,const string& className) 
     195      { 
     196        CInterface::AttributeFortran2003Interface<T>(oss, className, this->getName()) ; 
     197      } 
     198       
     199      template <typename T> 
     200      void CAttributeTemplate<T>::generateFortranInterfaceDeclaration_(ostream& oss,const string& className) 
     201      { 
     202        CInterface::AttributeFortranInterfaceDeclaration<T>(oss, className, this->getName()+"_") ; 
     203      } 
     204  
     205      template <typename T> 
     206      void CAttributeTemplate<T>::generateFortranInterfaceBody_(ostream& oss,const string& className) 
     207      { 
     208        CInterface::AttributeFortranInterfaceBody<T>(oss, className, this->getName()) ; 
     209      } 
     210 
     211      template <typename T> 
     212      void CAttributeTemplate<T>::generateFortranInterfaceDeclaration(ostream& oss,const string& className) 
     213      { 
     214        CInterface::AttributeFortranInterfaceDeclaration<T>(oss, className, this->getName()) ; 
     215      } 
     216       
     217      template <typename T> 
     218      void CAttributeTemplate<T>::generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) 
     219      { 
     220        CInterface::AttributeFortranInterfaceGetDeclaration<T>(oss, className, this->getName()+"_") ; 
     221      } 
     222  
     223      template <typename T> 
     224      void CAttributeTemplate<T>::generateFortranInterfaceGetBody_(ostream& oss,const string& className) 
     225      { 
     226        CInterface::AttributeFortranInterfaceGetBody<T>(oss, className, this->getName()) ; 
     227      } 
     228 
     229      template <typename T> 
     230      void CAttributeTemplate<T>::generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) 
     231      { 
     232        CInterface::AttributeFortranInterfaceGetDeclaration<T>(oss, className, this->getName()) ; 
     233      } 
     234  
     235       
    183236      //--------------------------------------------------------------- 
    184237 
  • XIOS/trunk/src/config/axis_attribute.conf

    r219 r313  
    66 
    77DECLARE_ATTRIBUTE(int,       size) 
    8 DECLARE_ATTRIBUTE(ARRAY(double, 1), zvalue) 
     8DECLARE_ATTRIBUTE(ARRAY(double, 1), value) 
    99 
    1010 
  • XIOS/trunk/src/fortran/axis_interface.f90

    r286 r313  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55      
    6       SUBROUTINE cxios_set_axis_name(axis_hdl, name, name_size) BIND(C) 
    7          USE ISO_C_BINDING 
    8          INTEGER  (kind = C_INTPTR_T), VALUE        :: axis_hdl 
    9          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    10          INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE cxios_set_axis_name 
    12  
    13       SUBROUTINE cxios_set_axis_standard_name(axis_hdl, standard_name, standard_name_size) BIND(C) 
    14          USE ISO_C_BINDING 
    15          INTEGER  (kind = C_INTPTR_T), VALUE        :: axis_hdl 
    16          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    17          INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE cxios_set_axis_standard_name 
    19  
    20       SUBROUTINE cxios_set_axis_long_name(axis_hdl, long_name, long_name_size) BIND(C) 
    21          USE ISO_C_BINDING 
    22          INTEGER  (kind = C_INTPTR_T), VALUE       :: axis_hdl 
    23          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name 
    24          INTEGER  (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE cxios_set_axis_long_name 
    26  
    27       SUBROUTINE cxios_set_axis_unit(axis_hdl, unit, unit_size) BIND(C) 
    28          USE ISO_C_BINDING 
    29          INTEGER  (kind = C_INTPTR_T), VALUE       :: axis_hdl 
    30          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit 
    31          INTEGER  (kind = C_INT)     , VALUE        :: unit_size 
    32       END SUBROUTINE cxios_set_axis_unit 
    33  
    34       SUBROUTINE cxios_set_axis_size(axis_hdl, size) BIND(C) 
    35          USE ISO_C_BINDING 
    36          INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    37          INTEGER (kind = C_INT)     , VALUE :: size 
    38       END SUBROUTINE cxios_set_axis_size 
    39  
    40       SUBROUTINE cxios_set_axis_zvalue(axis_hdl, zvalue, zvalue_extent1) BIND(C) 
    41          USE ISO_C_BINDING 
    42          INTEGER (kind = C_INTPTR_T), VALUE        :: axis_hdl 
    43          REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: zvalue 
    44          INTEGER (kind = C_INT)     , VALUE        :: zvalue_extent1 
    45       END SUBROUTINE cxios_set_axis_zvalue 
    46        
    476      SUBROUTINE cxios_axis_handle_create(ret, idt, idt_size) BIND(C) 
    487         USE ISO_C_BINDING 
  • XIOS/trunk/src/fortran/axisgroup_interface.f90

    r286 r313  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55      
    6       SUBROUTINE cxios_set_axisgroup_name(axisgroup_hdl, name, name_size) BIND(C) 
    7          USE ISO_C_BINDING 
    8          INTEGER  (kind = C_INTPTR_T), VALUE        :: axisgroup_hdl 
    9          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    10          INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE cxios_set_axisgroup_name 
    12  
    13       SUBROUTINE cxios_set_axisgroup_standard_name(axisgroup_hdl, standard_name, standard_name_size) BIND(C) 
    14          USE ISO_C_BINDING 
    15          INTEGER  (kind = C_INTPTR_T), VALUE        :: axisgroup_hdl 
    16          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    17          INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE cxios_set_axisgroup_standard_name 
    19  
    20       SUBROUTINE cxios_set_axisgroup_long_name(axisgroup_hdl, long_name, long_name_size) BIND(C) 
    21          USE ISO_C_BINDING 
    22          INTEGER  (kind = C_INTPTR_T), VALUE        :: axisgroup_hdl 
    23          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name 
    24          INTEGER  (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE cxios_set_axisgroup_long_name 
    26  
    27       SUBROUTINE cxios_set_axisgroup_unit(axisgroup_hdl, unit, unit_size) BIND(C) 
    28          USE ISO_C_BINDING 
    29          INTEGER  (kind = C_INTPTR_T), VALUE        :: axisgroup_hdl 
    30          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit 
    31          INTEGER  (kind = C_INT)     , VALUE        :: unit_size 
    32       END SUBROUTINE cxios_set_axisgroup_unit 
    33  
    34       SUBROUTINE cxios_set_axisgroup_size(axisgroup_hdl, size) BIND(C) 
    35          USE ISO_C_BINDING 
    36          INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    37          INTEGER (kind = C_INT)     , VALUE :: size 
    38       END SUBROUTINE cxios_set_axisgroup_size 
    39  
    40       SUBROUTINE cxios_set_axisgroup_zvalue(axisgroup_hdl, zvalue, zvalue_extent1) BIND(C) 
    41          USE ISO_C_BINDING 
    42          INTEGER (kind = C_INTPTR_T), VALUE        :: axisgroup_hdl 
    43          REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: zvalue 
    44          INTEGER (kind = C_INT)     , VALUE        :: zvalue_extent1 
    45       END SUBROUTINE cxios_set_axisgroup_zvalue 
    466   
    477      SUBROUTINE cxios_axisgroup_handle_create(ret, idt, idt_size) BIND(C) 
  • XIOS/trunk/src/fortran/context_interface.f90

    r312 r313  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55      
    6       SUBROUTINE cxios_set_context_calendar_type(context_hdl, calendar_type ,calendar_type_size) BIND(C) 
    7          USE ISO_C_BINDING 
    8          INTEGER  (kind = C_INTPTR_T), VALUE        :: context_hdl 
    9          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: calendar_type 
    10          INTEGER  (kind = C_INT)     , VALUE        :: calendar_type_size 
    11       END SUBROUTINE cxios_set_context_calendar_type 
    12  
    13       SUBROUTINE cxios_set_context_start_date(context_hdl, start_date ,start_date_size) BIND(C) 
    14          USE ISO_C_BINDING 
    15          INTEGER  (kind = C_INTPTR_T), VALUE        :: context_hdl 
    16          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: start_date 
    17          INTEGER  (kind = C_INT)     , VALUE        :: start_date_size 
    18       END SUBROUTINE cxios_set_context_start_date 
    19  
    20       SUBROUTINE cxios_set_context_output_dir(context_hdl, output_dir ,output_dir_size) BIND(C) 
    21          USE ISO_C_BINDING 
    22          INTEGER  (kind = C_INTPTR_T), VALUE        :: context_hdl 
    23          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: output_dir 
    24          INTEGER  (kind = C_INT)     , VALUE        :: output_dir_size 
    25       END SUBROUTINE cxios_set_context_output_dir 
    26        
    276      SUBROUTINE cxios_context_handle_create(ret, idt, idt_size) BIND(C) 
    287         import C_CHAR, C_INTPTR_T, C_INT 
  • XIOS/trunk/src/fortran/domain_interface.f90

    r312 r313  
    33        
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    5         
    6       SUBROUTINE cxios_set_domain_name(domain_hdl, name, name_size) BIND(C) 
    7          USE ISO_C_BINDING 
    8          INTEGER  (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    9          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    10          INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE cxios_set_domain_name 
    12  
    13       SUBROUTINE cxios_set_domain_standard_name(domain_hdl, standard_name, standard_name_size) BIND(C) 
    14          USE ISO_C_BINDING 
    15          INTEGER  (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    16          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    17          INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE cxios_set_domain_standard_name 
    19  
    20       SUBROUTINE cxios_set_domain_long_name(domain_hdl, long_name, long_name_size) BIND(C) 
    21          USE ISO_C_BINDING 
    22          INTEGER  (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    23          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name 
    24          INTEGER  (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE cxios_set_domain_long_name 
    26  
    27       SUBROUTINE cxios_set_domain_domain_group_ref(domain_hdl, domain_group_ref, domain_group_ref_size) BIND(C) 
    28          USE ISO_C_BINDING 
    29          INTEGER  (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    30          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: domain_group_ref 
    31          INTEGER  (kind = C_INT)     , VALUE        :: domain_group_ref_size 
    32       END SUBROUTINE cxios_set_domain_domain_group_ref 
    33  
    34       SUBROUTINE cxios_set_domain_ni_glo(domain_hdl, ni_glo) BIND(C) 
    35          USE ISO_C_BINDING 
    36          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    37          INTEGER (kind = C_INT)     , VALUE :: ni_glo 
    38       END SUBROUTINE cxios_set_domain_ni_glo 
    39  
    40       SUBROUTINE cxios_set_domain_nj_glo(domain_hdl, nj_glo) BIND(C) 
    41          USE ISO_C_BINDING 
    42          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    43          INTEGER (kind = C_INT)     , VALUE :: nj_glo 
    44       END SUBROUTINE cxios_set_domain_nj_glo 
    45  
    46       SUBROUTINE cxios_set_domain_ibegin(domain_hdl, ibegin) BIND(C) 
    47          USE ISO_C_BINDING 
    48          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    49          INTEGER (kind = C_INT)     , VALUE :: ibegin 
    50       END SUBROUTINE cxios_set_domain_ibegin 
    51  
    52       SUBROUTINE cxios_set_domain_iend(domain_hdl, iend) BIND(C) 
    53          USE ISO_C_BINDING 
    54          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    55          INTEGER (kind = C_INT)     , VALUE :: iend 
    56       END SUBROUTINE cxios_set_domain_iend 
    57  
    58       SUBROUTINE cxios_set_domain_ni(domain_hdl, ni) BIND(C) 
    59          USE ISO_C_BINDING 
    60          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    61          INTEGER (kind = C_INT)     , VALUE :: ni 
    62       END SUBROUTINE cxios_set_domain_ni 
    63  
    64       SUBROUTINE cxios_set_domain_jbegin(domain_hdl, jbegin) BIND(C) 
    65          USE ISO_C_BINDING 
    66          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    67          INTEGER (kind = C_INT)     , VALUE :: jbegin 
    68       END SUBROUTINE cxios_set_domain_jbegin 
    69  
    70       SUBROUTINE cxios_set_domain_jend(domain_hdl, jend) BIND(C) 
    71          USE ISO_C_BINDING 
    72          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    73          INTEGER (kind = C_INT)     , VALUE :: jend 
    74       END SUBROUTINE cxios_set_domain_jend 
    75  
    76       SUBROUTINE cxios_set_domain_nj(domain_hdl, nj) BIND(C) 
    77          USE ISO_C_BINDING 
    78          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    79          INTEGER (kind = C_INT)     , VALUE :: nj 
    80       END SUBROUTINE cxios_set_domain_nj 
    81  
    82       SUBROUTINE cxios_set_domain_mask(domain_hdl, mask, mask_extent1, mask_extent2) BIND(C) 
    83          USE ISO_C_BINDING 
    84          INTEGER (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    85          LOGICAL(kind = C_BOOL)     , DIMENSION(*) :: mask 
    86          INTEGER (kind = C_INT)     , VALUE        :: mask_extent1 
    87          INTEGER (kind = C_INT)     , VALUE        :: mask_extent2 
    88       END SUBROUTINE cxios_set_domain_mask 
    89  
    90       SUBROUTINE cxios_set_domain_data_dim(domain_hdl, data_dim) BIND(C) 
    91          USE ISO_C_BINDING 
    92          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    93          INTEGER (kind = C_INT)     , VALUE :: data_dim 
    94       END SUBROUTINE cxios_set_domain_data_dim 
    95  
    96       SUBROUTINE cxios_set_domain_data_ni(domain_hdl, data_ni) BIND(C) 
    97          USE ISO_C_BINDING 
    98          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    99          INTEGER (kind = C_INT)     , VALUE :: data_ni 
    100       END SUBROUTINE cxios_set_domain_data_ni 
    101  
    102       SUBROUTINE cxios_set_domain_data_nj(domain_hdl, data_nj) BIND(C) 
    103          USE ISO_C_BINDING 
    104          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    105          INTEGER (kind = C_INT)     , VALUE :: data_nj 
    106       END SUBROUTINE cxios_set_domain_data_nj 
    107  
    108       SUBROUTINE cxios_set_domain_data_ibegin(domain_hdl, data_ibegin) BIND(C) 
    109          USE ISO_C_BINDING 
    110          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    111          INTEGER (kind = C_INT)     , VALUE :: data_ibegin 
    112       END SUBROUTINE cxios_set_domain_data_ibegin 
    113  
    114       SUBROUTINE cxios_set_domain_data_jbegin(domain_hdl, data_jbegin) BIND(C) 
    115          USE ISO_C_BINDING 
    116          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    117          INTEGER (kind = C_INT)     , VALUE :: data_jbegin 
    118       END SUBROUTINE cxios_set_domain_data_jbegin 
    119  
    120       SUBROUTINE cxios_set_domain_zoom_ni(domain_hdl, zoom_ni) BIND(C) 
    121          USE ISO_C_BINDING 
    122          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    123          INTEGER (kind = C_INT)     , VALUE :: zoom_ni 
    124       END SUBROUTINE cxios_set_domain_zoom_ni 
    125  
    126       SUBROUTINE cxios_set_domain_zoom_nj(domain_hdl, zoom_nj) BIND(C) 
    127          USE ISO_C_BINDING 
    128          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    129          INTEGER (kind = C_INT)     , VALUE :: zoom_nj 
    130       END SUBROUTINE cxios_set_domain_zoom_nj 
    131  
    132       SUBROUTINE cxios_set_domain_zoom_ibegin(domain_hdl, zoom_ibegin) BIND(C) 
    133          USE ISO_C_BINDING 
    134          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    135          INTEGER (kind = C_INT)     , VALUE :: zoom_ibegin 
    136       END SUBROUTINE cxios_set_domain_zoom_ibegin 
    137  
    138       SUBROUTINE cxios_set_domain_zoom_jbegin(domain_hdl, zoom_jbegin) BIND(C) 
    139          USE ISO_C_BINDING 
    140          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    141          INTEGER (kind = C_INT)     , VALUE :: zoom_jbegin 
    142       END SUBROUTINE cxios_set_domain_zoom_jbegin 
    143  
    144       SUBROUTINE cxios_set_domain_data_n_index(domain_hdl, data_n_index) BIND(C) 
    145          USE ISO_C_BINDING 
    146          INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    147          INTEGER (kind = C_INT)     , VALUE :: data_n_index 
    148       END SUBROUTINE cxios_set_domain_data_n_index 
    149  
    150       SUBROUTINE cxios_set_domain_data_i_index(domain_hdl, data_i_index, data_i_index_extent1) BIND(C) 
    151          USE ISO_C_BINDING 
    152          INTEGER (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    153          INTEGER (kind = C_INT)     , DIMENSION(*) :: data_i_index 
    154          INTEGER (kind = C_INT)     , VALUE        :: data_i_index_extent1 
    155       END SUBROUTINE cxios_set_domain_data_i_index 
    156  
    157       SUBROUTINE cxios_set_domain_data_j_index(domain_hdl, data_j_index, data_j_index_extent1) BIND(C) 
    158          USE ISO_C_BINDING 
    159          INTEGER (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    160          INTEGER (kind = C_INT)     , DIMENSION(*) :: data_j_index 
    161          INTEGER (kind = C_INT)     , VALUE        :: data_j_index_extent1 
    162       END SUBROUTINE cxios_set_domain_data_j_index 
    163  
    164       SUBROUTINE cxios_set_domain_lonvalue(domain_hdl, lonvalue, lonvalue_extent1) BIND(C) 
    165          USE ISO_C_BINDING 
    166          INTEGER (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    167          REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: lonvalue 
    168          INTEGER (kind = C_INT)     , VALUE        :: lonvalue_extent1 
    169       END SUBROUTINE cxios_set_domain_lonvalue 
    170  
    171       SUBROUTINE cxios_set_domain_latvalue(domain_hdl, latvalue, latvalue_extent1) BIND(C) 
    172          USE ISO_C_BINDING 
    173          INTEGER (kind = C_INTPTR_T), VALUE        :: domain_hdl 
    174          REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: latvalue 
    175          INTEGER (kind = C_INT)     , VALUE        :: latvalue_extent1 
    176       END SUBROUTINE cxios_set_domain_latvalue 
    1775        
    1786      SUBROUTINE cxios_domain_handle_create(ret, idt, idt_size) BIND(C) 
  • XIOS/trunk/src/fortran/domaingroup_interface.f90

    r312 r313  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55        
    6       SUBROUTINE cxios_set_domaingroup_name(domaingroup_hdl, name, name_size) BIND(C) 
    7          USE ISO_C_BINDING 
    8          INTEGER  (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    9          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    10          INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE cxios_set_domaingroup_name 
    12  
    13       SUBROUTINE cxios_set_domaingroup_standard_name(domaingroup_hdl, standard_name, standard_name_size) BIND(C) 
    14          USE ISO_C_BINDING 
    15          INTEGER  (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    16          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    17          INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE cxios_set_domaingroup_standard_name 
    19  
    20       SUBROUTINE cxios_set_domaingroup_long_name(domaingroup_hdl, long_name, long_name_size) BIND(C) 
    21          USE ISO_C_BINDING 
    22          INTEGER  (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    23          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name 
    24          INTEGER  (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE cxios_set_domaingroup_long_name 
    26  
    27       SUBROUTINE cxios_set_domaingroup_domain_group_ref(domaingroup_hdl, domain_group_ref, domain_group_ref_size) BIND(C) 
    28          USE ISO_C_BINDING 
    29          INTEGER  (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    30          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: domain_group_ref 
    31          INTEGER  (kind = C_INT)     , VALUE        :: domain_group_ref_size 
    32       END SUBROUTINE cxios_set_domaingroup_domain_group_ref 
    33  
    34       SUBROUTINE cxios_set_domaingroup_ni_glo(domaingroup_hdl, ni_glo) BIND(C) 
    35          USE ISO_C_BINDING 
    36          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    37          INTEGER (kind = C_INT)     , VALUE :: ni_glo 
    38       END SUBROUTINE cxios_set_domaingroup_ni_glo 
    39  
    40       SUBROUTINE cxios_set_domaingroup_nj_glo(domaingroup_hdl, nj_glo) BIND(C) 
    41          USE ISO_C_BINDING 
    42          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    43          INTEGER (kind = C_INT)     , VALUE :: nj_glo 
    44       END SUBROUTINE cxios_set_domaingroup_nj_glo 
    45  
    46       SUBROUTINE cxios_set_domaingroup_ibegin(domaingroup_hdl, ibegin) BIND(C) 
    47          USE ISO_C_BINDING 
    48          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    49          INTEGER (kind = C_INT)     , VALUE :: ibegin 
    50       END SUBROUTINE cxios_set_domaingroup_ibegin 
    51  
    52       SUBROUTINE cxios_set_domaingroup_iend(domaingroup_hdl, iend) BIND(C) 
    53          USE ISO_C_BINDING 
    54          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    55          INTEGER (kind = C_INT)     , VALUE :: iend 
    56       END SUBROUTINE cxios_set_domaingroup_iend 
    57  
    58       SUBROUTINE cxios_set_domaingroup_ni(domaingroup_hdl, ni) BIND(C) 
    59          USE ISO_C_BINDING 
    60          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    61          INTEGER (kind = C_INT)     , VALUE :: ni 
    62       END SUBROUTINE cxios_set_domaingroup_ni 
    63  
    64       SUBROUTINE cxios_set_domaingroup_jbegin(domaingroup_hdl, jbegin) BIND(C) 
    65          USE ISO_C_BINDING 
    66          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    67          INTEGER (kind = C_INT)     , VALUE :: jbegin 
    68       END SUBROUTINE cxios_set_domaingroup_jbegin 
    69  
    70       SUBROUTINE cxios_set_domaingroup_jend(domaingroup_hdl, jend) BIND(C) 
    71          USE ISO_C_BINDING 
    72          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    73          INTEGER (kind = C_INT)     , VALUE :: jend 
    74       END SUBROUTINE cxios_set_domaingroup_jend 
    75  
    76       SUBROUTINE cxios_set_domaingroup_nj(domaingroup_hdl, nj) BIND(C) 
    77          USE ISO_C_BINDING 
    78          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    79          INTEGER (kind = C_INT)     , VALUE :: nj 
    80       END SUBROUTINE cxios_set_domaingroup_nj 
    81  
    82       SUBROUTINE cxios_set_domaingroup_mask(domaingroup_hdl, mask, mask_extent1, mask_extent2) BIND(C) 
    83          USE ISO_C_BINDING 
    84          INTEGER (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    85          LOGICAL(kind = C_BOOL)     , DIMENSION(*) :: mask 
    86          INTEGER (kind = C_INT)     , VALUE        :: mask_extent1 
    87          INTEGER (kind = C_INT)     , VALUE        :: mask_extent2 
    88       END SUBROUTINE cxios_set_domaingroup_mask 
    89  
    90       SUBROUTINE cxios_set_domaingroup_data_dim(domaingroup_hdl, data_dim) BIND(C) 
    91          USE ISO_C_BINDING 
    92          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    93          INTEGER (kind = C_INT)     , VALUE :: data_dim 
    94       END SUBROUTINE cxios_set_domaingroup_data_dim 
    95  
    96       SUBROUTINE cxios_set_domaingroup_data_ni(domaingroup_hdl, data_ni) BIND(C) 
    97          USE ISO_C_BINDING 
    98          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    99          INTEGER (kind = C_INT)     , VALUE :: data_ni 
    100       END SUBROUTINE cxios_set_domaingroup_data_ni 
    101  
    102       SUBROUTINE cxios_set_domaingroup_data_nj(domaingroup_hdl, data_nj) BIND(C) 
    103          USE ISO_C_BINDING 
    104          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    105          INTEGER (kind = C_INT)     , VALUE :: data_nj 
    106       END SUBROUTINE cxios_set_domaingroup_data_nj 
    107  
    108       SUBROUTINE cxios_set_domaingroup_data_ibegin(domaingroup_hdl, data_ibegin) BIND(C) 
    109          USE ISO_C_BINDING 
    110          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    111          INTEGER (kind = C_INT)     , VALUE :: data_ibegin 
    112       END SUBROUTINE cxios_set_domaingroup_data_ibegin 
    113  
    114       SUBROUTINE cxios_set_domaingroup_data_jbegin(domaingroup_hdl, data_jbegin) BIND(C) 
    115          USE ISO_C_BINDING 
    116          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    117          INTEGER (kind = C_INT)     , VALUE  :: data_jbegin 
    118       END SUBROUTINE cxios_set_domaingroup_data_jbegin 
    119  
    120       SUBROUTINE cxios_set_domaingroup_zoom_ni(domaingroup_hdl, zoom_ni) BIND(C) 
    121          USE ISO_C_BINDING 
    122          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    123          INTEGER (kind = C_INT)     , VALUE :: zoom_ni 
    124       END SUBROUTINE cxios_set_domaingroup_zoom_ni 
    125  
    126       SUBROUTINE cxios_set_domaingroup_zoom_nj(domaingroup_hdl, zoom_nj) BIND(C) 
    127          USE ISO_C_BINDING 
    128          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    129          INTEGER (kind = C_INT)     , VALUE :: zoom_nj 
    130       END SUBROUTINE cxios_set_domaingroup_zoom_nj 
    131  
    132       SUBROUTINE cxios_set_domaingroup_zoom_ibegin(domaingroup_hdl, zoom_ibegin) BIND(C) 
    133          USE ISO_C_BINDING 
    134          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    135          INTEGER (kind = C_INT)     , VALUE :: zoom_ibegin 
    136       END SUBROUTINE cxios_set_domaingroup_zoom_ibegin 
    137  
    138       SUBROUTINE cxios_set_domaingroup_zoom_jbegin(domaingroup_hdl, zoom_jbegin) BIND(C) 
    139          USE ISO_C_BINDING 
    140          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    141          INTEGER (kind = C_INT)     , VALUE :: zoom_jbegin 
    142       END SUBROUTINE cxios_set_domaingroup_zoom_jbegin 
    143  
    144       SUBROUTINE cxios_set_domaingroup_data_n_index(domaingroup_hdl, data_n_index) BIND(C) 
    145          USE ISO_C_BINDING 
    146          INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    147          INTEGER (kind = C_INT)     , VALUE :: data_n_index 
    148       END SUBROUTINE cxios_set_domaingroup_data_n_index 
    149  
    150       SUBROUTINE cxios_set_domaingroup_data_i_index(domaingroup_hdl, data_i_index, data_i_index_extent1) BIND(C) 
    151          USE ISO_C_BINDING 
    152          INTEGER (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    153          INTEGER (kind = C_INT)     , DIMENSION(*) :: data_i_index 
    154          INTEGER (kind = C_INT)     , VALUE        :: data_i_index_extent1 
    155       END SUBROUTINE cxios_set_domaingroup_data_i_index 
    156  
    157       SUBROUTINE cxios_set_domaingroup_data_j_index(domaingroup_hdl, data_j_index, data_j_index_extent1) BIND(C) 
    158          USE ISO_C_BINDING 
    159          INTEGER (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    160          INTEGER (kind = C_INT)     , DIMENSION(*) :: data_j_index 
    161          INTEGER (kind = C_INT)     , VALUE        :: data_j_index_extent1 
    162       END SUBROUTINE cxios_set_domaingroup_data_j_index 
    163  
    164       SUBROUTINE cxios_set_domaingroup_lonvalue(domaingroup_hdl, lonvalue, lonvalue_extent1) BIND(C) 
    165          USE ISO_C_BINDING 
    166          INTEGER (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    167          REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: lonvalue 
    168          INTEGER (kind = C_INT)     , VALUE        :: lonvalue_extent1 
    169       END SUBROUTINE cxios_set_domaingroup_lonvalue 
    170  
    171       SUBROUTINE cxios_set_domaingroup_latvalue(domaingroup_hdl, latvalue, latvalue_extent1) BIND(C) 
    172          USE ISO_C_BINDING 
    173          INTEGER (kind = C_INTPTR_T), VALUE        :: domaingroup_hdl 
    174          REAL    (kind = C_DOUBLE)  , DIMENSION(*) :: latvalue 
    175          INTEGER (kind = C_INT)     , VALUE        :: latvalue_extent1 
    176       END SUBROUTINE cxios_set_domaingroup_latvalue 
    177        
    1786      SUBROUTINE cxios_domaingroup_handle_create(ret, idt, idt_size) BIND(C) 
    1797         USE ISO_C_BINDING 
  • XIOS/trunk/src/fortran/field_interface.f90

    r310 r313  
    33    
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    5     
    6       SUBROUTINE cxios_set_field_name(field_hdl, name ,name_size) BIND(C) 
    7          USE ISO_C_BINDING 
    8          INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    9          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    10          INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE cxios_set_field_name 
    12  
    13       SUBROUTINE cxios_set_field_standard_name(field_hdl, standard_name ,standard_name_size) BIND(C) 
    14          USE ISO_C_BINDING 
    15          INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    16          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    17          INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE cxios_set_field_standard_name 
    19  
    20       SUBROUTINE cxios_set_field_long_name(field_hdl, long_name ,long_name_size) BIND(C) 
    21          USE ISO_C_BINDING 
    22          INTEGER (kind = C_INTPTR_T), VALUE        :: field_hdl 
    23          CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: long_name 
    24          INTEGER (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE cxios_set_field_long_name 
    26  
    27       SUBROUTINE cxios_set_field_unit(field_hdl, unit ,unit_size) BIND(C) 
    28          USE ISO_C_BINDING 
    29          INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    30          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit 
    31          INTEGER  (kind = C_INT)     , VALUE        :: unit_size 
    32       END SUBROUTINE cxios_set_field_unit 
    33  
    34       SUBROUTINE cxios_set_field_operation(field_hdl, operation ,operation_size) BIND(C) 
    35          USE ISO_C_BINDING 
    36          INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    37          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: operation 
    38          INTEGER  (kind = C_INT)     , VALUE        :: operation_size 
    39       END SUBROUTINE cxios_set_field_operation 
    40  
    41       SUBROUTINE cxios_set_field_freq_op(field_hdl, freq_op ,freq_op_size) BIND(C) 
    42          USE ISO_C_BINDING 
    43          INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    44          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: freq_op 
    45          INTEGER  (kind = C_INT)     , VALUE        :: freq_op_size 
    46       END SUBROUTINE cxios_set_field_freq_op 
    47  
    48       SUBROUTINE cxios_set_field_level(field_hdl, level) BIND(C) 
    49          USE ISO_C_BINDING 
    50          INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
    51          INTEGER (kind = C_INT)     , VALUE :: level 
    52       END SUBROUTINE cxios_set_field_level 
    53  
    54       SUBROUTINE cxios_set_field_prec(field_hdl, prec) BIND(C) 
    55          USE ISO_C_BINDING 
    56          INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
    57          INTEGER (kind = C_INT)     , VALUE :: prec 
    58       END SUBROUTINE cxios_set_field_prec 
    59  
    60       SUBROUTINE cxios_set_field_enabled(field_hdl, enabled) BIND(C) 
    61          USE ISO_C_BINDING 
    62          INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
    63          LOGICAL (kind = C_BOOL)    , VALUE :: enabled 
    64          END SUBROUTINE cxios_set_field_enabled 
    65  
    66       SUBROUTINE cxios_set_field_domain_ref(field_hdl, domain_ref ,domain_ref_size) BIND(C) 
    67          USE ISO_C_BINDING 
    68          INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    69          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: domain_ref 
    70          INTEGER  (kind = C_INT)     , VALUE        :: domain_ref_size 
    71       END SUBROUTINE cxios_set_field_domain_ref 
    72  
    73       SUBROUTINE cxios_set_field_axis_ref(field_hdl, axis_ref ,axis_ref_size) BIND(C) 
    74          USE ISO_C_BINDING 
    75          INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    76          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_ref 
    77          INTEGER  (kind = C_INT)     , VALUE        :: axis_ref_size 
    78       END SUBROUTINE cxios_set_field_axis_ref 
    79  
    80       SUBROUTINE cxios_set_field_grid_ref(field_hdl, grid_ref ,grid_ref_size) BIND(C) 
    81          USE ISO_C_BINDING 
    82          INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    83          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: grid_ref 
    84          INTEGER  (kind = C_INT)     , VALUE        :: grid_ref_size 
    85       END SUBROUTINE cxios_set_field_grid_ref 
    86  
    87       SUBROUTINE cxios_set_field_field_ref(field_hdl, field_ref ,field_ref_size) BIND(C) 
    88          USE ISO_C_BINDING 
    89          INTEGER  (kind = C_INTPTR_T), VALUE        :: field_hdl 
    90          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: field_ref 
    91          INTEGER  (kind = C_INT)     , VALUE        :: field_ref_size 
    92       END SUBROUTINE cxios_set_field_field_ref 
    93  
    94       SUBROUTINE cxios_set_field_default_value(field_hdl, default_value) BIND(C) 
    95          USE ISO_C_BINDING 
    96          INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
    97          REAL    (kind = C_DOUBLE)  , VALUE :: default_value 
    98       END SUBROUTINE cxios_set_field_default_value 
    995    
    1006      SUBROUTINE cxios_field_handle_create(ret, idt, idt_size) BIND(C) 
  • XIOS/trunk/src/fortran/fieldgroup_interface.f90

    r286 r313  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55    
    6       SUBROUTINE cxios_set_fieldgroup_name(fieldgroup_hdl, name ,name_size) BIND(C) 
    7          USE ISO_C_BINDING 
    8          INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    9          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    10          INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE cxios_set_fieldgroup_name 
    12  
    13       SUBROUTINE cxios_set_fieldgroup_standard_name(fieldgroup_hdl, standard_name ,standard_name_size) BIND(C) 
    14          USE ISO_C_BINDING 
    15          INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    16          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name 
    17          INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size 
    18       END SUBROUTINE cxios_set_fieldgroup_standard_name 
    19  
    20       SUBROUTINE cxios_set_fieldgroup_long_name(fieldgroup_hdl, long_name ,long_name_size) BIND(C) 
    21          USE ISO_C_BINDING 
    22          INTEGER (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    23          CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: long_name 
    24          INTEGER (kind = C_INT)     , VALUE        :: long_name_size 
    25       END SUBROUTINE cxios_set_fieldgroup_long_name 
    26  
    27       SUBROUTINE cxios_set_fieldgroup_unit(fieldgroup_hdl, unit ,unit_size) BIND(C) 
    28          USE ISO_C_BINDING 
    29          INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    30          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit 
    31          INTEGER  (kind = C_INT)     , VALUE        :: unit_size 
    32       END SUBROUTINE cxios_set_fieldgroup_unit 
    33  
    34       SUBROUTINE cxios_set_fieldgroup_operation(fieldgroup_hdl, operation ,operation_size) BIND(C) 
    35          USE ISO_C_BINDING 
    36          INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    37          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: operation 
    38          INTEGER  (kind = C_INT)     , VALUE        :: operation_size 
    39       END SUBROUTINE cxios_set_fieldgroup_operation 
    40  
    41       SUBROUTINE cxios_set_fieldgroup_freq_op(fieldgroup_hdl, freq_op ,freq_op_size) BIND(C) 
    42          USE ISO_C_BINDING 
    43          INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    44          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: freq_op 
    45          INTEGER  (kind = C_INT)     , VALUE        :: freq_op_size 
    46       END SUBROUTINE cxios_set_fieldgroup_freq_op 
    47  
    48       SUBROUTINE cxios_set_fieldgroup_level(fieldgroup_hdl, level) BIND(C) 
    49          USE ISO_C_BINDING 
    50          INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
    51          INTEGER (kind = C_INT)     , VALUE :: level 
    52       END SUBROUTINE cxios_set_fieldgroup_level 
    53  
    54       SUBROUTINE cxios_set_fieldgroup_prec(fieldgroup_hdl, prec) BIND(C) 
    55          USE ISO_C_BINDING 
    56          INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
    57          INTEGER (kind = C_INT)     , VALUE :: prec 
    58       END SUBROUTINE cxios_set_fieldgroup_prec 
    59  
    60       SUBROUTINE cxios_set_fieldgroup_enabled(fieldgroup_hdl, enabled) BIND(C) 
    61          USE ISO_C_BINDING 
    62          INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
    63          LOGICAL (kind = C_BOOL)    , VALUE :: enabled 
    64          END SUBROUTINE cxios_set_fieldgroup_enabled 
    65  
    66       SUBROUTINE cxios_set_fieldgroup_domain_ref(fieldgroup_hdl, domain_ref ,domain_ref_size) BIND(C) 
    67          USE ISO_C_BINDING 
    68          INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    69          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: domain_ref 
    70          INTEGER  (kind = C_INT)     , VALUE        :: domain_ref_size 
    71       END SUBROUTINE cxios_set_fieldgroup_domain_ref 
    72  
    73       SUBROUTINE cxios_set_fieldgroup_axis_ref(fieldgroup_hdl, axis_ref ,axis_ref_size) BIND(C) 
    74          USE ISO_C_BINDING 
    75          INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    76          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_ref 
    77          INTEGER  (kind = C_INT)     , VALUE        :: axis_ref_size 
    78       END SUBROUTINE cxios_set_fieldgroup_axis_ref 
    79  
    80       SUBROUTINE cxios_set_fieldgroup_grid_ref(fieldgroup_hdl, grid_ref ,grid_ref_size) BIND(C) 
    81          USE ISO_C_BINDING 
    82          INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    83          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: grid_ref 
    84          INTEGER  (kind = C_INT)     , VALUE        :: grid_ref_size 
    85       END SUBROUTINE cxios_set_fieldgroup_grid_ref 
    86  
    87       SUBROUTINE cxios_set_fieldgroup_field_ref(fieldgroup_hdl, field_ref ,field_ref_size) BIND(C) 
    88          USE ISO_C_BINDING 
    89          INTEGER  (kind = C_INTPTR_T), VALUE        :: fieldgroup_hdl 
    90          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: field_ref 
    91          INTEGER  (kind = C_INT)     , VALUE        :: field_ref_size 
    92       END SUBROUTINE cxios_set_fieldgroup_field_ref 
    93  
    94       SUBROUTINE cxios_set_fieldgroup_default_value(fieldgroup_hdl, default_value) BIND(C) 
    95          USE ISO_C_BINDING 
    96          INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
    97          REAL    (kind = C_DOUBLE)  , VALUE :: default_value 
    98       END SUBROUTINE cxios_set_fieldgroup_default_value 
    99        
    1006      SUBROUTINE cxios_fieldgroup_handle_create(ret, idt, idt_size) BIND(C) 
    1017         USE ISO_C_BINDING 
  • XIOS/trunk/src/fortran/file_interface.f90

    r300 r313  
    33    
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    5     
    6       SUBROUTINE cxios_set_file_name(file_hdl, name, name_size) BIND(C) 
    7          USE ISO_C_BINDING 
    8          INTEGER  (kind = C_INTPTR_T), VALUE        :: file_hdl 
    9          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    10          INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE cxios_set_file_name 
    12  
    13       SUBROUTINE cxios_set_file_description(file_hdl, description, description_size) BIND(C) 
    14          USE ISO_C_BINDING 
    15          INTEGER  (kind = C_INTPTR_T), VALUE        :: file_hdl 
    16          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: description 
    17          INTEGER  (kind = C_INT)     , VALUE        :: description_size 
    18       END SUBROUTINE cxios_set_file_description 
    19        
    20       SUBROUTINE cxios_set_file_name_suffix(file_hdl, name_suffix, name_suffix_size) BIND(C) 
    21          USE ISO_C_BINDING 
    22          INTEGER  (kind = C_INTPTR_T), VALUE        :: file_hdl 
    23          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name_suffix 
    24          INTEGER  (kind = C_INT)     , VALUE        :: name_suffix_size 
    25       END SUBROUTINE cxios_set_file_name_suffix 
    26  
    27       SUBROUTINE cxios_set_file_output_freq(file_hdl, output_freq, output_freq_size) BIND(C) 
    28          USE ISO_C_BINDING 
    29          INTEGER  (kind = C_INTPTR_T), VALUE        :: file_hdl 
    30          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: output_freq 
    31          INTEGER  (kind = C_INT)     , VALUE        :: output_freq_size 
    32       END SUBROUTINE cxios_set_file_output_freq 
    33  
    34       SUBROUTINE cxios_set_file_output_level(file_hdl, output_level) BIND(C) 
    35          USE ISO_C_BINDING 
    36          INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
    37          INTEGER (kind = C_INT)     , VALUE :: output_level 
    38       END SUBROUTINE cxios_set_file_output_level 
    39  
    40       SUBROUTINE cxios_set_file_enabled(file_hdl, enabled) BIND(C) 
    41          USE ISO_C_BINDING 
    42          INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
    43          LOGICAL (kind = C_BOOL)    , VALUE :: enabled 
    44       END SUBROUTINE cxios_set_file_enabled 
    455    
    466      SUBROUTINE cxios_file_handle_create(ret, idt, idt_size) BIND(C) 
     
    5818      END SUBROUTINE cxios_file_valid_id 
    5919 
    60      SUBROUTINE cxios_set_file_type(file_hdl, type, type_size) BIND(C) 
    61          USE ISO_C_BINDING 
    62          INTEGER  (kind = C_INTPTR_T), VALUE        :: file_hdl 
    63          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: type 
    64          INTEGER  (kind = C_INT)     , VALUE        :: type_size 
    65       END SUBROUTINE cxios_set_file_type 
    66        
    6720   END INTERFACE 
    6821    
  • XIOS/trunk/src/fortran/filegroup_interface.f90

    r300 r313  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55    
    6       SUBROUTINE cxios_set_filegroup_name(filegroup_hdl, name ,name_size) BIND(C) 
    7          USE ISO_C_BINDING 
    8          INTEGER  (kind = C_INTPTR_T), VALUE        :: filegroup_hdl 
    9          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name 
    10          INTEGER  (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE cxios_set_filegroup_name 
    12  
    13       SUBROUTINE cxios_set_filegroup_description(filegroup_hdl, description ,description_size) BIND(C) 
    14          USE ISO_C_BINDING 
    15          INTEGER  (kind = C_INTPTR_T), VALUE        :: filegroup_hdl 
    16          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: description 
    17          INTEGER  (kind = C_INT)     , VALUE        :: description_size 
    18       END SUBROUTINE cxios_set_filegroup_description 
    19        
    20       SUBROUTINE cxios_set_filegroup_name_suffix(filegroup_hdl, name_suffix ,name_suffix_size) BIND(C) 
    21          USE ISO_C_BINDING 
    22          INTEGER  (kind = C_INTPTR_T), VALUE        :: filegroup_hdl 
    23          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name_suffix 
    24          INTEGER  (kind = C_INT)     , VALUE        :: name_suffix_size 
    25       END SUBROUTINE cxios_set_filegroup_name_suffix 
    26  
    27       SUBROUTINE cxios_set_filegroup_output_freq(filegroup_hdl, output_freq ,output_freq_size) BIND(C) 
    28          USE ISO_C_BINDING 
    29          INTEGER  (kind = C_INTPTR_T), VALUE        :: filegroup_hdl 
    30          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: output_freq 
    31          INTEGER  (kind = C_INT)     , VALUE        :: output_freq_size 
    32       END SUBROUTINE cxios_set_filegroup_output_freq 
    33  
    34       SUBROUTINE cxios_set_filegroup_output_level(filegroup_hdl, output_level) BIND(C) 
    35          USE ISO_C_BINDING 
    36          INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
    37          INTEGER (kind = C_INT)     , VALUE :: output_level 
    38       END SUBROUTINE cxios_set_filegroup_output_level 
    39  
    40       SUBROUTINE cxios_set_filegroup_enabled(filegroup_hdl, enabled) BIND(C) 
    41          USE ISO_C_BINDING 
    42          INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
    43          LOGICAL (kind = C_BOOL)    , VALUE :: enabled 
    44       END SUBROUTINE cxios_set_filegroup_enabled 
    45        
    466      SUBROUTINE cxios_filegroup_handle_create(ret, idt, idt_size) BIND(C) 
    477         USE ISO_C_BINDING 
     
    5818      END SUBROUTINE cxios_filegroup_valid_id 
    5919 
    60       SUBROUTINE cxios_set_filegroup_type(filegroup_hdl, type ,type_size) BIND(C) 
    61          USE ISO_C_BINDING 
    62          INTEGER  (kind = C_INTPTR_T), VALUE        :: filegroup_hdl 
    63          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: type 
    64          INTEGER  (kind = C_INT)     , VALUE        :: type_size 
    65       END SUBROUTINE cxios_set_filegroup_type 
    66        
    6720   END INTERFACE 
    6821    
  • XIOS/trunk/src/fortran/grid_interface.f90

    r286 r313  
    33      
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    5       
    6       SUBROUTINE cxios_set_grid_name(grid_hdl, name, name_size) BIND(C) 
    7          USE ISO_C_BINDING 
    8          INTEGER (kind = C_INTPTR_T), VALUE        :: grid_hdl 
    9          CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: name 
    10          INTEGER (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE cxios_set_grid_name 
    125 
    13       SUBROUTINE cxios_set_grid_description(grid_hdl, description, description_size) BIND(C) 
    14          USE ISO_C_BINDING 
    15          INTEGER (kind = C_INTPTR_T), VALUE        :: grid_hdl 
    16          CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: description 
    17          INTEGER (kind = C_INT)     , VALUE        :: description_size 
    18       END SUBROUTINE cxios_set_grid_description 
    19  
    20       SUBROUTINE cxios_set_grid_domain_ref(grid_hdl, domain_ref, domain_ref_size) BIND(C) 
    21          USE ISO_C_BINDING 
    22          INTEGER (kind = C_INTPTR_T), VALUE        :: grid_hdl 
    23          CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: domain_ref 
    24          INTEGER (kind = C_INT)     , VALUE        :: domain_ref_size 
    25       END SUBROUTINE cxios_set_grid_domain_ref 
    26  
    27       SUBROUTINE cxios_set_grid_axis_ref(grid_hdl, axis_ref, axis_ref_size) BIND(C) 
    28          USE ISO_C_BINDING 
    29          INTEGER  (kind = C_INTPTR_T), VALUE        :: grid_hdl 
    30          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_ref 
    31          INTEGER  (kind = C_INT)     , VALUE        :: axis_ref_size 
    32       END SUBROUTINE cxios_set_grid_axis_ref 
    33        
    346      SUBROUTINE cxios_grid_handle_create(ret, idt, idt_size) BIND(C) 
    357         USE ISO_C_BINDING 
  • XIOS/trunk/src/fortran/gridgroup_interface.f90

    r286 r313  
    44   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
    55      
    6       SUBROUTINE cxios_set_gridgroup_name(gridgroup_hdl, name, name_size) BIND(C) 
    7          USE ISO_C_BINDING 
    8          INTEGER (kind = C_INTPTR_T), VALUE        :: gridgroup_hdl 
    9          CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: name 
    10          INTEGER (kind = C_INT)     , VALUE        :: name_size 
    11       END SUBROUTINE cxios_set_gridgroup_name 
    12  
    13       SUBROUTINE cxios_set_gridgroup_description(gridgroup_hdl, description, description_size) BIND(C) 
    14          USE ISO_C_BINDING 
    15          INTEGER (kind = C_INTPTR_T), VALUE        :: gridgroup_hdl 
    16          CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: description 
    17          INTEGER (kind = C_INT)     , VALUE        :: description_size 
    18       END SUBROUTINE cxios_set_gridgroup_description 
    19  
    20       SUBROUTINE cxios_set_gridgroup_domain_ref(gridgroup_hdl, domain_ref, domain_ref_size) BIND(C) 
    21          USE ISO_C_BINDING 
    22          INTEGER (kind = C_INTPTR_T), VALUE        :: gridgroup_hdl 
    23          CHARACTER(kind = C_CHAR)   , DIMENSION(*) :: domain_ref 
    24          INTEGER (kind = C_INT)     , VALUE        :: domain_ref_size 
    25       END SUBROUTINE cxios_set_gridgroup_domain_ref 
    26  
    27       SUBROUTINE cxios_set_gridgroup_axis_ref(gridgroup_hdl, axis_ref, axis_ref_size) BIND(C) 
    28          USE ISO_C_BINDING 
    29          INTEGER  (kind = C_INTPTR_T), VALUE        :: gridgroup_hdl 
    30          CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_ref 
    31          INTEGER  (kind = C_INT)     , VALUE        :: axis_ref_size 
    32       END SUBROUTINE cxios_set_gridgroup_axis_ref 
    33        
    346      SUBROUTINE cxios_domaingroup_handle_create(ret, idt, idt_size) BIND(C) 
    357         USE ISO_C_BINDING 
  • XIOS/trunk/src/fortran/iaxis.F90

    r312 r313  
    55   USE AXIS_INTERFACE 
    66   USE AXISGROUP_INTERFACE 
    7  
     7    
    88   TYPE txios(axis) 
    99      INTEGER(kind = C_INTPTR_T) :: daddr 
     
    1717          
    1818   CONTAINS ! Fonctions disponibles pour les utilisateurs. 
    19  
    20  
    21  
    22    SUBROUTINE xios(set_axis_attr)(axis_id, name, standard_name, long_name, unit, size, value) 
    23       IMPLICIT NONE 
    24       TYPE(txios(axis))                                     :: axis_hdl 
    25       CHARACTER(len = *)                        , INTENT(IN) :: axis_id 
    26       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: name 
    27       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: standard_name 
    28       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: long_name 
    29       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: unit 
    30       INTEGER                         , OPTIONAL, INTENT(IN) :: size 
    31       REAL(kind=8), dimension(*), OPTIONAL, INTENT(IN) :: value(:) 
    32        
    33       CALL xios(get_axis_handle)(axis_id,axis_hdl) 
    34       CALL xios(set_axis_attr_hdl_)(axis_hdl, name, standard_name, long_name, unit, size, value) 
    35  
    36    END SUBROUTINE xios(set_axis_attr) 
    37     
    38  
    39    SUBROUTINE xios(set_axis_attr_hdl)(axis_hdl, name, standard_name, long_name, unit, size, value) 
    40       IMPLICIT NONE 
    41       TYPE(txios(axis))                        , INTENT(IN) :: axis_hdl 
    42       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: name 
    43       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: standard_name 
    44       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: long_name 
    45       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: unit 
    46       INTEGER                         , OPTIONAL, INTENT(IN) :: size 
    47       REAL(kind=8), dimension(*), OPTIONAL, INTENT(IN) :: value(:) 
    48  
    49       CALL xios(set_axis_attr_hdl_)(axis_hdl, name, standard_name, long_name, unit, size, value) 
    50  
    51    END SUBROUTINE xios(set_axis_attr_hdl) 
    52     
    53     
    54    SUBROUTINE xios(set_axis_attr_hdl_)(axis_hdl, name_, standard_name_, long_name_, unit_, size_, value_) 
    55       IMPLICIT NONE 
    56       TYPE(txios(axis))                        , INTENT(IN) :: axis_hdl 
    57       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: name_ 
    58       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: standard_name_ 
    59       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: long_name_ 
    60       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: unit_ 
    61       INTEGER                         , OPTIONAL, INTENT(IN) :: size_ 
    62       REAL(kind=8), dimension(*), OPTIONAL, INTENT(IN) :: value_(:) 
    63        
    64       IF (PRESENT(name_))           THEN 
    65          CALL cxios_set_axis_name(axis_hdl%daddr, name_, len(name_)) 
    66       END IF 
    67       IF (PRESENT(standard_name_))  THEN 
    68          CALL cxios_set_axis_standard_name(axis_hdl%daddr, standard_name_, len(standard_name_)) 
    69       END IF 
    70       IF (PRESENT(long_name_))      THEN 
    71          CALL cxios_set_axis_long_name(axis_hdl%daddr, long_name_, len(long_name_)) 
    72       END IF 
    73       IF (PRESENT(unit_))           THEN 
    74          CALL cxios_set_axis_unit(axis_hdl%daddr, unit_, len(unit_)) 
    75       END IF 
    76       IF (PRESENT(size_))           THEN 
    77          CALL cxios_set_axis_size(axis_hdl%daddr, size_) 
    78       END IF 
    79       IF (PRESENT(value_))         THEN 
    80          CALL cxios_set_axis_zvalue(axis_hdl%daddr, value_, size(value_, 1)) 
    81       END IF 
    82        
    83    END SUBROUTINE xios(set_axis_attr_hdl_) 
    84  
    85     
    86    SUBROUTINE xios(set_axisgroup_attr)(axisgroup_id, name, standard_name, long_name, unit, size, value) 
    87       IMPLICIT NONE 
    88       TYPE(txios(axisgroup))                                :: axisgroup_hdl 
    89       CHARACTER(len = *)                        , INTENT(IN) :: axisgroup_id 
    90       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: name 
    91       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: standard_name 
    92       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: long_name 
    93       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: unit 
    94       INTEGER                         , OPTIONAL, INTENT(IN) :: size 
    95       REAL(kind=8), dimension(*), OPTIONAL, INTENT(IN) :: value(:) 
    96  
    97       CALL xios(get_axisgroup_handle)(axisgroup_id,axisgroup_hdl) 
    98       CALL xios(set_axisgroup_attr_hdl_)(axisgroup_hdl, name, standard_name, long_name, unit, size, value) 
    99  
    100    END SUBROUTINE xios(set_axisgroup_attr) 
    101     
    102  
    103    SUBROUTINE xios(set_axisgroup_attr_hdl)(axisgroup_hdl, name, standard_name, long_name, unit, size, value) 
    104       IMPLICIT NONE 
    105       TYPE(txios(axisgroup))                   , INTENT(IN) :: axisgroup_hdl 
    106       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: name 
    107       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: standard_name 
    108       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: long_name 
    109       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: unit 
    110       INTEGER                         , OPTIONAL, INTENT(IN) :: size 
    111       REAL(kind=8), dimension(*), OPTIONAL, INTENT(IN) :: value(:) 
    112  
    113       CALL xios(set_axisgroup_attr_hdl_)(axisgroup_hdl, name, standard_name, long_name, unit, size, value)       
    114  
    115    END SUBROUTINE xios(set_axisgroup_attr_hdl) 
    116  
    117        
    118    SUBROUTINE xios(set_axisgroup_attr_hdl_)(axisgroup_hdl, name_, standard_name_, long_name_, unit_, size_, value_) 
    119       IMPLICIT NONE 
    120       TYPE(txios(axisgroup))                   , INTENT(IN) :: axisgroup_hdl 
    121       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: name_ 
    122       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: standard_name_ 
    123       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: long_name_ 
    124       CHARACTER(len = *)              , OPTIONAL, INTENT(IN) :: unit_ 
    125       INTEGER                         , OPTIONAL, INTENT(IN) :: size_ 
    126       REAL(kind=8), dimension(*), OPTIONAL, INTENT(IN) :: value_(:) 
    127        
    128       IF (PRESENT(name_))           THEN 
    129          CALL cxios_set_axisgroup_name(axisgroup_hdl%daddr, name_, len(name_)) 
    130       END IF 
    131       IF (PRESENT(standard_name_))  THEN 
    132          CALL cxios_set_axisgroup_standard_name(axisgroup_hdl%daddr, standard_name_, len(standard_name_)) 
    133       END IF 
    134       IF (PRESENT(long_name_))      THEN 
    135          CALL cxios_set_axisgroup_long_name(axisgroup_hdl%daddr, long_name_, len(long_name_)) 
    136       END IF 
    137       IF (PRESENT(unit_))           THEN 
    138          CALL cxios_set_axisgroup_unit(axisgroup_hdl%daddr, unit_, len(unit_)) 
    139       END IF 
    140       IF (PRESENT(size_))           THEN 
    141          CALL cxios_set_axisgroup_size(axisgroup_hdl%daddr, size_) 
    142       END IF 
    143       IF (PRESENT(value_))         THEN 
    144          CALL cxios_set_axisgroup_zvalue(axisgroup_hdl%daddr, value_, size(value_, 1)) 
    145       END IF 
    146    END SUBROUTINE xios(set_axisgroup_attr_hdl_) 
    147     
    14819 
    14920   SUBROUTINE xios(get_axis_handle)(idt,ret) 
  • XIOS/trunk/src/fortran/icaxis.cpp

    r300 r313  
    2323   typedef xmlioserver::tree::CAxisGroup * XAxisGroupPtr; 
    2424 
    25    // ------------------------- Attributs des axes ----------------------------- 
    26    void cxios_set_axis_name  
    27       (XAxisPtr axis_hdl, const char * name , int name_size) 
    28    { 
    29       std::string name_str;  
    30       if (!cstr2string(name, name_size, name_str)) return; 
    31  
    32       axis_hdl->name.setValue(name_str); 
    33       axis_hdl->sendAttributToServer(axis_hdl->name) ; 
    34    } 
    35  
    36    void cxios_set_axis_standard_name 
    37       (XAxisPtr axis_hdl, const char * standard_name , int standard_name_size) 
    38    { 
    39       std::string standard_name_str;  
    40       if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    41  
    42       axis_hdl->standard_name.setValue(standard_name_str);  
    43       axis_hdl->sendAttributToServer(axis_hdl->standard_name);  
    44   } 
    45      
    46    void cxios_set_axis_long_name  
    47       (XAxisPtr axis_hdl, const char * long_name , int long_name_size) 
    48    { 
    49       std::string long_name_str;  
    50       if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
    51  
    52       axis_hdl->long_name.setValue(long_name_str); 
    53       axis_hdl->sendAttributToServer(axis_hdl->long_name) ; 
    54    } 
    55  
    56    void cxios_set_axis_unit  
    57       (XAxisPtr axis_hdl, const char * unit , int unit_size) 
    58    { 
    59       std::string unit_str;  
    60       if (!cstr2string(unit, unit_size, unit_str)) return; 
    61  
    62       axis_hdl->unit.setValue(unit_str); 
    63       axis_hdl->sendAttributToServer(axis_hdl->unit) ; 
    64    } 
    65      
    66    void cxios_set_axis_size(XAxisPtr axis_hdl, int size) 
    67    { 
    68       axis_hdl->size.setValue(size); 
    69       axis_hdl->sendAttributToServer(axis_hdl->size) ; 
    70    } 
    71  
    72    void cxios_set_axis_zvalue  
    73       (XAxisPtr axis_hdl, const double * zvalue , int zvalue_extent1) 
    74    { 
    75       ARRAY(double, 1) zvalue_val(new CArray<double, 1>(boost::extents [zvalue_extent1])); 
    76       std::copy(zvalue, &(zvalue[zvalue_val->num_elements()]), zvalue_val->data()); 
    77  
    78       axis_hdl->zvalue.setValue(zvalue_val); 
    79       axis_hdl->sendAttributToServer(axis_hdl->zvalue) ; 
    80  
    81    } 
    82     
    83    // -------------------- Attributs des groupes d'axes ------------------------- 
    84     
    85    void cxios_set_axisgroup_name  
    86       (XAxisGroupPtr axisgroup_hdl, const char * name , int name_size) 
    87    { 
    88       std::string name_str; 
    89       if (!cstr2string(name, name_size, name_str)) return; 
    90  
    91       axisgroup_hdl->name.setValue(name_str); 
    92       axisgroup_hdl->sendAttributToServer(axisgroup_hdl->name) ; 
    93    } 
    94  
    95    void cxios_set_axisgroup_standard_name 
    96       (XAxisGroupPtr axisgroup_hdl, const char * standard_name , int standard_name_size) 
    97    { 
    98       std::string standard_name_str; 
    99       if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    100  
    101       axisgroup_hdl->standard_name.setValue(standard_name_str); 
    102       axisgroup_hdl->sendAttributToServer(axisgroup_hdl->standard_name) ; 
    103    } 
    104      
    105    void cxios_set_axisgroup_long_name  
    106       (XAxisGroupPtr axisgroup_hdl, const char * long_name , int long_name_size) 
    107    { 
    108       std::string long_name_str; 
    109       if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
    110  
    111       axisgroup_hdl->long_name.setValue(long_name_str); 
    112       axisgroup_hdl->sendAttributToServer(axisgroup_hdl->long_name) ; 
    113    } 
    114  
    115    void cxios_set_axisgroup_unit  
    116       (XAxisGroupPtr axisgroup_hdl, const char * unit , int unit_size) 
    117    { 
    118       std::string unit_str; 
    119       if (!cstr2string(unit, unit_size, unit_str)) return; 
    120  
    121       axisgroup_hdl->unit.setValue(unit_str); 
    122       axisgroup_hdl->sendAttributToServer(axisgroup_hdl->unit) ; 
    123    } 
    124      
    125    void cxios_set_axisgroup_size(XAxisGroupPtr axisgroup_hdl, int size) 
    126    { 
    127       axisgroup_hdl->size.setValue(size); 
    128       axisgroup_hdl->sendAttributToServer(axisgroup_hdl->size) ; 
    129    } 
    130  
    131    void cxios_set_axisgroup_zvalue  
    132       (XAxisGroupPtr axisgroup_hdl, const double * zvalue , int zvalue_extent1) 
    133    { 
    134       ARRAY(double, 1) zvalue_val(new CArray<double, 1>(boost::extents [zvalue_extent1])); 
    135       std::copy(zvalue, &(zvalue[zvalue_val->num_elements()]), zvalue_val->data()); 
    136  
    137       axisgroup_hdl->zvalue.setValue(zvalue_val); 
    138       axisgroup_hdl->sendAttributToServer(axisgroup_hdl->zvalue) ; 
    139    } 
    140     
    14125   // ------------------------ Création des handle ----------------------------- 
    14226    
  • XIOS/trunk/src/fortran/iccontext.cpp

    r312 r313  
    2626   typedef xmlioserver::tree::CContext * XContextPtr; 
    2727 
    28    // ------------------------- Attributs des contextes ------------------------ 
    29     
    30     
    31    void cxios_set_context_calendar_type(XContextPtr context_hdl, const char * calendar_type, int calendar_type_size) 
    32    { 
    33       std::string calendar_type_str;  
    34       if (!cstr2string(calendar_type, calendar_type_size, calendar_type_str)) return; 
    35       context_hdl->calendar_type.setValue(calendar_type_str); 
    36       context_hdl->sendAttributToServer(context_hdl->calendar_type) ; 
    37    } 
    38     
    39    void cxios_set_context_start_date(XContextPtr context_hdl, const char * start_date, int start_date_size) 
    40    { 
    41       std::string start_date_str;  
    42       if (!cstr2string(start_date, start_date_size, start_date_str)) return; 
    43  
    44       context_hdl->start_date.setValue(start_date_str); 
    45       context_hdl->sendAttributToServer(context_hdl->start_date) ;  
    46    } 
    47     
    48    void cxios_set_context_output_dir(XContextPtr context_hdl, const char * output_dir, int output_dir_size) 
    49    { 
    50       std::string output_dir_str;  
    51       if (!cstr2string(output_dir, output_dir_size, output_dir_str)) return; 
    52  
    53       context_hdl->output_dir.setValue(output_dir_str); 
    54       context_hdl->sendAttributToServer(context_hdl->output_dir) ;  
    55    } 
    56     
    5728   // ------------------------ Création des handle ----------------------------- 
    5829    
     
    7142          return; 
    7243      } 
    73       // Lever une execption ici 
     44      // Lever une exeception ici 
    7445   } 
    7546    
  • XIOS/trunk/src/fortran/icdomain.cpp

    r312 r313  
    2323   typedef xmlioserver::tree::CDomainGroup * XDomainGroupPtr; 
    2424 
    25    // ------------------------- Attributs des axes ----------------------------- 
    26     
    27    void cxios_set_domain_name(XDomainPtr domain_hdl, const char * name, int name_size) 
    28    { 
    29       std::string name_str;  
    30       if (!cstr2string(name, name_size, name_str)) return; 
    31  
    32       domain_hdl->name.setValue(name_str); 
    33       domain_hdl->sendAttributToServer(domain_hdl->name) ;  
    34    } 
    35     
    36    void cxios_set_domain_standard_name(XDomainPtr domain_hdl, const char * standard_name, int standard_name_size) 
    37    { 
    38       std::string standard_name_str;  
    39       if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    40  
    41       domain_hdl->standard_name.setValue(standard_name_str); 
    42       domain_hdl->sendAttributToServer(domain_hdl->standard_name) ;  
    43    } 
    44     
    45    void cxios_set_domain_long_name(XDomainPtr domain_hdl, const char * long_name, int long_name_size) 
    46    { 
    47       std::string long_name_str;  
    48       if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
    49  
    50       domain_hdl->long_name.setValue(long_name_str); 
    51       domain_hdl->sendAttributToServer(domain_hdl->long_name) ;  
    52    } 
    53     
    54    void cxios_set_domain_domain_group_ref(XDomainPtr domain_hdl, const char * domain_group_ref, int domain_group_ref_size) 
    55    { 
    56       std::string domain_group_ref_str;  
    57       if (!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return; 
    58  
    59       domain_hdl->domain_group_ref.setValue(domain_group_ref_str); 
    60       domain_hdl->sendAttributToServer(domain_hdl->domain_group_ref) ;  
    61    } 
    62     
    63    void cxios_set_domain_ni_glo(XDomainPtr domain_hdl, int ni_glo) 
    64    { 
    65       domain_hdl->ni_glo.setValue(ni_glo); 
    66       domain_hdl->sendAttributToServer(domain_hdl->ni_glo) ;  
    67    } 
    68     
    69    void cxios_set_domain_nj_glo(XDomainPtr domain_hdl, int nj_glo) 
    70    { 
    71       domain_hdl->nj_glo.setValue(nj_glo); 
    72       domain_hdl->sendAttributToServer(domain_hdl->nj_glo) ;  
    73    } 
    74     
    75    void cxios_set_domain_ibegin(XDomainPtr domain_hdl, int ibegin) 
    76    { 
    77       domain_hdl->ibegin.setValue(ibegin); 
    78       domain_hdl->sendAttributToServer(domain_hdl->ibegin) ;  
    79    } 
    80     
    81    void cxios_set_domain_iend(XDomainPtr domain_hdl, int iend) 
    82    { 
    83       domain_hdl->iend.setValue(iend); 
    84       domain_hdl->sendAttributToServer(domain_hdl->iend) ;  
    85    } 
    86     
    87    void cxios_set_domain_ni(XDomainPtr domain_hdl, int ni) 
    88    { 
    89       domain_hdl->ni.setValue(ni); 
    90       domain_hdl->sendAttributToServer(domain_hdl->ni) ;  
    91    } 
    92     
    93    void cxios_set_domain_jbegin(XDomainPtr domain_hdl, int jbegin) 
    94    { 
    95       domain_hdl->jbegin.setValue(jbegin); 
    96       domain_hdl->sendAttributToServer(domain_hdl->jbegin) ;  
    97    } 
    98     
    99    void cxios_set_domain_jend(XDomainPtr domain_hdl, int jend) 
    100    { 
    101       domain_hdl->jend.setValue(jend); 
    102       domain_hdl->sendAttributToServer(domain_hdl->jend) ;  
    103    } 
    104     
    105    void cxios_set_domain_nj(XDomainPtr domain_hdl, int nj) 
    106    { 
    107       domain_hdl->nj.setValue(nj); 
    108       domain_hdl->sendAttributToServer(domain_hdl->nj) ;  
    109    } 
    110     
    111    void cxios_set_domain_mask(XDomainPtr domain_hdl, bool * mask, int mask_extent1, int mask_extent2) 
    112    { 
    113       ARRAY(bool, 2) mask_val(new CArray<bool, 2>(boost::extents [mask_extent1][mask_extent2])); 
    114       std::copy(mask, &(mask[mask_val->num_elements()]), mask_val->data()); 
    115  
    116       domain_hdl->mask.setValue(mask_val); 
    117       domain_hdl->sendAttributToServer(domain_hdl->mask) ;  
    118    } 
    119     
    120    void cxios_set_domain_data_dim(XDomainPtr domain_hdl, int data_dim) 
    121    { 
    122       domain_hdl->data_dim.setValue(data_dim); 
    123       domain_hdl->sendAttributToServer(domain_hdl->data_dim) ;  
    124    } 
    125     
    126    void cxios_set_domain_data_ni(XDomainPtr domain_hdl, int data_ni) 
    127    { 
    128       domain_hdl->data_ni.setValue(data_ni); 
    129       domain_hdl->sendAttributToServer(domain_hdl->data_ni) ;  
    130    } 
    131     
    132    void cxios_set_domain_data_nj(XDomainPtr domain_hdl, int data_nj) 
    133    { 
    134       domain_hdl->data_nj.setValue(data_nj); 
    135       domain_hdl->sendAttributToServer(domain_hdl->data_nj) ;  
    136    } 
    137     
    138    void cxios_set_domain_data_ibegin(XDomainPtr domain_hdl, int data_ibegin) 
    139    { 
    140       domain_hdl->data_ibegin.setValue(data_ibegin); 
    141       domain_hdl->sendAttributToServer(domain_hdl->data_ibegin) ;  
    142    } 
    143     
    144    void cxios_set_domain_data_jbegin(XDomainPtr domain_hdl, int data_jbegin) 
    145    { 
    146       domain_hdl->data_jbegin.setValue(data_jbegin); 
    147       domain_hdl->sendAttributToServer(domain_hdl->data_jbegin) ;  
    148    } 
    149     
    150    void cxios_set_domain_zoom_ni(XDomainPtr domain_hdl, int zoom_ni) 
    151    { 
    152       domain_hdl->zoom_ni.setValue(zoom_ni); 
    153       domain_hdl->sendAttributToServer(domain_hdl->zoom_ni) ;  
    154    } 
    155     
    156    void cxios_set_domain_zoom_nj(XDomainPtr domain_hdl, int zoom_nj) 
    157    { 
    158       domain_hdl->zoom_nj.setValue(zoom_nj); 
    159       domain_hdl->sendAttributToServer(domain_hdl->zoom_nj) ;  
    160    } 
    161     
    162    void cxios_set_domain_zoom_ibegin(XDomainPtr domain_hdl, int zoom_ibegin) 
    163    { 
    164       domain_hdl->zoom_ibegin.setValue(zoom_ibegin); 
    165       domain_hdl->sendAttributToServer(domain_hdl->zoom_ibegin) ;  
    166    } 
    167      
    168    void cxios_set_domain_zoom_jbegin(XDomainPtr domain_hdl, int zoom_jbegin) 
    169    { 
    170       domain_hdl->zoom_jbegin.setValue(zoom_jbegin); 
    171       domain_hdl->sendAttributToServer(domain_hdl->zoom_jbegin) ;  
    172    } 
    173     
    174    void cxios_set_domain_data_n_index(XDomainPtr domain_hdl, int data_n_index) 
    175    { 
    176       domain_hdl->data_n_index.setValue(data_n_index); 
    177       domain_hdl->sendAttributToServer(domain_hdl->data_n_index) ;  
    178    } 
    179     
    180    void cxios_set_domain_data_i_index(XDomainPtr domain_hdl, int * data_i_index, int data_i_index_extent1) 
    181    { 
    182       ARRAY(int, 1) data_i_index_val(new CArray<int, 1>(boost::extents [data_i_index_extent1])); 
    183       std::copy(data_i_index, &(data_i_index[data_i_index_val->num_elements()]), data_i_index_val->data()); 
    184  
    185       domain_hdl->data_i_index.setValue(data_i_index_val); 
    186       domain_hdl->sendAttributToServer(domain_hdl->data_i_index) ;  
    187    } 
    188     
    189    void cxios_set_domain_data_j_index(XDomainPtr domain_hdl, int * data_j_index, int data_j_index_extent1) 
    190    { 
    191       ARRAY(int, 1) data_j_index_val(new CArray<int, 1>(boost::extents [data_j_index_extent1])); 
    192       std::copy(data_j_index, &(data_j_index[data_j_index_val->num_elements()]), data_j_index_val->data()); 
    193  
    194       domain_hdl->data_j_index.setValue(data_j_index_val); 
    195       domain_hdl->sendAttributToServer(domain_hdl->data_j_index) ;  
    196    } 
    197      
    198    void cxios_set_domain_lonvalue(XDomainPtr domain_hdl, double * lonvalue, int lonvalue_extent1) 
    199    { 
    200       ARRAY(double, 1) lonvalue_val(new CArray<double, 1>(boost::extents [lonvalue_extent1])); 
    201       std::copy(lonvalue, &(lonvalue[lonvalue_val->num_elements()]), lonvalue_val->data()); 
    202  
    203       domain_hdl->lonvalue.setValue(lonvalue_val); 
    204       domain_hdl->sendAttributToServer(domain_hdl->lonvalue) ;  
    205    } 
    206     
    207    void cxios_set_domain_latvalue(XDomainPtr domain_hdl, double * latvalue, int latvalue_extent1) 
    208    { 
    209       ARRAY(double, 1) latvalue_val(new CArray<double, 1>(boost::extents [latvalue_extent1])); 
    210       std::copy(latvalue, &(latvalue[latvalue_val->num_elements()]), latvalue_val->data()); 
    211  
    212       domain_hdl->latvalue.setValue(latvalue_val); 
    213       domain_hdl->sendAttributToServer(domain_hdl->latvalue) ;  
    214    }    
    215     
    216    // -------------------- Attributs des groupes de domaine ------------------------ 
    217     
    218     
    219    void cxios_set_domaingroup_name(XDomainGroupPtr domaingroup_hdl, const char * name, int name_size) 
    220    { 
    221       std::string name_str;  
    222       if (!cstr2string(name, name_size, name_str)) return; 
    223  
    224       domaingroup_hdl->name.setValue(name_str); 
    225       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->name) ;  
    226        
    227    } 
    228     
    229    void cxios_set_domaingroup_standard_name(XDomainGroupPtr domaingroup_hdl, const char * standard_name, int standard_name_size) 
    230    { 
    231       std::string standard_name_str;  
    232       if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    233  
    234       domaingroup_hdl->standard_name.setValue(standard_name_str); 
    235       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->standard_name) ; 
    236    } 
    237     
    238    void cxios_set_domaingroup_long_name(XDomainGroupPtr domaingroup_hdl, const char * long_name, int long_name_size) 
    239    { 
    240       std::string long_name_str;  
    241       if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
    242  
    243       domaingroup_hdl->long_name.setValue(long_name_str); 
    244       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->long_name) ; 
    245    } 
    246     
    247    void cxios_set_domaingroup_domain_group_ref(XDomainGroupPtr domaingroup_hdl, const char * domain_group_ref, int domain_group_ref_size) 
    248    { 
    249       std::string domain_group_ref_str;  
    250       if (!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return; 
    251  
    252       domaingroup_hdl->domain_group_ref.setValue(domain_group_ref_str); 
    253       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->domain_group_ref) ; 
    254    } 
    255     
    256    void cxios_set_domaingroup_ni_glo(XDomainGroupPtr domaingroup_hdl, int ni_glo) 
    257    { 
    258       domaingroup_hdl->ni_glo.setValue(ni_glo); 
    259       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ni_glo) ; 
    260    } 
    261     
    262    void cxios_set_domaingroup_nj_glo(XDomainGroupPtr domaingroup_hdl, int nj_glo) 
    263    { 
    264       domaingroup_hdl->nj_glo.setValue(nj_glo); 
    265       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->nj_glo) ; 
    266    } 
    267     
    268    void cxios_set_domaingroup_ibegin(XDomainGroupPtr domaingroup_hdl, int ibegin) 
    269    { 
    270       domaingroup_hdl->ibegin.setValue(ibegin); 
    271       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ibegin) ; 
    272    } 
    273     
    274    void cxios_set_domaingroup_iend(XDomainGroupPtr domaingroup_hdl, int iend) 
    275    { 
    276       domaingroup_hdl->iend.setValue(iend); 
    277       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->iend) ; 
    278    } 
    279     
    280    void cxios_set_domaingroup_ni(XDomainGroupPtr domaingroup_hdl, int ni) 
    281    { 
    282       domaingroup_hdl->ni.setValue(ni); 
    283       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ni) ; 
    284    } 
    285     
    286    void cxios_set_domaingroup_jbegin(XDomainGroupPtr domaingroup_hdl, int jbegin) 
    287    { 
    288       domaingroup_hdl->jbegin.setValue(jbegin); 
    289       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->jbegin) ; 
    290    } 
    291     
    292    void cxios_set_domaingroup_jend(XDomainGroupPtr domaingroup_hdl, int jend) 
    293    { 
    294       domaingroup_hdl->jend.setValue(jend); 
    295       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->jend) ; 
    296    } 
    297     
    298    void cxios_set_domaingroup_nj(XDomainGroupPtr domaingroup_hdl, int nj) 
    299    { 
    300       domaingroup_hdl->nj.setValue(nj); 
    301       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->nj) ; 
    302    } 
    303     
    304    void cxios_set_domaingroup_mask(XDomainGroupPtr domaingroup_hdl, bool * mask, int mask_extent1, int mask_extent2) 
    305    { 
    306       ARRAY(bool, 2) mask_val(new CArray<bool, 2>(boost::extents [mask_extent1][mask_extent2])); 
    307       std::copy(mask, &(mask[mask_val->num_elements()]), mask_val->data()); 
    308  
    309       domaingroup_hdl->mask.setValue(mask_val); 
    310       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->mask) ; 
    311    } 
    312     
    313    void cxios_set_domaingroup_data_dim(XDomainGroupPtr domaingroup_hdl, int data_dim) 
    314    { 
    315       domaingroup_hdl->data_dim.setValue(data_dim); 
    316       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_dim) ; 
    317    } 
    318     
    319    void cxios_set_domaingroup_data_ni(XDomainGroupPtr domaingroup_hdl, int data_ni) 
    320    { 
    321       domaingroup_hdl->data_ni.setValue(data_ni); 
    322       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_ni) ; 
    323    } 
    324     
    325    void cxios_set_domaingroup_data_nj(XDomainGroupPtr domaingroup_hdl, int data_nj) 
    326    { 
    327       domaingroup_hdl->data_nj.setValue(data_nj); 
    328       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_nj) ; 
    329    } 
    330     
    331    void cxios_set_domaingroup_data_ibegin(XDomainGroupPtr domaingroup_hdl, int data_ibegin) 
    332    { 
    333       domaingroup_hdl->data_ibegin.setValue(data_ibegin); 
    334       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_ibegin) ; 
    335    } 
    336     
    337    void cxios_set_domaingroup_data_jbegin(XDomainGroupPtr domaingroup_hdl, int data_jbegin) 
    338    { 
    339       domaingroup_hdl->data_jbegin.setValue(data_jbegin); 
    340       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_jbegin) ; 
    341    } 
    342     
    343    void cxios_set_domaingroup_zoom_ni(XDomainGroupPtr domaingroup_hdl, int zoom_ni) 
    344    { 
    345       domaingroup_hdl->zoom_ni.setValue(zoom_ni); 
    346       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ni) ; 
    347    } 
    348     
    349    void cxios_set_domaingroup_zoom_nj(XDomainGroupPtr domaingroup_hdl, int zoom_nj) 
    350    { 
    351       domaingroup_hdl->zoom_nj.setValue(zoom_nj); 
    352       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_nj) ; 
    353    } 
    354     
    355    void cxios_set_domaingroup_zoom_ibegin(XDomainGroupPtr domaingroup_hdl, int zoom_ibegin) 
    356    { 
    357       domaingroup_hdl->zoom_ibegin.setValue(zoom_ibegin); 
    358       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ibegin) ; 
    359    } 
    360      
    361    void cxios_set_domaingroup_zoom_jbegin(XDomainGroupPtr domaingroup_hdl, int zoom_jbegin) 
    362    { 
    363       domaingroup_hdl->zoom_jbegin.setValue(zoom_jbegin); 
    364       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_jbegin) ; 
    365    } 
    366     
    367    void cxios_set_domaingroup_data_n_index(XDomainGroupPtr domaingroup_hdl, int data_n_index) 
    368    { 
    369       domaingroup_hdl->data_n_index.setValue(data_n_index); 
    370       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_n_index) ; 
    371    } 
    372     
    373    void cxios_set_domaingroup_data_i_index(XDomainGroupPtr domaingroup_hdl, int * data_i_index, int data_i_index_extent1) 
    374    { 
    375       ARRAY(int, 1) data_i_index_val(new CArray<int, 1>(boost::extents [data_i_index_extent1])); 
    376       std::copy(data_i_index, &(data_i_index[data_i_index_val->num_elements()]), data_i_index_val->data()); 
    377  
    378       domaingroup_hdl->data_i_index.setValue(data_i_index_val); 
    379       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_i_index) ; 
    380    } 
    381     
    382    void cxios_set_domaingroup_data_j_index(XDomainGroupPtr domaingroup_hdl, int * data_j_index, int data_j_index_extent1) 
    383    { 
    384       ARRAY(int, 1) data_j_index_val(new CArray<int, 1>(boost::extents [data_j_index_extent1])); 
    385       std::copy(data_j_index, &(data_j_index[data_j_index_val->num_elements()]), data_j_index_val->data()); 
    386  
    387       domaingroup_hdl->data_j_index.setValue(data_j_index_val); 
    388       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_j_index) ; 
    389    } 
    390      
    391    void cxios_set_domaingroup_lonvalue(XDomainGroupPtr domaingroup_hdl, double * lonvalue, int lonvalue_extent1) 
    392    { 
    393       ARRAY(double, 1) lonvalue_val(new CArray<double, 1>(boost::extents [lonvalue_extent1])); 
    394       std::copy(lonvalue, &(lonvalue[lonvalue_val->num_elements()]), lonvalue_val->data()); 
    395  
    396       domaingroup_hdl->lonvalue.setValue(lonvalue_val); 
    397       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->lonvalue) ; 
    398    } 
    399     
    400    void cxios_set_domaingroup_latvalue(XDomainGroupPtr domaingroup_hdl, double * latvalue, int latvalue_extent1) 
    401    { 
    402       ARRAY(double, 1) latvalue_val(new CArray<double, 1>(boost::extents [latvalue_extent1])); 
    403       std::copy(latvalue, &(latvalue[latvalue_val->num_elements()]), latvalue_val->data()); 
    404  
    405       domaingroup_hdl->latvalue.setValue(latvalue_val); 
    406       domaingroup_hdl->sendAttributToServer(domaingroup_hdl->latvalue) ; 
    407    }   
    408     
    40925   // ------------------------ Création des handle ----------------------------- 
    41026    
  • XIOS/trunk/src/fortran/icfield.cpp

    r310 r313  
    2222   typedef xmlioserver::tree::CField      * XFieldPtr; 
    2323   typedef xmlioserver::tree::CFieldGroup * XFieldGroupPtr; 
    24  
    25    // ------------------------- Attributs des champs --------------------------- 
    2624    
    27    void cxios_set_field_name(XFieldPtr field_hdl, const char * name, int name_size) 
    28    { 
    29       std::string name_str;  
    30       if (!cstr2string(name, name_size, name_str)) return; 
    31  
    32       field_hdl->name.setValue(name_str); 
    33       field_hdl->sendAttributToServer(field_hdl->name) ;  
    34    } 
    35     
    36    void cxios_set_field_standard_name(XFieldPtr field_hdl, const char * standard_name, int standard_name_size) 
    37    { 
    38       std::string standard_name_str;  
    39       if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    40  
    41       field_hdl->standard_name.setValue(standard_name_str); 
    42       field_hdl->sendAttributToServer(field_hdl->standard_name) ;  
    43    } 
    44     
    45    void cxios_set_field_long_name(XFieldPtr field_hdl, const char * long_name, int long_name_size) 
    46    { 
    47       std::string long_name_str;  
    48       if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
    49  
    50       field_hdl->long_name.setValue(long_name_str); 
    51       field_hdl->sendAttributToServer(field_hdl->long_name) ; 
    52    } 
    53     
    54    void cxios_set_field_unit(XFieldPtr field_hdl, const char * unit, int unit_size) 
    55    { 
    56       std::string unit_str;  
    57       if (!cstr2string(unit, unit_size, unit_str)) return; 
    58  
    59       field_hdl->unit.setValue(unit_str); 
    60       field_hdl->sendAttributToServer(field_hdl->unit) ; 
    61  
    62    } 
    63     
    64    void cxios_set_field_operation(XFieldPtr field_hdl, const char * operation, int operation_size)  
    65    { 
    66       std::string operation_str;  
    67       if (!cstr2string(operation, operation_size, operation_str)) return; 
    68  
    69       field_hdl->operation.setValue(operation_str); 
    70       field_hdl->sendAttributToServer(field_hdl->operation) ; 
    71    } 
    72     
    73    void cxios_set_field_freq_op(XFieldPtr field_hdl, const char * freq_op, int freq_op_size) 
    74    { 
    75       std::string freq_op_str;  
    76       if (!cstr2string(freq_op, freq_op_size, freq_op_str)) return; 
    77  
    78       field_hdl->freq_op.setValue(freq_op_str); 
    79       field_hdl->sendAttributToServer(field_hdl->freq_op) ; 
    80    } 
    81     
    82    void cxios_set_field_level(XFieldPtr field_hdl, int level) 
    83    { 
    84       field_hdl->level.setValue(level); 
    85       field_hdl->sendAttributToServer(field_hdl->level) ; 
    86    } 
    87     
    88    void cxios_set_field_prec(XFieldPtr field_hdl, int prec) 
    89    { 
    90       field_hdl->prec.setValue(prec); 
    91       field_hdl->sendAttributToServer(field_hdl->prec) ; 
    92    } 
    93     
    94    void cxios_set_field_enabled(XFieldPtr field_hdl, bool enabled) 
    95    { 
    96       field_hdl->enabled.setValue(enabled); 
    97       field_hdl->sendAttributToServer(field_hdl->enabled) ; 
    98    } 
    99     
    100    void cxios_set_field_domain_ref(XFieldPtr field_hdl,  const char * domain_ref, int domain_ref_size) 
    101    { 
    102       std::string domain_ref_str;  
    103       if (!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
    104  
    105       field_hdl->domain_ref.setValue(domain_ref_str); 
    106       field_hdl->sendAttributToServer(field_hdl->domain_ref) ; 
    107    } 
    108     
    109    void cxios_set_field_axis_ref(XFieldPtr field_hdl,  const char * axis_ref,  int axis_ref_size) 
    110    { 
    111       std::string axis_ref_str;  
    112       if (!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
    113  
    114       field_hdl->axis_ref.setValue(axis_ref_str); 
    115       field_hdl->sendAttributToServer(field_hdl->axis_ref) ; 
    116    } 
    117     
    118    void cxios_set_field_grid_ref(XFieldPtr field_hdl,  const char * grid_ref, int grid_ref_size) 
    119    { 
    120       std::string grid_ref_str;  
    121       if (!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return; 
    122  
    123       field_hdl->grid_ref.setValue(grid_ref_str); 
    124       field_hdl->sendAttributToServer(field_hdl->grid_ref) ; 
    125    } 
    126     
    127    void cxios_set_field_field_ref(XFieldPtr field_hdl,  const char * field_ref,  int field_ref_size) 
    128    { 
    129       std::string field_ref_str;  
    130       if (!cstr2string(field_ref, field_ref_size, field_ref_str)) return; 
    131  
    132       field_hdl->field_ref.setValue(field_ref_str); 
    133       field_hdl->sendAttributToServer(field_hdl->field_ref) ; 
    134    } 
    135     
    136    void cxios_set_field_default_value(XFieldPtr field_hdl, double default_value) 
    137    { 
    138       field_hdl->default_value.setValue(default_value); 
    139       field_hdl->sendAttributToServer(field_hdl->default_value) ; 
    140    }   
    141     
    142    // -------------------- Attributs des groupes de champs --------------------- 
    143    
    144    void cxios_set_fieldgroup_name(XFieldGroupPtr fieldgroup_hdl, const char * name, int name_size) 
    145    { 
    146       std::string name_str;  
    147       if (!cstr2string(name, name_size, name_str)) return; 
    148  
    149       fieldgroup_hdl->name.setValue(name_str); 
    150       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->name); 
    151    } 
    152     
    153    void cxios_set_fieldgroup_standard_name(XFieldGroupPtr fieldgroup_hdl, const char * standard_name, int standard_name_size) 
    154    { 
    155       std::string standard_name_str;  
    156       if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
    157  
    158       fieldgroup_hdl->standard_name.setValue(standard_name_str); 
    159       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->standard_name); 
    160    } 
    161     
    162    void cxios_set_fieldgroup_long_name(XFieldGroupPtr fieldgroup_hdl, const char * long_name, int long_name_size) 
    163    { 
    164       std::string long_name_str;  
    165       if (!cstr2string(long_name, long_name_size, long_name_str)) return; 
    166  
    167       fieldgroup_hdl->long_name.setValue(long_name_str); 
    168       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->long_name); 
    169    } 
    170     
    171    void cxios_set_fieldgroup_unit(XFieldGroupPtr fieldgroup_hdl, const char * unit, int unit_size) 
    172    { 
    173       std::string unit_str;  
    174       if (!cstr2string(unit, unit_size, unit_str)) return; 
    175  
    176       fieldgroup_hdl->unit.setValue(unit_str); 
    177       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->unit); 
    178    } 
    179     
    180    void cxios_set_fieldgroup_operation(XFieldGroupPtr fieldgroup_hdl, const char * operation, int operation_size)  
    181    { 
    182       std::string operation_str;  
    183       if (!cstr2string(operation, operation_size, operation_str)) return; 
    184  
    185       fieldgroup_hdl->operation.setValue(operation_str); 
    186       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->operation); 
    187    } 
    188     
    189    void cxios_set_fieldgroup_freq_op(XFieldGroupPtr fieldgroup_hdl, const char * freq_op, int freq_op_size) 
    190    { 
    191       std::string freq_op_str;  
    192       if (!cstr2string(freq_op, freq_op_size, freq_op_str)) return; 
    193  
    194       fieldgroup_hdl->freq_op.setValue(freq_op_str); 
    195       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->freq_op); 
    196    } 
    197     
    198    void cxios_set_fieldgroup_level(XFieldGroupPtr fieldgroup_hdl, int level) 
    199    { 
    200       fieldgroup_hdl->level.setValue(level); 
    201       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->level); 
    202    } 
    203     
    204    void cxios_set_fieldgroup_prec(XFieldGroupPtr fieldgroup_hdl, int prec) 
    205    { 
    206       fieldgroup_hdl->prec.setValue(prec); 
    207       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->prec); 
    208    } 
    209     
    210    void cxios_set_fieldgroup_enabled(XFieldGroupPtr fieldgroup_hdl, bool enabled) 
    211    { 
    212       fieldgroup_hdl->enabled.setValue(enabled); 
    213       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->enabled); 
    214    } 
    215     
    216    void cxios_set_fieldgroup_domain_ref(XFieldGroupPtr fieldgroup_hdl,  const char * domain_ref, int domain_ref_size) 
    217    { 
    218       std::string domain_ref_str;  
    219       if (!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
    220  
    221       fieldgroup_hdl->domain_ref.setValue(domain_ref_str); 
    222       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->domain_ref); 
    223    } 
    224     
    225    void cxios_set_fieldgroup_axis_ref(XFieldGroupPtr fieldgroup_hdl,  const char * axis_ref,  int axis_ref_size) 
    226    { 
    227       std::string axis_ref_str;  
    228       if (!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
    229  
    230       fieldgroup_hdl->axis_ref.setValue(axis_ref_str); 
    231       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->axis_ref); 
    232    } 
    233     
    234    void cxios_set_fieldgroup_grid_ref(XFieldGroupPtr fieldgroup_hdl,  const char * grid_ref, int grid_ref_size) 
    235    { 
    236       std::string grid_ref_str;  
    237       if (!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return; 
    238  
    239       fieldgroup_hdl->grid_ref.setValue(grid_ref_str); 
    240       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->grid_ref); 
    241    } 
    242     
    243    void cxios_set_fieldgroup_field_ref(XFieldGroupPtr fieldgroup_hdl,  const char * field_ref,  int field_ref_size) 
    244    { 
    245       std::string field_ref_str;  
    246       if (!cstr2string(field_ref, field_ref_size, field_ref_str)) return; 
    247  
    248       fieldgroup_hdl->field_ref.setValue(field_ref_str); 
    249       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->field_ref); 
    250    } 
    251     
    252    void cxios_set_fieldgroup_default_value(XFieldGroupPtr fieldgroup_hdl, double default_value) 
    253    { 
    254       fieldgroup_hdl->default_value.setValue(default_value); 
    255       fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->default_value); 
    256    }   
    257     
    258    // ------------------------ Création des handle ----------------------------- 
     25// --------------------------------------------------------------------------    
     26// ------------------------ Création des handle ----------------------------- 
     27// --------------------------------------------------------------------------    
    25928    
    26029   void cxios_field_handle_create (XFieldPtr * _ret, const char * _id, int _id_len) 
     
    29261      *_ret = xmlioserver::CObjectFactory::HasObject<xmlioserver::tree::CFieldGroup>(id); 
    29362   } 
    294     
    295    void cxios_field_is_active (XFieldPtr field_hdl, bool* ret) 
    296    { 
    297       *ret = field_hdl->isActive(); 
    298    } 
     63 
     64// -----------------------------------------------------------------------------------------------------    
     65// ------------------------- other function----------  --------------------------- --------------------- 
     66// -----------------------------------------------------------------------------------------------------    
     67 
     68  void cxios_field_is_active (XFieldPtr field_hdl, bool* ret) 
     69  { 
     70    *ret = field_hdl->isActive(); 
     71  } 
    29972    
    30073} // extern "C" 
  • XIOS/trunk/src/fortran/icfile.cpp

    r300 r313  
    2323   typedef xmlioserver::tree::CFileGroup * XFileGroupPtr; 
    2424 
    25    // ------------------------- Attributs des axes ----------------------------- 
    26     
    27    void cxios_set_file_name(XFilePtr file_hdl, const char * name, int name_size) 
    28    { 
    29       std::string name_str;  
    30       if (!cstr2string(name, name_size, name_str)) return; 
    31  
    32       file_hdl->name.setValue(name_str); 
    33       file_hdl->sendAttributToServer(file_hdl->name) ; 
    34    } 
    35     
    36    void cxios_set_file_description(XFilePtr file_hdl, const char * description, int description_size) 
    37    { 
    38       std::string description_str;  
    39       if (!cstr2string(description, description_size, description_str)) return; 
    40  
    41       file_hdl->description.setValue(description_str); 
    42       file_hdl->sendAttributToServer(file_hdl->description) ; 
    43    }  
    44     
    45    void cxios_set_file_name_suffix(XFilePtr file_hdl, const char * name_suffix, int name_suffix_size) 
    46    { 
    47       std::string name_suffix_str;  
    48       if (!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return; 
    49  
    50       file_hdl->name_suffix.setValue(name_suffix_str); 
    51       file_hdl->sendAttributToServer(file_hdl->name_suffix) ; 
    52    }  
    53     
    54    void cxios_set_file_output_freq(XFilePtr file_hdl, const char * output_freq, int output_freq_size) 
    55    { 
    56       std::string output_freq_str;  
    57       if (!cstr2string(output_freq, output_freq_size, output_freq_str)) return; 
    58  
    59       file_hdl->output_freq.setValue(output_freq_str); 
    60       file_hdl->sendAttributToServer(file_hdl->output_freq) ; 
    61    } 
    62     
    63    void cxios_set_file_output_level(XFilePtr file_hdl, int output_level) 
    64    { 
    65       file_hdl->output_level.setValue(output_level); 
    66       file_hdl->sendAttributToServer(file_hdl->output_level) ; 
    67    } 
    68     
    69    void cxios_set_file_enabled(XFilePtr file_hdl, bool enabled) 
    70    { 
    71       file_hdl->enabled.setValue(enabled); 
    72       file_hdl->sendAttributToServer(file_hdl->enabled) ; 
    73    } 
    74     
    75    void cxios_set_file_type(XFilePtr file_hdl, const char * type, int type_size) 
    76    { 
    77       std::string type_str;  
    78       if (!cstr2string(type, type_size, type_str)) return; 
    79  
    80       file_hdl->type.setValue(type_str); 
    81       file_hdl->sendAttributToServer(file_hdl->type) ; 
    82    } 
    83     
    84    // -------------------- Attributs des groupes d'axes ------------------------ 
    85     
    86    void cxios_set_filegroup_name(XFileGroupPtr filegroup_hdl, const char * name, int name_size) 
    87    { 
    88       std::string name_str;  
    89       if (!cstr2string(name, name_size, name_str)) return; 
    90  
    91       filegroup_hdl->name.setValue(name_str); 
    92       filegroup_hdl->sendAttributToServer(filegroup_hdl->name) ; 
    93    } 
    94     
    95    void cxios_set_filegroup_description(XFileGroupPtr filegroup_hdl, const char * description, int description_size) 
    96    { 
    97       std::string description_str;  
    98       if (!cstr2string(description, description_size, description_str)) return; 
    99  
    100       filegroup_hdl->description.setValue(description_str); 
    101       filegroup_hdl->sendAttributToServer(filegroup_hdl->description) ; 
    102    }  
    103     
    104    void cxios_set_filegroup_name_suffix(XFileGroupPtr filegroup_hdl, const char * name_suffix, int name_suffix_size) 
    105    { 
    106       std::string name_suffix_str;  
    107       if (!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return; 
    108  
    109       filegroup_hdl->name_suffix.setValue(name_suffix_str); 
    110       filegroup_hdl->sendAttributToServer(filegroup_hdl->name_suffix) ; 
    111    }  
    112     
    113    void cxios_set_filegroup_output_freq(XFileGroupPtr filegroup_hdl, const char * output_freq, int output_freq_size) 
    114    { 
    115       std::string output_freq_str;  
    116       if (!cstr2string(output_freq, output_freq_size, output_freq_str)) return; 
    117  
    118       filegroup_hdl->output_freq.setValue(output_freq_str); 
    119       filegroup_hdl->sendAttributToServer(filegroup_hdl->output_freq) ; 
    120    } 
    121     
    122    void cxios_set_filegroup_output_level(XFileGroupPtr filegroup_hdl, int output_level) 
    123    { 
    124       filegroup_hdl->output_level.setValue(output_level); 
    125       filegroup_hdl->sendAttributToServer(filegroup_hdl->output_level) ; 
    126    } 
    127     
    128    void cxios_set_filegroup_enabled(XFileGroupPtr filegroup_hdl, bool enabled) 
    129    { 
    130       filegroup_hdl->enabled.setValue(enabled); 
    131       filegroup_hdl->sendAttributToServer(filegroup_hdl->enabled) ; 
    132    } 
    133     
    134    void cxios_set_filegroup_type(XFileGroupPtr filegroup_hdl, const char * type, int type_size) 
    135    { 
    136       std::string type_str;  
    137       if (!cstr2string(type, type_size, type_str)) return; 
    138  
    139       filegroup_hdl->type.setValue(type_str); 
    140       filegroup_hdl->sendAttributToServer(filegroup_hdl->type) ; 
    141    } 
    142     
    14325   // ------------------------ Création des handle ----------------------------- 
    14426    
  • XIOS/trunk/src/fortran/icgrid.cpp

    r300 r313  
    2323   typedef xmlioserver::tree::CGridGroup * XGridGroupPtr; 
    2424 
    25    // ------------------------- Attributs des axes ----------------------------- 
    26     
    27    void cxios_set_grid_name(XGridPtr grid_hdl, const char * name,  int name_size) 
    28    { 
    29       std::string name_str;  
    30       if (!cstr2string(name, name_size, name_str)) return; 
    31  
    32       grid_hdl->name.setValue(name_str); 
    33       grid_hdl->sendAttributToServer(name_str) ; 
    34    } 
    35     
    36    void cxios_set_grid_description(XGridPtr grid_hdl, const char * description,  int description_size) 
    37    { 
    38       std::string description_str;  
    39       if (!cstr2string(description, description_size, description_str)) return; 
    40  
    41       grid_hdl->description.setValue(description_str); 
    42       grid_hdl->sendAttributToServer(description_str) ; 
    43    } 
    44     
    45    void cxios_set_grid_domain_ref(XGridPtr grid_hdl, const char * domain_ref,  int domain_ref_size) 
    46    { 
    47       std::string domain_ref_str;  
    48       if (!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
    49  
    50       grid_hdl->domain_ref.setValue(domain_ref_str); 
    51       grid_hdl->sendAttributToServer(domain_ref_str) ; 
    52    } 
    53     
    54    void cxios_set_grid_axis_ref(XGridPtr grid_hdl, const char * axis_ref,  int axis_ref_size) 
    55    { 
    56       std::string axis_ref_str;  
    57       if (!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
    58  
    59      grid_hdl->axis_ref.setValue(axis_ref_str); 
    60      grid_hdl->sendAttributToServer(axis_ref_str) ; 
    61    } 
    62     
    63    // -------------------- Attributs des groupes de grilles -------------------- 
    64     
    65    void cxios_set_gridgroup_name(XGridGroupPtr gridgroup_hdl, const char * name,  int name_size) 
    66    { 
    67       std::string name_str;  
    68       if (!cstr2string(name, name_size, name_str)) return; 
    69  
    70       gridgroup_hdl->name.setValue(name_str); 
    71       gridgroup_hdl->sendAttributToServer(gridgroup_hdl->name) ; 
    72    } 
    73     
    74    void cxios_set_gridgroup_description(XGridGroupPtr gridgroup_hdl, const char * description,  int description_size) 
    75    { 
    76       std::string description_str;  
    77       if (!cstr2string(description, description_size, description_str)) return; 
    78  
    79       gridgroup_hdl->description.setValue(description_str); 
    80       gridgroup_hdl->sendAttributToServer(gridgroup_hdl->description) ; 
    81    } 
    82     
    83    void cxios_set_gridgroup_domain_ref(XGridGroupPtr gridgroup_hdl, const char * domain_ref,  int domain_ref_size) 
    84    { 
    85       std::string domain_ref_str;  
    86       if (!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
    87  
    88       gridgroup_hdl->domain_ref.setValue(domain_ref_str); 
    89       gridgroup_hdl->sendAttributToServer(gridgroup_hdl->domain_ref) ; 
    90    } 
    91     
    92    void cxios_set_gridgroup_axis_ref(XGridGroupPtr gridgroup_hdl, const char * axis_ref,  int axis_ref_size) 
    93    { 
    94       std::string axis_ref_str;  
    95       if (!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
    96  
    97       gridgroup_hdl->axis_ref.setValue(axis_ref_str); 
    98       gridgroup_hdl->sendAttributToServer(gridgroup_hdl->axis_ref) ; 
    99    } 
    100     
    10125   // ------------------------ Création des handle ----------------------------- 
    10226   
  • XIOS/trunk/src/fortran/icontext.F90

    r312 r313  
    44   USE, INTRINSIC :: ISO_C_BINDING 
    55   USE CONTEXT_INTERFACE 
     6!   USE icontext_attr 
    67   USE IDATE 
    78 
     
    1415   CONTAINS ! Fonctions disponibles pour les utilisateurs. 
    1516    
    16    SUBROUTINE xios(set_context_attr)( context_id, calendar_type, start_date, output_dir) 
    17       IMPLICIT NONE 
    18       CHARACTER(len = *)            , INTENT(IN) :: context_id 
    19       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: calendar_type 
    20       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: start_date 
    21       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: output_dir 
    22           
    23       CALL xios(set_context_attr_)( context_id, calendar_type, start_date, output_dir) 
    24    END SUBROUTINE xios(set_context_attr) 
    25  
    26  
    27    SUBROUTINE xios(set_context_attr_)( context_id, calendar_type_, start_date_, output_dir_) 
    28       IMPLICIT NONE 
    29       CHARACTER(len = *)            , INTENT(IN) :: context_id 
    30       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: calendar_type_ 
    31       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: start_date_ 
    32       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: output_dir_ 
    33       TYPE(txios(context))                      :: context_hdl 
    34           
    35       CALL xios(get_context_handle)(context_id,context_hdl) 
    36       CALL xios(set_context_attr_hdl_)( context_hdl, calendar_type_, start_date_, output_dir_) 
    37    END SUBROUTINE xios(set_context_attr_) 
    38  
    39  
    40    SUBROUTINE xios(set_context_attr_hdl)( context_hdl, calendar_type, start_date, output_dir) 
    41       IMPLICIT NONE 
    42       TYPE(txios(context))          , INTENT(IN) :: context_hdl 
    43       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: calendar_type 
    44       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: start_date 
    45       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: output_dir    
    46          
    47       CALL  xios(set_context_attr_hdl_)( context_hdl, calendar_type, start_date, output_dir)   
    48  
    49    END SUBROUTINE xios(set_context_attr_hdl) 
    50  
    51    SUBROUTINE xios(set_context_attr_hdl_)( context_hdl, calendar_type_, start_date_, output_dir_) 
    52       IMPLICIT NONE 
    53       TYPE(txios(context))          , INTENT(IN) :: context_hdl 
    54       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: calendar_type_ 
    55       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: start_date_ 
    56       CHARACTER(len = *)  , OPTIONAL, INTENT(IN) :: output_dir_    
    57           
    58       IF (PRESENT(calendar_type_)) THEN 
    59          CALL cxios_set_context_calendar_type(context_hdl%daddr, calendar_type_, len(calendar_type_)) 
    60       END IF 
    61       IF (PRESENT(start_date_))    THEN 
    62          CALL cxios_set_context_start_date(context_hdl%daddr, start_date_, len(start_date_)) 
    63       END IF 
    64       IF (PRESENT(output_dir_))    THEN 
    65          CALL cxios_set_context_output_dir(context_hdl%daddr, output_dir_, len(output_dir_)) 
    66       END IF 
    67    END SUBROUTINE xios(set_context_attr_hdl_) 
    68  
    69  
    70  
    7117   SUBROUTINE xios(get_context_handle)(idt,ret) 
    7218      IMPLICIT NONE 
  • XIOS/trunk/src/fortran/icutil.hpp

    r274 r313  
    88 
    99#include <string> 
    10  
     10#include <string.h> 
    1111// ///////////////////////// Définitions/Déclarations /////////////////////// // 
    1212 
     
    2929} 
    3030 
     31inline bool string_copy(const string& str, char* cstr,int cstr_size) 
     32{ 
     33   
     34  if (str.size()>cstr_size) return false ; 
     35  else 
     36  { 
     37    std::memset (cstr,' ',cstr_size); 
     38    str.copy(cstr,cstr_size) ; 
     39    return true ; 
     40  } 
     41} 
     42  template<class T> 
     43  inline  bool array_copy(ARRAY(T,1) array_in, T* array_out, size_t extent1) 
     44  { 
     45    if (array_in->num_elements() != extent1) return false ; 
     46    std::copy(array_in->data(), array_in->data() + array_in->num_elements(), array_out); 
     47    return true ; 
     48  } 
     49 
     50  template<class T> 
     51  inline  bool array_copy(ARRAY(T,2) array_in, T* array_out, size_t extent1, size_t extent2) 
     52  { 
     53    if (array_in->num_elements() != extent1*extent2) return false ; 
     54    std::copy(array_in->data(), array_in->data() + array_in->num_elements(), array_out); 
     55    return true ; 
     56  } 
     57 
     58  template<class T> 
     59  inline  bool array_copy(ARRAY(T,3) array_in, T* array_out, size_t extent1, size_t extent2, size_t extent3) 
     60  { 
     61    if (array_in->num_elements() != extent1*extent2*extent3) return false ; 
     62    std::copy(array_in->data(), array_in->data() + array_in->num_elements(), array_out); 
     63    return true ; 
     64  }         
     65 
     66 
    3167#endif // __ICUTIL_HPP__ 
  • XIOS/trunk/src/fortran/idomain.F90

    r312 r313  
    55   USE DOMAIN_INTERFACE 
    66   USE DOMAINGROUP_INTERFACE 
    7     
     7!   USE IDOMAIN_ATTR 
     8!   USE IDOMAINGROUP_ATTR 
     9       
    810   TYPE txios(domain) 
    911      INTEGER(kind = C_INTPTR_T) :: daddr 
     
    1719   CONTAINS ! Fonctions disponibles pour les utilisateurs. 
    1820 
    19  
    20    SUBROUTINE xios(set_domaingroup_attr)                                                                   & 
    21    ( domaingroup_id, name, standard_name, long_name, domain_group_ref, ni_glo, nj_glo, ibegin, iend,       & 
    22      ni, jbegin, jend, nj, mask, data_dim, data_ni, data_nj, data_ibegin, data_jbegin,                     & 
    23      zoom_ni, zoom_nj, zoom_ibegin, zoom_jbegin, data_n_index, data_i_index, data_j_index,                 & 
    24      lonvalue, latvalue) 
    25       IMPLICIT NONE 
    26       TYPE(txios(domaingroup))                              :: domaingroup_hdl 
    27       CHARACTER(len = *)                       , INTENT(IN) :: domaingroup_id 
    28       CHARACTER(len = *)             , OPTIONAL, INTENT(IN) :: name 
    29       CHARACTER(len = *)             , OPTIONAL, INTENT(IN) :: standard_name 
    30       CHARACTER(len = *)             , OPTIONAL, INTENT(IN) :: long_name 
    31       CHARACTER(len = *)             , OPTIONAL, INTENT(IN) :: domain_group_ref 
    32       INTEGER                        , OPTIONAL, INTENT(IN) :: ni_glo 
    33       INTEGER                        , OPTIONAL, INTENT(IN) :: nj_glo 
    34       INTEGER                        , OPTIONAL, INTENT(IN) :: ibegin 
    35       INTEGER                        , OPTIONAL, INTENT(IN) :: iend 
    36       INTEGER                        , OPTIONAL, INTENT(IN) :: ni 
    37       INTEGER                        , OPTIONAL, INTENT(IN) :: jbegin 
    38       INTEGER                        , OPTIONAL, INTENT(IN) :: jend 
    39       INTEGER                        , OPTIONAL, INTENT(IN) :: nj 
    40       LOGICAL          , dimension(*), OPTIONAL, INTENT(IN) :: mask(:,:) 
    41       INTEGER                        , OPTIONAL, INTENT(IN) :: data_dim 
    42       INTEGER                        , OPTIONAL, INTENT(IN) :: data_ni 
    43       INTEGER                        , OPTIONAL, INTENT(IN) :: data_nj 
    44       INTEGER                        , OPTIONAL, INTENT(IN) :: data_ibegin 
    45       INTEGER                        , OPTIONAL, INTENT(IN) :: data_jbegin 
    46       INTEGER                        , OPTIONAL, INTENT(IN) :: zoom_ni 
    47       INTEGER                        , OPTIONAL, INTENT(IN) :: zoom_nj 
    48       INTEGER                        , OPTIONAL, INTENT(IN) :: zoom_ibegin 
    49       INTEGER                        , OPTIONAL, INTENT(IN) :: zoom_jbegin 
    50       INTEGER                        , OPTIONAL, INTENT(IN) :: data_n_index 
    51       INTEGER       , dimension(*)   , OPTIONAL, INTENT(IN) :: data_i_index(:) 
    52       INTEGER       , dimension(*)   , OPTIONAL, INTENT(IN) :: data_j_index(:) 
    53       REAL(kind = 8), dimension(*)   , OPTIONAL, INTENT(IN) :: lonvalue(:) 
    54       REAL(kind = 8), dimension(*)   , OPTIONAL, INTENT(IN) :: latvalue(:) 
    55   
    56       CALL xios(get_domaingroup_handle)(domaingroup_id,domaingroup_hdl) 
    57       CALL xios(set_domaingroup_attr_hdl_)                                                                 & 
    58    ( domaingroup_hdl, name, standard_name, long_name, domain_group_ref, ni_glo, nj_glo, ibegin, iend,      & 
    59      ni, jbegin, jend, nj, mask, data_dim, data_ni, data_nj, data_ibegin, data_jbegin,                     & 
    60      zoom_ni, zoom_nj, zoom_ibegin, zoom_jbegin, data_n_index, data_i_index, data_j_index,                 & 
    61      lonvalue, latvalue) 
    62  
    63    END SUBROUTINE xios(set_domaingroup_attr) 
    64  
    65    SUBROUTINE xios(set_domaingroup_attr_hdl)                                                               &    
    66    ( domaingroup_hdl,name, standard_name, long_name, domain_group_ref, ni_glo, nj_glo, ibegin, iend,       & 
    67      ni, jbegin, jend, nj, mask, data_dim, data_ni, data_nj, data_ibegin, data_jbegin,                     & 
    68      zoom_ni, zoom_nj, zoom_ibegin, zoom_jbegin, data_n_index, data_i_index,                               & 
    69      data_j_index, lonvalue, latvalue) 
    70       IMPLICIT NONE 
    71       TYPE(txios(domaingroup))             , INTENT(IN) :: domaingroup_hdl 
    72       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: name 
    73       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: standard_name 
    74       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: long_name 
    75       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: domain_group_ref 
    76       INTEGER                          , OPTIONAL, INTENT(IN) :: ni_glo 
    77       INTEGER                          , OPTIONAL, INTENT(IN) :: nj_glo 
    78       INTEGER                          , OPTIONAL, INTENT(IN) :: ibegin 
    79       INTEGER                          , OPTIONAL, INTENT(IN) :: iend 
    80       INTEGER                          , OPTIONAL, INTENT(IN) :: ni 
    81       INTEGER                          , OPTIONAL, INTENT(IN) :: jbegin 
    82       INTEGER                          , OPTIONAL, INTENT(IN) :: jend 
    83       INTEGER                          , OPTIONAL, INTENT(IN) :: nj 
    84       LOGICAL          , dimension(*)  , OPTIONAL, INTENT(IN) :: mask(:,:) 
    85       INTEGER                          , OPTIONAL, INTENT(IN) :: data_dim 
    86       INTEGER                          , OPTIONAL, INTENT(IN) :: data_ni 
    87       INTEGER                          , OPTIONAL, INTENT(IN) :: data_nj 
    88       INTEGER                          , OPTIONAL, INTENT(IN) :: data_ibegin 
    89       INTEGER                          , OPTIONAL, INTENT(IN) :: data_jbegin 
    90       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_ni 
    91       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_nj 
    92       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_ibegin 
    93       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_jbegin 
    94       INTEGER                          , OPTIONAL, INTENT(IN) :: data_n_index 
    95       INTEGER       , dimension(*)     , OPTIONAL, INTENT(IN) :: data_i_index(:) 
    96       INTEGER       , dimension(*)     , OPTIONAL, INTENT(IN) :: data_j_index(:) 
    97       REAL(kind = 8), dimension(*)     , OPTIONAL, INTENT(IN) :: lonvalue(:) 
    98       REAL(kind = 8), dimension(*)     , OPTIONAL, INTENT(IN) :: latvalue(:)    
    99  
    100       CALL xios(set_domaingroup_attr_hdl_)                                                               & 
    101    ( domaingroup_hdl,name, standard_name, long_name, domain_group_ref, ni_glo, nj_glo, ibegin, iend,     & 
    102      ni, jbegin, jend, nj, mask, data_dim, data_ni, data_nj, data_ibegin, data_jbegin,                   & 
    103      zoom_ni, zoom_nj, zoom_ibegin, zoom_jbegin, data_n_index, data_i_index, data_j_index,               & 
    104      lonvalue, latvalue) 
    105  
    106     END SUBROUTINE xios(set_domaingroup_attr_hdl) 
    107  
    108    SUBROUTINE xios(set_domaingroup_attr_hdl_)                                                                       & 
    109    ( domaingroup_hdl, name_, standard_name_, long_name_, domain_group_ref_, ni_glo_, nj_glo_, ibegin_, iend_,       & 
    110      ni_, jbegin_, jend_, nj_, mask_, data_dim_, data_ni_, data_nj_, data_ibegin_, data_jbegin_,                   & 
    111      zoom_ni_, zoom_nj_, zoom_ibegin_, zoom_jbegin_, data_n_index_, data_i_index_, data_j_index_,                  & 
    112      lonvalue_, latvalue_) 
    113       IMPLICIT NONE 
    114       TYPE(txios(domaingroup))             , INTENT(IN) :: domaingroup_hdl 
    115       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: name_ 
    116       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: standard_name_ 
    117       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: long_name_ 
    118       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: domain_group_ref_ 
    119       INTEGER                          , OPTIONAL, INTENT(IN) :: ni_glo_ 
    120       INTEGER                          , OPTIONAL, INTENT(IN) :: nj_glo_ 
    121       INTEGER                          , OPTIONAL, INTENT(IN) :: ibegin_ 
    122       INTEGER                          , OPTIONAL, INTENT(IN) :: iend_ 
    123       INTEGER                          , OPTIONAL, INTENT(IN) :: ni_ 
    124       INTEGER                          , OPTIONAL, INTENT(IN) :: jbegin_ 
    125       INTEGER                          , OPTIONAL, INTENT(IN) :: jend_ 
    126       INTEGER                          , OPTIONAL, INTENT(IN) :: nj_ 
    127       LOGICAL          , dimension(*)  , OPTIONAL, INTENT(IN) :: mask_(:,:) 
    128       LOGICAL(kind = 1), dimension(:,:), ALLOCATABLE          :: mask__! (size(mask_,1),size(mask,2)) 
    129       INTEGER                          , OPTIONAL, INTENT(IN) :: data_dim_ 
    130       INTEGER                          , OPTIONAL, INTENT(IN) :: data_ni_ 
    131       INTEGER                          , OPTIONAL, INTENT(IN) :: data_nj_ 
    132       INTEGER                          , OPTIONAL, INTENT(IN) :: data_ibegin_ 
    133       INTEGER                          , OPTIONAL, INTENT(IN) :: data_jbegin_ 
    134       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_ni_ 
    135       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_nj_ 
    136       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_ibegin_ 
    137       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_jbegin_ 
    138       INTEGER                          , OPTIONAL, INTENT(IN) :: data_n_index_ 
    139       INTEGER       , dimension(*)     , OPTIONAL, INTENT(IN) :: data_i_index_(:) 
    140       INTEGER       , dimension(*)     , OPTIONAL, INTENT(IN) :: data_j_index_(:) 
    141       REAL(kind = 8), dimension(*)     , OPTIONAL, INTENT(IN) :: lonvalue_(:) 
    142       REAL(kind = 8), dimension(*)     , OPTIONAL, INTENT(IN) :: latvalue_(:) 
    143        
    144       IF (PRESENT(name_))             THEN 
    145          CALL cxios_set_domaingroup_name(domaingroup_hdl%daddr, name_, len(name_)) 
    146       END IF 
    147       IF (PRESENT(standard_name_))    THEN 
    148          CALL cxios_set_domaingroup_standard_name(domaingroup_hdl%daddr, standard_name_, len(standard_name_)) 
    149       END IF 
    150       IF (PRESENT(long_name_))        THEN 
    151          CALL cxios_set_domaingroup_long_name(domaingroup_hdl%daddr, long_name_, len(long_name_)) 
    152        END IF 
    153       IF (PRESENT(domain_group_ref_)) THEN 
    154          CALL cxios_set_domaingroup_domain_group_ref(domaingroup_hdl%daddr, domain_group_ref_, len(domain_group_ref_)) 
    155       END IF 
    156       IF (PRESENT(ni_glo_))           THEN 
    157          CALL cxios_set_domaingroup_ni_glo(domaingroup_hdl%daddr, ni_glo_) 
    158       END IF 
    159       IF (PRESENT(nj_glo_))           THEN 
    160          CALL cxios_set_domaingroup_nj_glo(domaingroup_hdl%daddr, nj_glo_) 
    161       END IF 
    162       IF (PRESENT(ibegin_))           THEN 
    163          CALL cxios_set_domaingroup_ibegin(domaingroup_hdl%daddr, ibegin_) 
    164        END IF 
    165       IF (PRESENT(iend_))             THEN 
    166          CALL cxios_set_domaingroup_iend(domaingroup_hdl%daddr, iend_) 
    167       END IF 
    168       IF (PRESENT(ni_))               THEN 
    169          CALL cxios_set_domaingroup_ni(domaingroup_hdl%daddr, ni_) 
    170       END IF 
    171       IF (PRESENT(jbegin_))           THEN 
    172          CALL cxios_set_domaingroup_jbegin(domaingroup_hdl%daddr, jbegin_) 
    173       END IF 
    174       IF (PRESENT(jend_))             THEN 
    175          CALL cxios_set_domaingroup_jend(domaingroup_hdl%daddr, jend_) 
    176       END IF 
    177       IF (PRESENT(nj_))               THEN 
    178          CALL cxios_set_domaingroup_nj(domaingroup_hdl%daddr, nj_) 
    179       END IF 
    180       IF (PRESENT(mask_))             THEN 
    181          ALLOCATE(mask__(size(mask_, 1), size(mask_, 2))) 
    182          mask__(:,:) = mask_(:,:) 
    183          CALL cxios_set_domaingroup_mask(domaingroup_hdl%daddr, mask__, size(mask_, 1), size(mask_, 2))          
    184          DEALLOCATE(mask__) 
    185       END IF 
    186       IF (PRESENT(data_dim_))         THEN 
    187          CALL cxios_set_domaingroup_data_dim(domaingroup_hdl%daddr, data_dim_) 
    188       END IF 
    189       IF (PRESENT(data_ni_))          THEN 
    190          CALL cxios_set_domaingroup_data_ni(domaingroup_hdl%daddr, data_ni_) 
    191       END IF  
    192       IF (PRESENT(data_nj_))          THEN 
    193          CALL cxios_set_domaingroup_data_nj(domaingroup_hdl%daddr, data_nj_) 
    194       END IF 
    195       IF (PRESENT(data_ibegin_))      THEN 
    196          CALL cxios_set_domaingroup_data_ibegin(domaingroup_hdl%daddr, data_ibegin_) 
    197       END IF 
    198       IF (PRESENT(data_jbegin_))      THEN 
    199          CALL cxios_set_domaingroup_data_jbegin(domaingroup_hdl%daddr, data_jbegin_) 
    200       END IF 
    201       IF (PRESENT(zoom_ni_))          THEN 
    202          CALL cxios_set_domaingroup_zoom_ni(domaingroup_hdl%daddr, zoom_ni_) 
    203       END IF 
    204       IF (PRESENT(zoom_nj_))          THEN 
    205        CALL cxios_set_domaingroup_zoom_nj(domaingroup_hdl%daddr, zoom_nj_) 
    206       END IF 
    207       IF (PRESENT(zoom_ibegin_))      THEN 
    208          CALL cxios_set_domaingroup_zoom_ibegin(domaingroup_hdl%daddr, zoom_ibegin_) 
    209       END IF 
    210       IF (PRESENT(zoom_jbegin_))      THEN 
    211          CALL cxios_set_domaingroup_zoom_jbegin(domaingroup_hdl%daddr, zoom_jbegin_) 
    212       END IF 
    213  
    214       IF (PRESENT(data_n_index_))     THEN 
    215          CALL cxios_set_domaingroup_data_n_index(domaingroup_hdl%daddr, data_n_index_) 
    216       END IF 
    217       IF (PRESENT(data_i_index_))     THEN 
    218          CALL cxios_set_domaingroup_data_i_index(domaingroup_hdl%daddr, data_i_index_, size(data_i_index_, 1)) 
    219       END IF 
    220       IF (PRESENT(data_j_index_))     THEN 
    221          CALL cxios_set_domaingroup_data_j_index(domaingroup_hdl%daddr, data_j_index_, size(data_j_index_, 1)) 
    222       END IF 
    223       IF (PRESENT(lonvalue_))         THEN 
    224          CALL cxios_set_domaingroup_lonvalue(domaingroup_hdl%daddr, lonvalue_, size(lonvalue_, 1)) 
    225       END IF 
    226       IF (PRESENT(latvalue_))         THEN 
    227          CALL cxios_set_domaingroup_latvalue(domaingroup_hdl%daddr, latvalue_, size(latvalue_, 1)) 
    228       END IF 
    229  
    230    END SUBROUTINE xios(set_domaingroup_attr_hdl_) 
    231     
    232     
    233    SUBROUTINE xios(set_domain_attr)                                                                & 
    234    ( domain_id, name, standard_name, long_name, domain_group_ref, ni_glo, nj_glo, ibegin, iend,    & 
    235      ni, jbegin, jend, nj, mask, data_dim, data_ni, data_nj, data_ibegin, data_jbegin,             & 
    236      zoom_ni, zoom_nj, zoom_ibegin, zoom_jbegin, data_n_index, data_i_index, data_j_index,         & 
    237      lonvalue, latvalue) 
    238       IMPLICIT NONE 
    239       
    240       TYPE(txios(domain))                                   :: domain_hdl 
    241       CHARACTER(len = *)                       , INTENT(IN) :: domain_id 
    242       CHARACTER(len = *)             , OPTIONAL, INTENT(IN) :: name 
    243       CHARACTER(len = *)             , OPTIONAL, INTENT(IN) :: standard_name 
    244       CHARACTER(len = *)             , OPTIONAL, INTENT(IN) :: long_name 
    245       CHARACTER(len = *)             , OPTIONAL, INTENT(IN) :: domain_group_ref 
    246       INTEGER                        , OPTIONAL, INTENT(IN) :: ni_glo 
    247       INTEGER                        , OPTIONAL, INTENT(IN) :: nj_glo 
    248       INTEGER                        , OPTIONAL, INTENT(IN) :: ibegin 
    249       INTEGER                        , OPTIONAL, INTENT(IN) :: iend 
    250       INTEGER                        , OPTIONAL, INTENT(IN) :: ni 
    251       INTEGER                        , OPTIONAL, INTENT(IN) :: jbegin 
    252       INTEGER                        , OPTIONAL, INTENT(IN) :: jend 
    253       INTEGER                        , OPTIONAL, INTENT(IN) :: nj 
    254       LOGICAL          , dimension(*), OPTIONAL, INTENT(IN) :: mask(:,:) 
    255       INTEGER                        , OPTIONAL, INTENT(IN) :: data_dim 
    256       INTEGER                        , OPTIONAL, INTENT(IN) :: data_ni 
    257       INTEGER                        , OPTIONAL, INTENT(IN) :: data_nj 
    258       INTEGER                        , OPTIONAL, INTENT(IN) :: data_ibegin 
    259       INTEGER                        , OPTIONAL, INTENT(IN) :: data_jbegin 
    260       INTEGER                        , OPTIONAL, INTENT(IN) :: zoom_ni 
    261       INTEGER                        , OPTIONAL, INTENT(IN) :: zoom_nj 
    262       INTEGER                        , OPTIONAL, INTENT(IN) :: zoom_ibegin 
    263       INTEGER                        , OPTIONAL, INTENT(IN) :: zoom_jbegin 
    264       INTEGER                        , OPTIONAL, INTENT(IN) :: data_n_index 
    265       INTEGER       , dimension(*)   , OPTIONAL, INTENT(IN) :: data_i_index(:) 
    266       INTEGER       , dimension(*)   , OPTIONAL, INTENT(IN) :: data_j_index(:) 
    267       REAL(kind = 8), dimension(*)   , OPTIONAL, INTENT(IN) :: lonvalue(:) 
    268       REAL(kind = 8), dimension(*)   , OPTIONAL, INTENT(IN) :: latvalue(:) 
    269   
    270       CALL xios(get_domain_handle)(domain_id,domain_hdl) 
    271       CALL xios(set_domain_attr_hdl_)                                                               & 
    272    ( domain_hdl, name, standard_name, long_name, domain_group_ref, ni_glo, nj_glo, ibegin, iend,    & 
    273      ni, jbegin, jend, nj, mask, data_dim, data_ni, data_nj, data_ibegin, data_jbegin,              & 
    274      zoom_ni, zoom_nj, zoom_ibegin, zoom_jbegin, data_n_index, data_i_index, data_j_index,          & 
    275      lonvalue, latvalue) 
    276  
    277    END SUBROUTINE xios(set_domain_attr) 
    278  
    279  
    280    SUBROUTINE xios(set_domain_attr_hdl)                                                            & 
    281    ( domain_hdl,name, standard_name, long_name, domain_group_ref, ni_glo, nj_glo, ibegin, iend,    & 
    282      ni, jbegin, jend, nj, mask, data_dim, data_ni, data_nj, data_ibegin, data_jbegin,             & 
    283      zoom_ni, zoom_nj, zoom_ibegin, zoom_jbegin, data_n_index, data_i_index,                       & 
    284      data_j_index, lonvalue, latvalue) 
    285       IMPLICIT NONE 
    286       
    287       TYPE(txios(domain))                       , INTENT(IN) :: domain_hdl 
    288       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: name 
    289       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: standard_name 
    290       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: long_name 
    291       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: domain_group_ref 
    292       INTEGER                          , OPTIONAL, INTENT(IN) :: ni_glo 
    293       INTEGER                          , OPTIONAL, INTENT(IN) :: nj_glo 
    294       INTEGER                          , OPTIONAL, INTENT(IN) :: ibegin 
    295       INTEGER                          , OPTIONAL, INTENT(IN) :: iend 
    296       INTEGER                          , OPTIONAL, INTENT(IN) :: ni 
    297       INTEGER                          , OPTIONAL, INTENT(IN) :: jbegin 
    298       INTEGER                          , OPTIONAL, INTENT(IN) :: jend 
    299       INTEGER                          , OPTIONAL, INTENT(IN) :: nj 
    300       LOGICAL          , dimension(*)  , OPTIONAL, INTENT(IN) :: mask(:,:) 
    301       INTEGER                          , OPTIONAL, INTENT(IN) :: data_dim 
    302       INTEGER                          , OPTIONAL, INTENT(IN) :: data_ni 
    303       INTEGER                          , OPTIONAL, INTENT(IN) :: data_nj 
    304       INTEGER                          , OPTIONAL, INTENT(IN) :: data_ibegin 
    305       INTEGER                          , OPTIONAL, INTENT(IN) :: data_jbegin 
    306       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_ni 
    307       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_nj 
    308       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_ibegin 
    309       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_jbegin 
    310       INTEGER                          , OPTIONAL, INTENT(IN) :: data_n_index 
    311       INTEGER       , dimension(*)     , OPTIONAL, INTENT(IN) :: data_i_index(:) 
    312       INTEGER       , dimension(*)     , OPTIONAL, INTENT(IN) :: data_j_index(:) 
    313       REAL(kind = 8), dimension(*)     , OPTIONAL, INTENT(IN) :: lonvalue(:) 
    314       REAL(kind = 8), dimension(*)     , OPTIONAL, INTENT(IN) :: latvalue(:) 
    315        
    316       CALL xios(set_domain_attr_hdl_)                                                             & 
    317    ( domain_hdl,name, standard_name, long_name, domain_group_ref, ni_glo, nj_glo, ibegin, iend,   & 
    318      ni, jbegin, jend, nj, mask, data_dim, data_ni, data_nj, data_ibegin, data_jbegin,            & 
    319      zoom_ni, zoom_nj, zoom_ibegin, zoom_jbegin, data_n_index, data_i_index, data_j_index,        & 
    320      lonvalue, latvalue) 
    321       
    322    END SUBROUTINE xios(set_domain_attr_hdl) 
    323         
    324    SUBROUTINE xios(set_domain_attr_hdl_)                                                                 & 
    325    ( domain_hdl,name_, standard_name_, long_name_, domain_group_ref_, ni_glo_, nj_glo_, ibegin_, iend_,  & 
    326      ni_, jbegin_, jend_, nj_, mask_, data_dim_, data_ni_, data_nj_, data_ibegin_, data_jbegin_,         & 
    327      zoom_ni_, zoom_nj_, zoom_ibegin_, zoom_jbegin_, data_n_index_, data_i_index_, data_j_index_,        & 
    328      lonvalue_, latvalue_) 
    329  
    330       IMPLICIT NONE 
    331       TYPE(txios(domain))                       , INTENT(IN) :: domain_hdl 
    332       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: name_ 
    333       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: standard_name_ 
    334       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: long_name_ 
    335       CHARACTER(len = *)               , OPTIONAL, INTENT(IN) :: domain_group_ref_ 
    336       INTEGER                          , OPTIONAL, INTENT(IN) :: ni_glo_ 
    337       INTEGER                          , OPTIONAL, INTENT(IN) :: nj_glo_ 
    338       INTEGER                          , OPTIONAL, INTENT(IN) :: ibegin_ 
    339       INTEGER                          , OPTIONAL, INTENT(IN) :: iend_ 
    340       INTEGER                          , OPTIONAL, INTENT(IN) :: ni_ 
    341       INTEGER                          , OPTIONAL, INTENT(IN) :: jbegin_ 
    342       INTEGER                          , OPTIONAL, INTENT(IN) :: jend_ 
    343       INTEGER                          , OPTIONAL, INTENT(IN) :: nj_ 
    344       LOGICAL          , dimension(*)  , OPTIONAL, INTENT(IN) :: mask_(:,:) 
    345       LOGICAL(kind = 1), dimension(:,:), ALLOCATABLE          :: mask__ 
    346       INTEGER                          , OPTIONAL, INTENT(IN) :: data_dim_ 
    347       INTEGER                          , OPTIONAL, INTENT(IN) :: data_ni_ 
    348       INTEGER                          , OPTIONAL, INTENT(IN) :: data_nj_ 
    349       INTEGER                          , OPTIONAL, INTENT(IN) :: data_ibegin_ 
    350       INTEGER                          , OPTIONAL, INTENT(IN) :: data_jbegin_ 
    351       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_ni_ 
    352       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_nj_ 
    353       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_ibegin_ 
    354       INTEGER                          , OPTIONAL, INTENT(IN) :: zoom_jbegin_ 
    355       INTEGER                          , OPTIONAL, INTENT(IN) :: data_n_index_ 
    356       INTEGER       , dimension(*)     , OPTIONAL, INTENT(IN) :: data_i_index_(:) 
    357       INTEGER       , dimension(*)     , OPTIONAL, INTENT(IN) :: data_j_index_(:) 
    358       REAL(kind = 8), dimension(*)     , OPTIONAL, INTENT(IN) :: lonvalue_(:) 
    359       REAL(kind = 8), dimension(*)     , OPTIONAL, INTENT(IN) :: latvalue_(:) 
    360       IF (PRESENT(name_))             THEN 
    361          CALL cxios_set_domain_name(domain_hdl%daddr, name_, len(name_)) 
    362       END IF 
    363       IF (PRESENT(standard_name_))    THEN 
    364          CALL cxios_set_domain_standard_name(domain_hdl%daddr, standard_name_, len(standard_name_)) 
    365       END IF 
    366       IF (PRESENT(long_name_))        THEN 
    367          CALL cxios_set_domain_long_name(domain_hdl%daddr, long_name_, len(long_name_)) 
    368        END IF 
    369       IF (PRESENT(domain_group_ref_)) THEN 
    370          CALL cxios_set_domain_domain_group_ref(domain_hdl%daddr, domain_group_ref_, len(domain_group_ref_)) 
    371       END IF 
    372       IF (PRESENT(ni_glo_))           THEN 
    373          CALL cxios_set_domain_ni_glo(domain_hdl%daddr, ni_glo_) 
    374       END IF 
    375       IF (PRESENT(nj_glo_))           THEN 
    376          CALL cxios_set_domain_nj_glo(domain_hdl%daddr, nj_glo_) 
    377       END IF 
    378       IF (PRESENT(ibegin_))           THEN 
    379          CALL cxios_set_domain_ibegin(domain_hdl%daddr, ibegin_) 
    380        END IF 
    381       IF (PRESENT(iend_))             THEN 
    382          CALL cxios_set_domain_iend(domain_hdl%daddr, iend_) 
    383       END IF 
    384       IF (PRESENT(ni_))               THEN 
    385          CALL cxios_set_domain_ni(domain_hdl%daddr, ni_) 
    386       END IF 
    387       IF (PRESENT(jbegin_))           THEN 
    388          CALL cxios_set_domain_jbegin(domain_hdl%daddr, jbegin_) 
    389       END IF 
    390       IF (PRESENT(jend_))             THEN 
    391          CALL cxios_set_domain_jend(domain_hdl%daddr, jend_) 
    392       END IF 
    393       IF (PRESENT(nj_))               THEN 
    394          CALL cxios_set_domain_nj(domain_hdl%daddr, nj_) 
    395       END IF 
    396       IF (PRESENT(mask_))             THEN 
    397          ALLOCATE(mask__(size(mask_, 1), size(mask_, 2))) 
    398          mask__(:,:) = mask_(:,:) 
    399          CALL cxios_set_domain_mask(domain_hdl%daddr, mask__, size(mask_, 1), size(mask_, 2))          
    400          DEALLOCATE(mask__) 
    401       END IF 
    402       IF (PRESENT(data_dim_))         THEN 
    403          CALL cxios_set_domain_data_dim(domain_hdl%daddr, data_dim_) 
    404       END IF 
    405       IF (PRESENT(data_ni_))          THEN 
    406          CALL cxios_set_domain_data_ni(domain_hdl%daddr, data_ni_) 
    407       END IF  
    408       IF (PRESENT(data_nj_))          THEN 
    409          CALL cxios_set_domain_data_nj(domain_hdl%daddr, data_nj_) 
    410       END IF 
    411       IF (PRESENT(data_ibegin_))      THEN 
    412          CALL cxios_set_domain_data_ibegin(domain_hdl%daddr, data_ibegin_) 
    413       END IF 
    414       IF (PRESENT(data_jbegin_))      THEN 
    415          CALL cxios_set_domain_data_jbegin(domain_hdl%daddr, data_jbegin_) 
    416       END IF 
    417       IF (PRESENT(zoom_ni_))          THEN 
    418          CALL cxios_set_domain_zoom_ni(domain_hdl%daddr, zoom_ni_) 
    419       END IF 
    420       IF (PRESENT(zoom_nj_))          THEN 
    421        CALL cxios_set_domain_zoom_nj(domain_hdl%daddr, zoom_nj_) 
    422       END IF 
    423       IF (PRESENT(zoom_ibegin_))      THEN 
    424          CALL cxios_set_domain_zoom_ibegin(domain_hdl%daddr, zoom_ibegin_) 
    425       END IF 
    426       IF (PRESENT(zoom_jbegin_))      THEN 
    427          CALL cxios_set_domain_zoom_jbegin(domain_hdl%daddr, zoom_jbegin_) 
    428       END IF 
    429       IF (PRESENT(data_n_index_))     THEN 
    430          CALL cxios_set_domain_data_n_index(domain_hdl%daddr, data_n_index_) 
    431       END IF 
    432       IF (PRESENT(data_i_index_))     THEN 
    433          CALL cxios_set_domain_data_i_index(domain_hdl%daddr, data_i_index_, size(data_i_index_, 1)) 
    434       END IF 
    435       IF (PRESENT(data_j_index_))     THEN 
    436          CALL cxios_set_domain_data_j_index(domain_hdl%daddr, data_j_index_, size(data_j_index_, 1)) 
    437       END IF 
    438       IF (PRESENT(lonvalue_))         THEN 
    439          CALL cxios_set_domain_lonvalue(domain_hdl%daddr, lonvalue_, size(lonvalue_, 1)) 
    440       END IF 
    441       IF (PRESENT(latvalue_))         THEN 
    442          CALL cxios_set_domain_latvalue(domain_hdl%daddr, latvalue_, size(latvalue_, 1)) 
    443       END IF 
    444  
    445    END SUBROUTINE xios(set_domain_attr_hdl_) 
    446  
    447  
    448     
    44921   SUBROUTINE xios(get_domain_handle)(idt,ret) 
    45022      IMPLICIT NONE 
  • XIOS/trunk/src/fortran/ifield.F90

    r312 r313  
    55   USE FIELD_INTERFACE 
    66   USE FIELDGROUP_INTERFACE 
     7!   USE IFIELD_ATTR 
     8!   USE IFIELDGROUP_ATTR 
    79    
    810   TYPE txios(field) 
     
    1517    
    1618   CONTAINS ! Fonctions disponibles pour les utilisateurs. 
    17  
    18  
    19    SUBROUTINE xios(set_fieldgroup_attr)                                             & 
    20    (fieldgroup_id, name, standard_name, long_name, unit, operation, freq_op, level, & 
    21     prec, enabled, domain_ref, axis_ref, grid_ref, field_ref, default_value) 
    22      
    23       IMPLICIT NONE 
    24       TYPE(txios(fieldgroup))                      :: fieldgroup_hdl 
    25       CHARACTER(len = *)               , INTENT(IN) :: fieldgroup_id 
    26       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name 
    27       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: standard_name 
    28       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: long_name 
    29       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: unit 
    30       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: operation 
    31       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: freq_op 
    32       INTEGER                , OPTIONAL, INTENT(IN) :: level 
    33       INTEGER                , OPTIONAL, INTENT(IN) :: prec 
    34       LOGICAL                , OPTIONAL, INTENT(IN) :: enabled 
    35       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref 
    36       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref 
    37       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: grid_ref 
    38       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: field_ref 
    39       REAL(kind=8)           , OPTIONAL, INTENT(IN) :: default_value 
    40          
    41       CALL xios(get_fieldgroup_handle)(fieldgroup_id,fieldgroup_hdl) 
    42       CALL xios(set_fieldgroup_attr_hdl_)                                                  & 
    43          (fieldgroup_hdl, name, standard_name, long_name, unit, operation, freq_op, level, & 
    44           prec, enabled, domain_ref, axis_ref, grid_ref, field_ref, default_value) 
    45  
    46    END SUBROUTINE xios(set_fieldgroup_attr) 
    47  
    48    SUBROUTINE xios(set_fieldgroup_attr_hdl)                                           & 
    49    (fieldgroup_hdl, name, standard_name, long_name, unit, operation, freq_op, level , & 
    50     prec, enabled, domain_ref, axis_ref, grid_ref, field_ref, default_value) 
    51       IMPLICIT NONE 
    52       TYPE(txios(fieldgroup))         , INTENT(IN) :: fieldgroup_hdl 
    53       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name 
    54       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: standard_name 
    55       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: long_name 
    56       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: unit 
    57       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: operation 
    58       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: freq_op 
    59       INTEGER                , OPTIONAL, INTENT(IN) :: level 
    60       INTEGER                , OPTIONAL, INTENT(IN) :: prec 
    61       LOGICAL                , OPTIONAL, INTENT(IN) :: enabled 
    62       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref 
    63       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref 
    64       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: grid_ref 
    65       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: field_ref 
    66       REAL(kind=8)           , OPTIONAL, INTENT(IN) :: default_value 
    67        
    68       CALL  xios(set_fieldgroup_attr_hdl_)                                            & 
    69    (fieldgroup_hdl, name, standard_name, long_name, unit, operation, freq_op, level , & 
    70     prec, enabled, domain_ref, axis_ref, grid_ref, field_ref, default_value)  
    71         
    72    END SUBROUTINE xios(set_fieldgroup_attr_hdl) 
    73  
    74  
    75    SUBROUTINE xios(set_fieldgroup_attr_hdl_)                                                & 
    76    (fieldgroup_hdl, name_, standard_name_, long_name_, unit_, operation_, freq_op_, level_, & 
    77     prec_, enabled_, domain_ref_, axis_ref_, grid_ref_, field_ref_, default_value_) 
    78       IMPLICIT NONE 
    79       TYPE(txios(fieldgroup))         , INTENT(IN) :: fieldgroup_hdl 
    80       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name_ 
    81       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: standard_name_ 
    82       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: long_name_ 
    83       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: unit_ 
    84       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: operation_ 
    85       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: freq_op_ 
    86       INTEGER                , OPTIONAL, INTENT(IN) :: level_ 
    87       INTEGER                , OPTIONAL, INTENT(IN) :: prec_ 
    88       LOGICAL(kind = 1)                             :: enabled__ 
    89       LOGICAL                , OPTIONAL, INTENT(IN) :: enabled_ 
    90       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref_ 
    91       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref_ 
    92       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: grid_ref_ 
    93       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: field_ref_ 
    94       REAL(kind=8)           , OPTIONAL, INTENT(IN) :: default_value_ 
    95        
    96       IF (PRESENT(name_))           THEN 
    97          CALL cxios_set_fieldgroup_name(fieldgroup_hdl%daddr, name_, len(name_)) 
    98       END IF 
    99       IF (PRESENT(standard_name_))  THEN 
    100          CALL cxios_set_fieldgroup_standard_name(fieldgroup_hdl%daddr, standard_name_, len(standard_name_)) 
    101       END IF 
    102       IF (PRESENT(long_name_))      THEN 
    103          CALL cxios_set_fieldgroup_long_name(fieldgroup_hdl%daddr, long_name_, len(long_name_)) 
    104       END IF 
    105       IF (PRESENT(unit_))           THEN 
    106          CALL cxios_set_fieldgroup_unit(fieldgroup_hdl%daddr, unit_, len(unit_)) 
    107       END IF 
    108       IF (PRESENT(operation_))      THEN 
    109          CALL cxios_set_fieldgroup_operation(fieldgroup_hdl%daddr, operation_, len(operation_)) 
    110       END IF 
    111       IF (PRESENT(freq_op_))        THEN 
    112          CALL cxios_set_fieldgroup_freq_op(fieldgroup_hdl%daddr, freq_op_, len(freq_op_)) 
    113       END IF 
    114       IF (PRESENT(level_))          THEN 
    115          CALL cxios_set_fieldgroup_level(fieldgroup_hdl%daddr, level_) 
    116       END IF 
    117       IF (PRESENT(prec_))           THEN 
    118          CALL cxios_set_fieldgroup_prec(fieldgroup_hdl%daddr, prec_) 
    119       END IF 
    120       IF (PRESENT(enabled_))        THEN 
    121          enabled__ = enabled_   
    122          CALL cxios_set_fieldgroup_enabled(fieldgroup_hdl%daddr, enabled__) 
    123       END IF 
    124       IF (PRESENT(domain_ref_))     THEN 
    125          CALL cxios_set_fieldgroup_domain_ref(fieldgroup_hdl%daddr, domain_ref_, len(domain_ref_)) 
    126       END IF 
    127       IF (PRESENT(axis_ref_))       THEN 
    128          CALL cxios_set_fieldgroup_axis_ref(fieldgroup_hdl%daddr, axis_ref_, len(axis_ref_)) 
    129       END IF 
    130       IF (PRESENT(grid_ref_))       THEN 
    131          CALL cxios_set_fieldgroup_grid_ref(fieldgroup_hdl%daddr, grid_ref_, len(grid_ref_)) 
    132       END IF 
    133       IF (PRESENT(field_ref_))      THEN 
    134          CALL cxios_set_fieldgroup_field_ref(fieldgroup_hdl%daddr, field_ref_, len(field_ref_)) 
    135       END IF 
    136       IF (PRESENT(default_value_))  THEN 
    137          CALL cxios_set_fieldgroup_default_value(fieldgroup_hdl%daddr, default_value_) 
    138       END IF 
    139  
    140    END SUBROUTINE xios(set_fieldgroup_attr_hdl_) 
    141  
    142     
    143    SUBROUTINE xios(set_field_attr)                                             & 
    144    (field_id, name, standard_name, long_name, unit, operation, freq_op, level, & 
    145     prec, enabled, domain_ref, axis_ref, grid_ref, field_ref, default_value) 
    146      
    147       IMPLICIT NONE 
    148       TYPE(txios(field))                            :: field_hdl 
    149       CHARACTER(len = *)               , INTENT(IN) :: field_id 
    150       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name 
    151       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: standard_name 
    152       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: long_name 
    153       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: unit 
    154       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: operation 
    155       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: freq_op 
    156       INTEGER                , OPTIONAL, INTENT(IN) :: level 
    157       INTEGER                , OPTIONAL, INTENT(IN) :: prec 
    158       LOGICAL                , OPTIONAL, INTENT(IN) :: enabled 
    159       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref 
    160       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref 
    161       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: grid_ref 
    162       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: field_ref 
    163       REAL(kind=8)           , OPTIONAL, INTENT(IN) :: default_value 
    164        
    165       CALL xios(get_field_handle)(field_id,field_hdl) 
    166       CALL xios(set_field_attr_hdl_)                                                          & 
    167          (field_hdl, name, standard_name, long_name, unit, operation, freq_op, level,  & 
    168           prec, enabled, domain_ref, axis_ref, grid_ref, field_ref, default_value) 
    169    END SUBROUTINE xios(set_field_attr) 
    170  
    171  
    172    SUBROUTINE xios(set_field_attr_hdl)                                          & 
    173    (field_hdl, name, standard_name, long_name, unit, operation, freq_op, level, & 
    174     prec, enabled, domain_ref, axis_ref, grid_ref, field_ref, default_value) 
    175       IMPLICIT NONE 
    176       TYPE(txios(field))               , INTENT(IN):: field_hdl 
    177       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name 
    178       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: standard_name 
    179       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: long_name 
    180       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: unit 
    181       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: operation 
    182       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: freq_op 
    183       INTEGER                , OPTIONAL, INTENT(IN) :: level 
    184       INTEGER                , OPTIONAL, INTENT(IN) :: prec 
    185       LOGICAL                , OPTIONAL, INTENT(IN) :: enabled 
    186       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref 
    187       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref 
    188       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: grid_ref 
    189       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: field_ref 
    190       REAL(kind=8)           , OPTIONAL, INTENT(IN) :: default_value 
    191  
    192       CALL xios(set_field_attr_hdl_)                                            & 
    193    (field_hdl, name, standard_name, long_name, unit, operation, freq_op, level, & 
    194     prec, enabled, domain_ref, axis_ref, grid_ref, field_ref, default_value)   
    195          
    196    END SUBROUTINE xios(set_field_attr_hdl) 
    197  
    198    SUBROUTINE xios(set_field_attr_hdl_)                                                & 
    199    (field_hdl, name_, standard_name_, long_name_, unit_, operation_, freq_op_, level_, & 
    200     prec_, enabled_, domain_ref_, axis_ref_, grid_ref_, field_ref_, default_value_) 
    201       IMPLICIT NONE 
    202       TYPE(txios(field))               , INTENT(IN):: field_hdl 
    203       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name_ 
    204       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: standard_name_ 
    205       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: long_name_ 
    206       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: unit_ 
    207       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: operation_ 
    208       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: freq_op_ 
    209       INTEGER                , OPTIONAL, INTENT(IN) :: level_ 
    210       INTEGER                , OPTIONAL, INTENT(IN) :: prec_ 
    211       LOGICAL(kind = 1)                             :: enabled__ 
    212       LOGICAL                , OPTIONAL, INTENT(IN) :: enabled_ 
    213       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref_ 
    214       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref_ 
    215       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: grid_ref_ 
    216       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: field_ref_ 
    217       REAL(kind=8)           , OPTIONAL, INTENT(IN) :: default_value_ 
    218        
    219       IF (PRESENT(name_))           THEN 
    220          CALL cxios_set_field_name(field_hdl%daddr, name_, len(name_)) 
    221       END IF 
    222       IF (PRESENT(standard_name_))  THEN 
    223          CALL cxios_set_field_standard_name(field_hdl%daddr, standard_name_, len(standard_name_)) 
    224       END IF 
    225       IF (PRESENT(long_name_))      THEN 
    226          CALL cxios_set_field_long_name(field_hdl%daddr, long_name_, len(long_name_)) 
    227       END IF 
    228       IF (PRESENT(unit_))           THEN 
    229          CALL cxios_set_field_unit(field_hdl%daddr, unit_, len(unit_)) 
    230       END IF 
    231       IF (PRESENT(operation_))      THEN 
    232          CALL cxios_set_field_operation(field_hdl%daddr, operation_, len(operation_)) 
    233       END IF 
    234       IF (PRESENT(freq_op_))        THEN 
    235          CALL cxios_set_field_freq_op(field_hdl%daddr, freq_op_, len(freq_op_)) 
    236       END IF 
    237       IF (PRESENT(level_))          THEN 
    238          CALL cxios_set_field_level(field_hdl%daddr, level_) 
    239       END IF 
    240       IF (PRESENT(prec_))           THEN 
    241          CALL cxios_set_field_prec(field_hdl%daddr, prec_) 
    242       END IF 
    243       IF (PRESENT(enabled_))        THEN 
    244          enabled__ = enabled_   
    245          CALL cxios_set_field_enabled(field_hdl%daddr, enabled__) 
    246       END IF 
    247       IF (PRESENT(domain_ref_))     THEN 
    248          CALL cxios_set_field_domain_ref(field_hdl%daddr, domain_ref_, len(domain_ref_)) 
    249       END IF 
    250       IF (PRESENT(axis_ref_))       THEN 
    251          CALL cxios_set_field_axis_ref(field_hdl%daddr, axis_ref_, len(axis_ref_)) 
    252       END IF 
    253       IF (PRESENT(grid_ref_))       THEN 
    254          CALL cxios_set_field_grid_ref(field_hdl%daddr, grid_ref_, len(grid_ref_)) 
    255       END IF 
    256       IF (PRESENT(field_ref_))      THEN 
    257          CALL cxios_set_field_field_ref(field_hdl%daddr, field_ref_, len(field_ref_)) 
    258       END IF 
    259       IF (PRESENT(default_value_))  THEN 
    260          CALL cxios_set_field_default_value(field_hdl%daddr, default_value_) 
    261       END IF 
    262  
    263    END SUBROUTINE xios(set_field_attr_hdl_) 
    264     
    26519 
    26620   SUBROUTINE xios(get_field_handle)(idt, ret) 
  • XIOS/trunk/src/fortran/ifile.F90

    r312 r313  
    55   USE FILE_INTERFACE 
    66   USE FILEGROUP_INTERFACE 
     7!   USE IFILE_ATTR 
     8!   USE IFILEGROUP_ATTR 
    79    
    810   TYPE txios(file) 
     
    1517    
    1618   CONTAINS ! Fonctions disponibles pour les utilisateurs. 
    17  
    18  
    19    SUBROUTINE xios(set_file_attr)(file_id, name , description, name_suffix, output_freq, output_level, enabled, type) 
    20       IMPLICIT NONE 
    21       TYPE(txios(file))                       :: file_hdl 
    22       CHARACTER(len = *)          , INTENT(IN) :: file_id 
    23       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name 
    24       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: description 
    25       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_suffix 
    26       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: output_freq 
    27       INTEGER           , OPTIONAL, INTENT(IN) :: output_level 
    28       LOGICAL           , OPTIONAL, INTENT(IN) :: enabled 
    29       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: type 
    30              
    31       CALL xios(get_file_handle)(file_id,file_hdl) 
    32       CALL xios(set_file_attr_hdl_)(file_hdl, name , description, name_suffix, output_freq, output_level, enabled, type) 
    33        
    34    END SUBROUTINE xios(set_file_attr) 
    35     
    36  
    37    SUBROUTINE xios(set_file_attr_hdl)(file_hdl, name , description, name_suffix, output_freq, output_level, enabled,type) 
    38       TYPE(txios(file))          , INTENT(IN) :: file_hdl 
    39       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name 
    40       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: description 
    41       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_suffix 
    42       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: output_freq 
    43       INTEGER           , OPTIONAL, INTENT(IN) :: output_level 
    44       LOGICAL           , OPTIONAL, INTENT(IN) :: enabled 
    45       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: type 
    46  
    47       CALL xios(set_file_attr_hdl_)(file_hdl, name , description, name_suffix, output_freq, output_level, enabled, type) 
    48        
    49    END SUBROUTINE xios(set_file_attr_hdl) 
    50  
    51    SUBROUTINE xios(set_file_attr_hdl_)(file_hdl, name_ , description_, name_suffix_, output_freq_, output_level_, enabled_, type_) 
    52       TYPE(txios(file))          , INTENT(IN) :: file_hdl 
    53       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_ 
    54       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: description_ 
    55       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_suffix_ 
    56       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: output_freq_ 
    57       INTEGER           , OPTIONAL, INTENT(IN) :: output_level_ 
    58       LOGICAL(kind = 1)                        :: enabled__ 
    59       LOGICAL           , OPTIONAL, INTENT(IN) :: enabled_ 
    60       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: type_ 
    61              
    62       IF (PRESENT(name_))         THEN 
    63          CALL cxios_set_file_name(file_hdl%daddr, name_, len(name_)) 
    64       END IF 
    65       IF (PRESENT(description_))  THEN 
    66          CALL cxios_set_file_description(file_hdl%daddr, description_, len(description_)) 
    67       END IF 
    68       IF (PRESENT(name_suffix_))  THEN 
    69          CALL cxios_set_file_name_suffix(file_hdl%daddr, name_suffix_, len(name_suffix_)) 
    70       END IF 
    71       IF (PRESENT(output_freq_))  THEN 
    72          CALL cxios_set_file_output_freq(file_hdl%daddr, output_freq_, len(output_freq_)) 
    73       END IF 
    74       IF (PRESENT(output_level_)) THEN 
    75          CALL cxios_set_file_output_level(file_hdl%daddr, output_level_) 
    76       END IF 
    77       IF (PRESENT(enabled_))      THEN 
    78          enabled__ = enabled_         
    79          CALL cxios_set_file_enabled(file_hdl%daddr, enabled__) 
    80       END IF 
    81        
    82       IF (PRESENT(type_))         THEN 
    83          CALL cxios_set_file_type(file_hdl%daddr, type_, len(type_)) 
    84       END IF 
    85        
    86    END SUBROUTINE xios(set_file_attr_hdl_) 
    87  
    88  
    89     
    90    SUBROUTINE xios(set_filegroup_attr)(filegroup_id, name , description, name_suffix, output_freq, output_level, enabled, type) 
    91       IMPLICIT NONE 
    92       TYPE(txios(filegroup))                  :: filegroup_hdl 
    93       CHARACTER(len = *)          , INTENT(IN) :: filegroup_id 
    94       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name 
    95       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: description 
    96       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_suffix 
    97       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: output_freq 
    98       INTEGER           , OPTIONAL, INTENT(IN) :: output_level 
    99       LOGICAL           , OPTIONAL, INTENT(IN) :: enabled 
    100       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: type 
    101        
    102       CALL xios(get_filegroup_handle)(filegroup_id,filegroup_hdl) 
    103       CALL xios(set_filegroup_attr_hdl_)(filegroup_hdl, name , description, name_suffix, output_freq, output_level, enabled, type) 
    104        
    105    END SUBROUTINE xios(set_filegroup_attr) 
    106  
    107  
    108    SUBROUTINE xios(set_filegroup_attr_hdl)(filegroup_hdl, name , description, name_suffix, output_freq, output_level, enabled, type) 
    109       IMPLICIT NONE 
    110       TYPE(txios(filegroup))     , INTENT(IN) :: filegroup_hdl 
    111       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name 
    112       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: description 
    113       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_suffix 
    114       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: output_freq 
    115       INTEGER           , OPTIONAL, INTENT(IN) :: output_level 
    116       LOGICAL           , OPTIONAL, INTENT(IN) :: enabled 
    117       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: type 
    118        
    119      CALL xios(set_filegroup_attr_hdl_)(filegroup_hdl, name , description, name_suffix, output_freq, output_level, enabled, type) 
    120  
    121    END SUBROUTINE xios(set_filegroup_attr_hdl) 
    122        
    123     
    124    SUBROUTINE xios(set_filegroup_attr_hdl_)(filegroup_hdl, name_ , description_, name_suffix_, output_freq_, output_level_,     & 
    125                    enabled_,type_) 
    126       IMPLICIT NONE 
    127       TYPE(txios(filegroup))     , INTENT(IN) :: filegroup_hdl 
    128       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_ 
    129       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: description_ 
    130       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: name_suffix_ 
    131       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: output_freq_ 
    132       INTEGER           , OPTIONAL, INTENT(IN) :: output_level_ 
    133       LOGICAL(kind = 1)                        :: enabled__ 
    134       LOGICAL           , OPTIONAL, INTENT(IN) :: enabled_ 
    135       CHARACTER(len = *), OPTIONAL, INTENT(IN) :: type_ 
    136        
    137       IF (PRESENT(name_))         THEN 
    138          CALL cxios_set_filegroup_name(filegroup_hdl%daddr, name_, len(name_)) 
    139       END IF 
    140       IF (PRESENT(description_))  THEN 
    141          CALL cxios_set_filegroup_description(filegroup_hdl%daddr, description_, len(description_)) 
    142       END IF 
    143       IF (PRESENT(name_suffix_))  THEN 
    144          CALL cxios_set_filegroup_name_suffix(filegroup_hdl%daddr, name_suffix_, len(name_suffix_)) 
    145       END IF 
    146       IF (PRESENT(output_freq_))  THEN 
    147          CALL cxios_set_filegroup_output_freq(filegroup_hdl%daddr, output_freq_, len(output_freq_)) 
    148       END IF 
    149       IF (PRESENT(output_level_)) THEN 
    150          CALL cxios_set_filegroup_output_level(filegroup_hdl%daddr, output_level_) 
    151       END IF 
    152       IF (PRESENT(enabled_))      THEN 
    153         enabled__ = enabled_  
    154         CALL cxios_set_filegroup_enabled(filegroup_hdl%daddr, enabled__) 
    155       END IF 
    156        
    157       IF (PRESENT(type_))         THEN 
    158          CALL cxios_set_filegroup_type(filegroup_hdl%daddr, type_, len(type_)) 
    159       END IF 
    160  
    161    END SUBROUTINE xios(set_filegroup_attr_hdl_) 
    162  
    16319 
    16420   SUBROUTINE xios(get_file_handle)( idt, ret) 
  • XIOS/trunk/src/fortran/igrid.F90

    r312 r313  
    55   USE GRID_INTERFACE 
    66   USE GRIDGROUP_INTERFACE 
    7  
     7!   USE IGRID_ATTR 
     8!   USE IGRIDGROUP_ATTR 
     9    
    810   TYPE txios(grid) 
    911      INTEGER(kind = C_INTPTR_T) :: daddr 
     
    1618    
    1719   CONTAINS ! Fonctions disponibles pour les utilisateurs. 
    18  
    19  
    20  
    21    SUBROUTINE xios(set_grid_attr)(grid_id, name, description, domain_ref, axis_ref) 
    22       IMPLICIT NONE 
    23       TYPE(txios(grid))                             :: grid_hdl 
    24       CHARACTER(len = *)               , INTENT(IN) :: grid_id 
    25       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name 
    26       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: description 
    27       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref 
    28       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref 
    29        
    30       CALL xios(get_grid_handle)(grid_id,grid_hdl) 
    31       CALL xios(set_grid_attr_hdl_)(grid_hdl, name, description, domain_ref, axis_ref) 
    32  
    33    END SUBROUTINE xios(set_grid_attr) 
    34     
    35    SUBROUTINE xios(set_grid_attr_hdl)(grid_hdl, name, description, domain_ref, axis_ref) 
    36       IMPLICIT NONE 
    37       TYPE      (txios(grid))                      :: grid_hdl 
    38       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name 
    39       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: description 
    40       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref 
    41       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref 
    42        
    43       CALL xios(set_grid_attr_hdl_)(grid_hdl, name, description, domain_ref, axis_ref) 
    44  
    45    END SUBROUTINE xios(set_grid_attr_hdl)    
    46  
    47  
    48    SUBROUTINE xios(set_grid_attr_hdl_)(grid_hdl, name_, description_, domain_ref_, axis_ref_) 
    49       IMPLICIT NONE 
    50       TYPE      (txios(grid))                      :: grid_hdl 
    51       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name_ 
    52       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: description_ 
    53       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref_ 
    54       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref_ 
    55        
    56       IF (PRESENT(name_))        THEN 
    57        CALL cxios_set_grid_name(grid_hdl%daddr, name_, len(name_)) 
    58       END IF 
    59       IF (PRESENT(description_)) THEN 
    60        CALL cxios_set_grid_description(grid_hdl%daddr, description_, len(description_)) 
    61       END IF 
    62       IF (PRESENT(domain_ref_))  THEN 
    63        CALL cxios_set_grid_domain_ref(grid_hdl%daddr, domain_ref_, len(domain_ref_)) 
    64       END IF 
    65       IF (PRESENT(axis_ref_))    THEN 
    66        CALL cxios_set_grid_axis_ref(grid_hdl%daddr, axis_ref_, len(axis_ref_)) 
    67       END IF 
    68    END SUBROUTINE xios(set_grid_attr_hdl_) 
    69  
    70  
    71     
    72    SUBROUTINE xios(set_gridgroup_attr)(gridgroup_id, name, description, domain_ref, axis_ref) 
    73       IMPLICIT NONE 
    74       TYPE(txios(gridgroup))                       :: gridgroup_hdl 
    75       CHARACTER(len = *)               , INTENT(IN) :: gridgroup_id 
    76       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name 
    77       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: description 
    78       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref 
    79       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref 
    80        
    81       CALL xios(get_gridgroup_handle)(gridgroup_id, gridgroup_hdl) 
    82       CALL xios(set_gridgroup_attr_hdl_)(gridgroup_hdl, name, description, domain_ref, axis_ref) 
    83  
    84    END SUBROUTINE xios(set_gridgroup_attr) 
    85     
    86    SUBROUTINE xios(set_gridgroup_attr_hdl)(gridgroup_hdl, name, description, domain_ref, axis_ref) 
    87       IMPLICIT NONE 
    88       TYPE      (txios(gridgroup))                 :: gridgroup_hdl 
    89       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name 
    90       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: description 
    91       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref 
    92       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref 
    93  
    94       CALL xios(set_gridgroup_attr_hdl_)(gridgroup_hdl, name, description, domain_ref, axis_ref) 
    95  
    96    END SUBROUTINE xios(set_gridgroup_attr_hdl) 
    97     
    98    SUBROUTINE xios(set_gridgroup_attr_hdl_)(gridgroup_hdl, name_, description_, domain_ref_, axis_ref_) 
    99       IMPLICIT NONE 
    100       TYPE      (txios(gridgroup))                 :: gridgroup_hdl 
    101       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: name_ 
    102       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: description_ 
    103       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: domain_ref_ 
    104       CHARACTER(len = *)     , OPTIONAL, INTENT(IN) :: axis_ref_ 
    105        
    106       IF (PRESENT(name_))        THEN 
    107        CALL cxios_set_gridgroup_name(gridgroup_hdl%daddr, name_, len(name_)) 
    108       END IF 
    109       IF (PRESENT(description_)) THEN 
    110        CALL cxios_set_gridgroup_description(gridgroup_hdl%daddr, description_, len(description_)) 
    111       END IF 
    112       IF (PRESENT(domain_ref_))  THEN 
    113        CALL cxios_set_gridgroup_domain_ref(gridgroup_hdl%daddr, domain_ref_, len(domain_ref_)) 
    114       END IF 
    115       IF (PRESENT(axis_ref_))    THEN 
    116        CALL cxios_set_gridgroup_axis_ref(gridgroup_hdl%daddr, axis_ref_, len(axis_ref_)) 
    117       END IF 
    118    END SUBROUTINE xios(set_gridgroup_attr_hdl_) 
    119     
    120     
    12120 
    12221   SUBROUTINE xios(get_grid_handle)(idt,ret) 
  • XIOS/trunk/src/fortran/ixios.F90

    r310 r313  
    44 
    55 
    6 USE icontext, ONLY : txios(context), xios(set_context_attr), xios(set_context_attr_hdl),   & 
    7                      xios(get_context_handle), xios(set_current_context),                  & 
     6USE icontext, ONLY : txios(context), xios(get_context_handle), xios(set_current_context),    & 
    87                     xios(is_valid_context) 
    98 
     9USE icontext_attr, ONLY : xios(set_context_attr), xios(set_context_attr_hdl), & 
     10                          xios(get_context_attr), xios(get_context_attr_hdl) 
     11                                                
    1012USE idata, ONLY : xios(initialize),xios(init_server), xios(finalize), xios(context_initialize),  & 
    1113                  xios(close_context_definition),       & 
     
    1618USE idate, ONLY : txios(date),txios(time), xios(set_timestep),xios(update_calendar) 
    1719 
    18 USE idomain, ONLY : txios(domain), txios(domaingroup), xios(set_domaingroup_attr),       & 
    19                     xios(set_domaingroup_attr_hdl), xios(set_domain_attr), xios(set_domain_attr_hdl),& 
    20                     xios(get_domain_handle), xios(get_domaingroup_handle),xios(is_valid_domain),     & 
     20USE idomain, ONLY : txios(domain), txios(domaingroup), xios(get_domain_handle),  & 
     21                    xios(get_domaingroup_handle),xios(is_valid_domain),     & 
    2122                    xios(is_valid_domaingroup) 
    22                       
    23 USE ifield, ONLY : txios(field), txios(fieldgroup), xios(set_fieldgroup_attr),           & 
    24                    xios(set_fieldgroup_attr_hdl),xios(set_field_attr),xios(set_field_attr_hdl),      & 
    25                    xios(get_field_handle), xios(get_fieldgroup_handle), xios(is_valid_field),        & 
     23 
     24USE idomain_attr, ONLY :  xios(set_domain_attr), xios(set_domain_attr_hdl),  & 
     25                          xios(get_domain_attr), xios(get_domain_attr_hdl) 
     26 
     27USE idomaingroup_attr, ONLY : xios(set_domaingroup_attr), xios(set_domaingroup_attr_hdl),  &  
     28                              xios(get_domaingroup_attr), xios(get_domaingroup_attr_hdl)  
     29                     
     30USE ifield, ONLY : txios(field), txios(fieldgroup), xios(get_field_handle),  & 
     31                   xios(get_fieldgroup_handle), xios(is_valid_field),        & 
    2632                   xios(is_valid_fieldgroup),xios(field_is_active_id),xios(field_is_active_hdl)   
    27                     
    28 USE ifile, ONLY : txios(file), txios(filegroup), xios(set_file_attr),xios(set_file_attr_hdl), & 
    29                   xios(set_filegroup_attr), xios(set_filegroup_attr_hdl), xios(get_file_handle),    &  
     33 
     34USE ifield_attr, ONLY : xios(set_field_attr),xios(set_field_attr_hdl),    & 
     35                        xios(get_field_attr),xios(get_field_attr_hdl) 
     36   
     37USE ifieldgroup_attr, ONLY : xios(set_fieldgroup_attr), xios(set_fieldgroup_attr_hdl),  & 
     38                             xios(get_fieldgroup_attr), xios(get_fieldgroup_attr_hdl) 
     39 
     40USE ifile, ONLY : txios(file), txios(filegroup), xios(get_file_handle),    &  
    3041                  xios(get_filegroup_handle), xios(is_valid_file), xios(is_valid_filegroup) 
     42 
     43USE ifile_attr, ONLY : xios(set_file_attr),xios(set_file_attr_hdl), & 
     44                       xios(get_file_attr),xios(get_file_attr_hdl) 
     45 
     46USE ifilegroup_attr, ONLY : xios(set_filegroup_attr), xios(set_filegroup_attr_hdl), & 
     47                            xios(get_filegroup_attr), xios(get_filegroup_attr_hdl) 
    3148                   
    32 USE igrid, ONLY : txios(grid), txios(gridgroup), xios(set_grid_attr), xios(set_grid_attr_hdl), & 
    33                   xios(set_gridgroup_attr), xios(set_gridgroup_attr_hdl), xios(get_grid_handle),     & 
     49USE igrid, ONLY : txios(grid), txios(gridgroup), xios(get_grid_handle),     & 
    3450                  xios(get_gridgroup_handle), xios(is_valid_grid), xios(is_valid_gridgroup)  
    3551 
    36 USE iaxis, ONLY : txios(axis), txios(axisgroup), xios(set_axis_attr), xios(set_axis_attr_hdl), & 
    37                   xios(set_axisgroup_attr), xios(set_axisgroup_attr_hdl), xios(get_axis_handle),     & 
     52USE igrid_attr, ONLY : xios(set_grid_attr_hdl), xios(set_grid_attr), & 
     53                       xios(get_grid_attr_hdl), xios(get_grid_attr) 
     54 
     55USE igridgroup_attr, ONLY : xios(set_gridgroup_attr), xios(set_gridgroup_attr_hdl),  & 
     56                            xios(get_gridgroup_attr), xios(get_gridgroup_attr_hdl) 
     57 
     58USE iaxis, ONLY : txios(axis), txios(axisgroup), xios(get_axis_handle),     & 
    3859                  xios(get_axisgroup_handle), xios(is_valid_axis), xios(is_valid_axisgroup)  
     60 
     61USE iaxis_attr, ONLY :  xios(set_axis_attr), xios(set_axis_attr_hdl), & 
     62                        xios(get_axis_attr), xios(get_axis_attr_hdl) 
     63 
     64USE iaxisgroup_attr, ONLY : xios(set_axisgroup_attr), xios(set_axisgroup_attr_hdl), & 
     65                            xios(get_axisgroup_attr), xios(get_axisgroup_attr_hdl) 
    3966 
    4067USE ixml_tree, ONLY : xios(add_axis), xios(add_file), xios(add_grid), xios(add_field), xios(add_domain),          & 
     
    5279                   xios(set_axisgroup_attr_hdl), xios(set_context_attr_hdl) 
    5380END INTERFACE xios(set_attr) 
     81 
     82INTERFACE xios(get_attr) 
     83  MODULE PROCEDURE xios(get_domaingroup_attr_hdl), xios(get_domain_attr_hdl), xios(get_fieldgroup_attr_hdl), & 
     84                   xios(get_field_attr_hdl), xios(get_file_attr_hdl), xios(get_filegroup_attr_hdl),          & 
     85                   xios(get_grid_attr_hdl), xios(get_gridgroup_attr_hdl), xios(get_axis_attr_hdl) ,          & 
     86                   xios(get_axisgroup_attr_hdl), xios(get_context_attr_hdl) 
     87END INTERFACE xios(get_attr) 
    5488 
    5589INTERFACE xios(get_handle) 
     
    84118          xios(set_axisgroup_attr), xios(set_context_attr) 
    85119 
     120 PUBLIC :: xios(get_attr), xios(get_domain_attr), xios(get_domaingroup_attr), xios(get_fieldgroup_attr), & 
     121          xios(get_field_attr), xios(get_file_attr), xios(get_filegroup_attr),          & 
     122          xios(get_grid_attr), xios(get_gridgroup_attr), xios(get_axis_attr) ,          & 
     123          xios(get_axisgroup_attr), xios(get_context_attr) 
     124 
    86125 PUBLIC :: xios(get_handle)  
    87126 PUBLIC :: xios(add_child)  
  • XIOS/trunk/src/indent.cpp

    r219 r313  
    11#include "indent.hpp" 
     2#include <ostream> 
     3#include <iostream> 
    24 
    3 /// boost headers /// 
    4 #include <boost/algorithm/string.hpp> 
    5 #include <boost/algorithm/string/split.hpp> 
     5using namespace std ; 
    66 
    77namespace xmlioserver 
    88{ 
    9    /// ////////////////////// Définitions ////////////////////// /// 
    10    unsigned int CIndent::Indent   = 0; 
    11    StdString    CIndent::Increm   = StdString("   "); 
    12    bool         CIndent::WithLine = false; 
     9  Cindent iendl ; 
     10  Cindent ireset(0,true) ; 
     11  int Cindent::defaultIncSize=2 ; 
     12  int Cindent::index=ios::xalloc() ; 
     13   
     14  Cindent::Cindent(int i,bool r) : offset(i), reset(r), incSize(defaultIncSize)  
     15  { } 
     16   
     17  Cindent Cindent::operator++() 
     18  { 
     19    return Cindent(incSize) ; 
     20  } 
     21   
     22  Cindent Cindent::operator--() 
     23  { 
     24    return Cindent(-incSize) ; 
     25  } 
    1326 
    14    StdOStream & CIndent::NIndent(StdOStream& out) 
    15    { 
    16       static unsigned int LineNB = 1; 
    17       if (CIndent::WithLine) out << LineNB++ << ". "; 
    18       for(unsigned int i = 0; i < CIndent::Indent; out << CIndent::Increm , i++){} 
    19       return (out); 
    20    } 
     27  Cindent Cindent::operator++(int) 
     28  { 
     29    return Cindent(incSize) ; 
     30  } 
     31   
     32  Cindent Cindent::operator--(int) 
     33  { 
     34    return Cindent(-incSize) ; 
     35  } 
    2136 
    22    StdOStream & CIndent::IncIndent(StdOStream& out) 
    23    { CIndent::Indent++; return (CIndent::NIndent(out)); } 
     37  Cindent Cindent::operator+=(int i) 
     38  { 
     39    return Cindent(incSize*i) ; 
     40  }   
    2441 
    25    StdOStream & CIndent::DecEndl  (StdOStream& out) 
    26    { CIndent::Indent--; return (out); } 
     42  Cindent Cindent::operator-=(int i) 
     43  { 
     44    return Cindent(-incSize*i) ; 
     45  }   
    2746 
    28    ///---------------------------------------- 
    29  
    30    StdString CIndentedXml::Indented(const StdString & content) 
    31    { 
    32       StdOStringStream retvalue; 
    33       std::vector<StdString> str; 
    34       boost::split(str, content, boost::is_any_of("\n")); 
    35        
    36       std::vector<StdString>::iterator it = str.begin(), end = str.end(); 
    37        
    38       for (; it != end; it++) 
    39       { 
    40          StdString & line = *it; 
    41          if (line.find("<? ") != StdString::npos || 
    42              line.find(xml::CXMLNode::GetRootName()) != StdString::npos) 
    43             retvalue << CIndent::NIndent << line <<  std::endl; 
    44          else if (line.find("</") != StdString::npos) 
    45             retvalue << CIndent::NIndent   << line << CIndent::DecEndl << std::endl; 
    46          else if (line.find(" />") != StdString::npos) 
    47             retvalue << CIndent::IncIndent << line << CIndent::DecEndl << std::endl; 
    48          else 
    49             retvalue << CIndent::IncIndent << line <<  std::endl; 
    50       } 
    51       return (retvalue.str()); 
    52    } 
    53 } // namespace xmlioserver 
     47  ostream& Cindent::iendl(ostream& o) const 
     48  { 
     49    if (reset) 
     50    { 
     51      o.iword(index)=0 ; 
     52      return o ; 
     53    } 
     54    else 
     55    { 
     56      o.iword(index)+=offset ; 
     57      if (o.iword(index)<0) o.iword(index)=0 ; 
     58      o<<"\n" ; 
     59      int mem=o.width(o.iword(index)) ; 
     60      o<<""; 
     61      o.width(mem) ; 
     62      return o ; 
     63    } 
     64  } 
     65   
     66  ostream& operator <<(ostream& o, const Cindent& indent)  
     67  { 
     68    return indent.iendl(o) ;  
     69  } 
     70   
     71} 
  • XIOS/trunk/src/indent.hpp

    r219 r313  
    1 #ifndef __XMLIO_CIndent__ 
    2 #define __XMLIO_CIndent__ 
     1#ifndef __XIOS_INDENT_HPP__ 
     2#define __XIOS_INDENT_HPP__ 
    33 
    4 /// xmlioserver headers /// 
    5 #include "xmlioserver_spl.hpp" 
    6 #include "xml_node.hpp" 
     4#include <ostream> 
    75 
    86namespace xmlioserver 
    97{ 
    10    /// ////////////////////// Déclarations ////////////////////// /// 
    11    class CIndent 
    12    { 
    13       public : 
     8  class Cindent   
     9  { 
     10    public: 
     11    static int defaultIncSize; 
     12    static int index ; 
     13    int incSize ; 
     14    int offset ; 
     15    bool reset ; 
     16    public : 
    1417 
    15          /// Méthodes statiques /// 
    16          static StdOStream & NIndent  (StdOStream & out); 
    17          static StdOStream & IncIndent(StdOStream & out); 
    18          static StdOStream & DecEndl  (StdOStream & out); 
     18    Cindent(int i=0, bool r=false) ; 
     19    Cindent operator++(int) ; 
     20    Cindent operator--(int) ; 
     21    Cindent operator++() ; 
     22    Cindent operator--() ; 
     23    Cindent operator+=(int n) ; 
     24    Cindent operator-=(int n) ; 
     25    std::ostream& iendl(std::ostream& o) const ; 
     26  }; 
     27   
     28  std::ostream& operator <<(std::ostream& o, const Cindent& indent) ; 
    1929 
    20       private : 
     30  extern Cindent iendl; 
     31  extern Cindent ireset; 
    2132 
    22          /// Propriétés  statiques /// 
    23          static unsigned int Indent; 
    24          static StdString    Increm; 
    25          static bool         WithLine; 
    26  
    27    }; // class CIndent 
    28  
    29     ///-------------------------------------------------------------- 
    30      
    31    class CIndentedXml 
    32    { 
    33       public : 
    34  
    35          /// Méthode statique /// 
    36          static StdString Indented(const StdString & content); 
    37  
    38    }; // class CIndentedXml 
    39  
    40     ///-------------------------------------------------------------- 
    41  
    42 } // namespace xmlioserver 
    43  
    44    /// ////////////////////// Macros ////////////////////// /// 
    45     
    46 #define NIndent   CIndent::NIndent 
    47 #define IncIndent CIndent::IncIndent 
    48 #define DecEndl   CIndent::DecEndl 
    49  
    50 #endif // __XMLIO_CIndent__ 
     33 
     34#endif 
  • XIOS/trunk/src/manager/tree_manager.hpp

    r219 r313  
    66#include "node_type.hpp" 
    77#include "xml_parser.hpp" 
    8 #include "indent.hpp" 
     8#include "indent_xml.hpp" 
    99 
    1010#undef  DECLARE_ATTRIBUTE 
  • XIOS/trunk/src/node/axis.cpp

    r300 r313  
    5353      if (this->isChecked) return; 
    5454      StdSize size = this->size.getValue(); 
    55       StdSize true_size = zvalue.getValue()->num_elements(); 
     55      StdSize true_size = value.getValue()->num_elements(); 
    5656      if (size != true_size) 
    5757         ERROR("CAxis::checkAttributes(void)", 
    58                << "Le tableau \'zvalue\' a une taille différente de celle indiquée dans l'attribut \'size\'") 
     58               << "Le tableau \'value\' a une taille différente de celle indiquée dans l'attribut \'size\'") 
    5959 
    6060      this->isChecked = true; 
  • XIOS/trunk/src/object_template.hpp

    r300 r313  
    4040         virtual void toBinary  (StdOStream & os) const; 
    4141         virtual void fromBinary(StdIStream & is); 
    42  
     42         virtual string getName(void) const ; 
    4343         virtual void parse(xml::CXMLNode & node); 
    4444          
     
    7171         static boost::shared_ptr<T> create(const string& id=string("")) ; 
    7272          
     73         void generateCInterface(ostream& oss) ; 
     74         void generateFortran2003Interface(ostream& oss) ; 
     75         void generateFortranInterface(ostream& oss) ; 
     76          
    7377      protected : 
    7478 
  • XIOS/trunk/src/object_template_impl.hpp

    r300 r313  
    112112      return (T::GetType()); 
    113113   } 
    114     
     114   
     115   template <class T> 
     116   string CObjectTemplate<T>::getName(void) const 
     117   { 
     118      return (T::GetName()); 
     119   } 
     120   
    115121   //--------------------------------------------------------------- 
    116122 
     
    238244  } 
    239245   
    240  
     246   template <typename T> 
     247   void CObjectTemplate<T>::generateCInterface(ostream& oss) 
     248   { 
     249     string className=getName() ; 
     250     int found=className.find_first_of("_") ; 
     251     if (found!=string::npos) className.replace(found,1,0,'x') ; 
     252      
     253     oss<<"/* ************************************************************************** *"<<iendl ; 
     254     oss<<" *               Interface auto generated - do not modify                   *"<<iendl ; 
     255     oss<<" * ************************************************************************** */"<<iendl; 
     256     oss<<iendl ; 
     257     oss<<"#include <boost/multi_array.hpp>"<<iendl ; 
     258     oss<<"#include <boost/shared_ptr.hpp>"<<iendl ; 
     259     oss<<"#include \"xmlioserver.hpp\""<<iendl; 
     260     oss<<"#include \"attribute_template_impl.hpp\""<<iendl ; 
     261     oss<<"#include \"object_template_impl.hpp\""<<iendl; 
     262     oss<<"#include \"group_template_impl.hpp\""<<iendl ; 
     263     oss<<"#include \"icutil.hpp\""<<iendl ; 
     264     oss<<iendl ; 
     265     oss<<"extern \"C\""<<iendl ; 
     266     oss<<"{"<<iendl++ ; 
     267     oss<<"typedef xmlioserver::tree::"<<getStrType<T>()<<"*  "<<className<<"_Ptr;"<<iendl; 
     268     oss<<iendl ; 
     269     SuperClassMap::generateCInterface(oss,className) ; 
     270     oss<<iendl-- ; 
     271     oss<<"}"<<iendl ; 
     272   } 
     273 
     274   template <typename T> 
     275   void CObjectTemplate<T>::generateFortran2003Interface(ostream& oss) 
     276   { 
     277     string className=getName() ; 
     278     int found=className.find_first_of("_") ; 
     279     if (found!=string::npos) className.replace(found,1,0,'x') ; 
     280      
     281     oss<<"! * ************************************************************************** *"<<iendl ; 
     282     oss<<"! *               Interface auto generated - do not modify                     *"<<iendl ; 
     283     oss<<"! * ************************************************************************** *"<<iendl; 
     284     oss<<iendl ; 
     285     oss<<"MODULE "<<className<<"_interface_attr"<<iendl++ ; 
     286     oss<<"USE, INTRINSIC :: ISO_C_BINDING"<<iendl ; 
     287     oss<<iendl ; 
     288     oss<<"INTERFACE ! Do not call directly / interface FORTRAN 2003 <-> C99"<<iendl++ ; 
     289     oss<<iendl ;    
     290     oss<<iendl ; 
     291     SuperClassMap::generateFortran2003Interface(oss,className) ; 
     292     oss<<"END INTERFACE"<<iendl-- ; 
     293     oss<<iendl-- ; 
     294     oss<<"END MODULE "<<className<<"_interface_attr"<<iendl ; 
     295   } 
    241296   
     297   template <typename T> 
     298   void CObjectTemplate<T>::generateFortranInterface(ostream& oss) 
     299   { 
     300     string className=getName() ; 
     301     int found=className.find_first_of('_') ; 
     302     if (found!=string::npos) className.erase(found,1) ; 
     303     string superClassName=getName(); 
     304     found=superClassName.find("_group") ; 
     305     if (found!=string::npos) superClassName.erase(found,6) ; 
     306      
     307     oss<<"! * ************************************************************************** *"<<iendl ; 
     308     oss<<"! *               Interface auto generated - do not modify                     *"<<iendl ; 
     309     oss<<"! * ************************************************************************** *"<<iendl; 
     310     oss<<"#include \"xios_fortran_prefix.hpp\""<<iendl ; 
     311     oss<<iendl ; 
     312     oss<<"MODULE i"<<className<<"_attr"<<iendl++ ; 
     313     oss<<"USE, INTRINSIC :: ISO_C_BINDING"<<iendl ; 
     314     oss<<"USE i"<<superClassName<<iendl ; 
     315     oss<<"USE "<<className<<"_interface_attr"<<iendl ; 
     316//     oss<<"TYPE txios("<<className<<")"<<iendl ; 
     317//     oss<<"  INTEGER(kind = C_INTPTR_T) :: daddr"<<iendl ; 
     318//     oss<<"END TYPE txios("<<className<<")"<<iendl ; 
     319     oss<<iendl-- ; 
     320     oss<<"CONTAINS"<<iendl++ ; 
     321     oss<<iendl ; 
     322     SuperClassMap::generateFortranInterface_id(oss,className) ; 
     323     oss<<iendl ; 
     324     SuperClassMap::generateFortranInterface_hdl(oss,className) ; 
     325     oss<<iendl ; 
     326     SuperClassMap::generateFortranInterface_hdl_(oss,className) ; 
     327     oss<<iendl ; 
     328     SuperClassMap::generateFortranInterfaceGet_id(oss,className) ; 
     329     oss<<iendl ; 
     330     SuperClassMap::generateFortranInterfaceGet_hdl(oss,className) ; 
     331     oss<<iendl ; 
     332     SuperClassMap::generateFortranInterfaceGet_hdl_(oss,className) ; 
     333     oss<<iendl-- ; 
     334     oss<<"END MODULE i"<<className<<"_attr"<<iendl ; 
     335   } 
     336 
     337 
    242338} // namespace xmlioserver 
    243339 
  • XIOS/trunk/src/output/nc4_data_output.cpp

    r300 r313  
    254254 
    255255               SuperClassWriter::definition_end(); 
    256                SuperClassWriter::writeData(axis->zvalue.getValue(), axisid, true, 0); 
     256               SuperClassWriter::writeData(axis->value.getValue(), axisid, true, 0); 
    257257               SuperClassWriter::definition_start(); 
    258258 
  • XIOS/trunk/src/test/test_cs.f90

    r310 r313  
    3939   
    4040  DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo,field_A_glo 
    41   DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:) 
     41  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:), lonvalue(:) ; 
    4242  INTEGER :: ni,ibegin,iend,nj,jbegin,jend 
    4343  INTEGER :: i,j,ts,n 
     
    6262  iend=ibegin+ni-1 ; jend=jbegin+nj-1 
    6363 
    64   ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2)) 
     64  ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2),lonvalue(ni*nj)) 
    6565  lon(:,:)=lon_glo(ibegin:iend,jbegin:jend) 
    6666  lat(:,:)=lat_glo(ibegin:iend,jbegin:jend) 
     
    9696    dtime%second=3600 
    9797    CALL xios_set_timestep(dtime)  
     98     
     99    ni=0 ; lonvalue(:)=0 
     100    CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue=lonvalue) 
     101     
     102    print *,"ni",ni 
     103    print *,"lonvalue",lonvalue ; 
    98104 
    99105    CALL xios_close_context_definition() 
Note: See TracChangeset for help on using the changeset viewer.