Changeset 1545


Ignore:
Timestamp:
06/18/18 20:32:55 (2 years ago)
Author:
yushan
Message:

branch_openmp merged with trunk r1544

Location:
XIOS/dev/branch_openmp
Files:
30 added
186 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/branch_openmp/arch/arch-X64_ADA.fcm

    r1460 r1545  
    33################################################################################ 
    44 
    5 %CCOMPILER      mpiicc -qopenmp -D_usingEP -D_intelmpi 
     5%CCOMPILER      mpiicc -qopenmp -D_usingEP -D_intelmpi  
    66%FCOMPILER      mpiifort -qopenmp -D_usingEP -D_intelmpi 
    77%LINKER         mpiifort  -nofor-main -qopenmp -D_usingEP -D_intelmpi 
    88 
    9 %BASE_CFLAGS    -diag-disable 1125 -diag-disable 279 
     9 
     10%BASE_CFLAGS    -std=c++11 -diag-disable 1125 -diag-disable 279 
    1011%PROD_CFLAGS    -O3 -D BOOST_DISABLE_ASSERTS 
    1112%DEV_CFLAGS     -g -traceback 
    1213%DEBUG_CFLAGS   -DBZ_DEBUG -g  -fno-inline  
    13 #-std=c++11 
     14 
    1415 
    1516%BASE_FFLAGS    -D__NONE__  
  • XIOS/dev/branch_openmp/extern/remap/src/mapper.cpp

    r1468 r1545  
    279279    } 
    280280  } 
    281  
    282281  MPI_Status *status = new MPI_Status[4*mpiSize]; 
    283282 
     
    419418  } 
    420419         
    421         MPI_Barrier(communicator); 
     420        //MPI_Barrier(communicator); 
    422421 
    423422  /* free all memory allocated in this function */ 
  • XIOS/dev/branch_openmp/extern/remap/src/parallel_tree.cpp

    r1538 r1545  
    384384        CTimer::get("parallelRouteNode").resume(); 
    385385        vector<int> route(node.size()); 
    386         cout<<"node.size = "<<node.size()<<endl; 
    387386        routeNodes(route /*out*/, node); 
    388387        CTimer::get("parallelRouteNode").suspend(); 
  • XIOS/dev/branch_openmp/src/array.hpp

    r591 r1545  
    44/// boost headers /// 
    55#include <boost/cstdint.hpp> 
    6 #include <boost/shared_ptr.hpp> 
    76#include <boost/multi_array.hpp> 
    87 
  • XIOS/dev/branch_openmp/src/array_mac.hpp

    r591 r1545  
    55 
    66// Type Fortran 
    7 #define ARRAY(valuetype, numdims) boost::shared_ptr<CArray<valuetype, numdims> > 
     7#define ARRAY(valuetype, numdims) std::shared_ptr<CArray<valuetype, numdims> > 
    88 
    99#define ARRAY_ASSIGN(value, valuetype, numdims, extent)\ 
  • XIOS/dev/branch_openmp/src/attribute_template_impl.hpp

    r1482 r1545  
    6666        inheritedValue.reset() ; 
    6767      } 
    68  
    6968 
    7069      template <class T> 
     
    8079        } 
    8180      } 
    82        
     81 
    8382      template <class T> 
    8483      T CAttributeTemplate<T>::getValue(void) const 
     
    8685        return CType<T>::get() ; 
    8786      } 
    88  
    8987 
    9088 
  • XIOS/dev/branch_openmp/src/buffer_client.cpp

    r1520 r1545  
    1515  size_t CClientBuffer::maxRequestSize = 0; 
    1616 
    17   CClientBuffer::CClientBuffer(MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents):  
    18     interComm(interComm) 
     17  CClientBuffer::CClientBuffer(MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents) 
     18    : interComm(interComm) 
    1919    , serverRank(serverRank) 
    2020    , bufferSize(bufferSize) 
  • XIOS/dev/branch_openmp/src/buffer_client.hpp

    r1460 r1545  
    4343 
    4444      CBufferOut* retBuffer; 
    45       ep_lib::MPI_Comm interComm; 
     45      const ep_lib::MPI_Comm interComm; 
    4646  }; 
    4747} 
  • XIOS/dev/branch_openmp/src/calendar_util.cpp

    r1482 r1545  
    132132      CDuration dur( dt0.getYear() - dt1.getYear(), dt0.getMonth()  - dt1.getMonth() , dt0.getDay()   - dt1.getDay(), 
    133133      dt0.getHour() - dt1.getHour(), dt0.getMinute() - dt1.getMinute(), dt0.getSecond() - dt1.getSecond() ); 
    134  
    135134      return (dur.resolve(dt0.getRelCalendar())); 
    136135    } 
  • XIOS/dev/branch_openmp/src/client.cpp

    r1460 r1545  
    1818    MPI_Comm CClient::intraComm ; 
    1919    MPI_Comm CClient::interComm ; 
    20     //std::list<MPI_Comm> CClient::contextInterComms; 
    2120    std::list<MPI_Comm> *CClient::contextInterComms_ptr = 0; 
    2221    int CClient::serverLeader ; 
     
    110109            MPI_Comm_size(intraComm,&intraCommSize) ; 
    111110            MPI_Comm_rank(intraComm,&intraCommRank) ; 
     111 
     112            MPI_Intercomm_create(intraComm, 0, CXios::globalComm, serverLeader, 0, &interComm) ; 
    112113            #pragma omp critical (_output) 
    113114            { 
     
    115116                   <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< serverLeader<<endl ; 
    116117            }  
    117             MPI_Intercomm_create(intraComm, 0, CXios::globalComm, serverLeader, 0, &interComm) ; 
    118             //rank_ = intraCommRank; 
     118             
    119119          } 
    120120          else 
     
    198198        CContext::setCurrent(id); 
    199199 
    200         //contextInterComms.push_back(contextInterComm); 
    201200        if(contextInterComms_ptr == NULL) contextInterComms_ptr = new std::list<MPI_Comm>; 
    202201        contextInterComms_ptr->push_back(contextInterComm); 
     
    234233        context->initClient(contextComm,contextInterComm) ; 
    235234 
    236         //contextInterComms.push_back(contextInterComm); 
    237235        if(contextInterComms_ptr == NULL) contextInterComms_ptr = new std::list<MPI_Comm>; 
    238236        contextInterComms_ptr->push_back(contextInterComm); 
     
    260258      } 
    261259 
    262       //for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
    263260      for (std::list<MPI_Comm>::iterator it = contextInterComms_ptr->begin(); it != contextInterComms_ptr->end(); it++) 
    264261        MPI_Comm_free(&(*it)); 
     
    333330      if (!fb->is_open()) 
    334331        ERROR("void CClient::openStream(const StdString& fileName, const StdString& ext, std::filebuf* fb)", 
    335               << std::endl << "Can not open <" << fileNameClient << "> file to write the client log(s)."); 
     332              << std::endl << "Can not open <" << fileNameClient.str() << "> file to write the client log(s)."); 
    336333    } 
    337334 
  • XIOS/dev/branch_openmp/src/client_client_dht_template.hpp

    r1328 r1545  
    1515#include "mpi.hpp" 
    1616#include "policy.hpp" 
    17 #include <boost/unordered_map.hpp> 
     17#include  <unordered_map> 
    1818#include "dht_data_types.hpp" 
    1919 
     
    3434    typedef T InfoType; 
    3535    static const int infoTypeSize = sizeof(InfoType); 
    36 //    typedef typename boost::unordered_map<InfoType, std::vector<size_t> > InfoType2IndexMap; 
    37     typedef typename boost::unordered_map<size_t,InfoType> Index2InfoTypeMap; 
    38     typedef typename boost::unordered_map<size_t,std::vector<InfoType> > Index2VectorInfoTypeMap; 
     36 
     37    typedef typename std::unordered_map<size_t,InfoType> Index2InfoTypeMap; 
     38    typedef typename std::unordered_map<size_t,std::vector<InfoType> > Index2VectorInfoTypeMap; 
    3939 
    4040  public: 
  • XIOS/dev/branch_openmp/src/client_client_dht_template_impl.hpp

    r1460 r1545  
    116116  size_t index; 
    117117  HashXIOS<size_t> hashGlobalIndex; 
    118   boost::unordered_map<size_t,int> nbIndices; 
     118  std::unordered_map<size_t,int> nbIndices; 
    119119  nbIndices.rehash(std::ceil(ssize/nbIndices.max_load_factor())); 
    120120  for (int i = 0; i < ssize; ++i) 
     
    131131  } 
    132132 
    133   boost::unordered_map<int, size_t* > client2ClientIndex; 
     133  std::unordered_map<int, size_t* > client2ClientIndex; 
    134134  for (int idx = 0; idx < nbClient; ++idx) 
    135135  { 
     
    191191    if (0 != recvNbIndexClientCount[idx]) 
    192192      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]); 
    193       //recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request); 
    194193    currentIndex += recvNbIndexClientCount[idx]; 
    195194  } 
    196195 
    197   boost::unordered_map<int, size_t* >::iterator itbIndex = client2ClientIndex.begin(), itIndex, 
     196  std::unordered_map<int, size_t* >::iterator itbIndex = client2ClientIndex.begin(), itIndex, 
    198197                                                iteIndex = client2ClientIndex.end(); 
    199198  for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex) 
    200199    sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]); 
    201     //sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request); 
    202200 
    203201  std::vector<ep_lib::MPI_Status> status(request.size()); 
     
    280278    if (0 != recvNbIndexOnReturn[idx]) 
    281279    { 
    282       //recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, requestOnReturn); 
    283       //recvInfoFromClients(recvRankOnReturn[idx], 
    284       //                    recvInfoBuffOnReturn+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
    285       //                    recvNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), 
    286       //                    commLevel, requestOnReturn); 
    287280      recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]); 
    288281      recvInfoFromClients(recvRankOnReturn[idx], 
     
    294287  } 
    295288 
    296   boost::unordered_map<int,unsigned char*> client2ClientInfoOnReturn; 
    297   boost::unordered_map<int,size_t*> client2ClientIndexOnReturn; 
     289  std::unordered_map<int,unsigned char*> client2ClientInfoOnReturn; 
     290  std::unordered_map<int,size_t*> client2ClientIndexOnReturn; 
    298291  currentIndex = 0; 
    299292  for (int idx = 0; idx < nbRecvClient; ++idx) 
     
    322315      } 
    323316 
    324       //sendIndexToClients(rank, client2ClientIndexOnReturn[rank], 
    325       //                   sendNbIndexOnReturn[idx], commLevel, requestOnReturn); 
    326       //sendInfoToClients(rank, client2ClientInfoOnReturn[rank], 
    327       //                  sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), commLevel, requestOnReturn); 
    328317      sendIndexToClients(rank, client2ClientIndexOnReturn[rank], 
    329318                         sendNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]); 
     
    349338  indexToInfoMappingLevel_.swap(indexToInfoMapping); 
    350339  if (0 != recvNbIndexCount) delete [] recvIndexBuff; 
    351   for (boost::unordered_map<int,size_t*>::const_iterator it = client2ClientIndex.begin(); 
     340  for (std::unordered_map<int,size_t*>::const_iterator it = client2ClientIndex.begin(); 
    352341                                                        it != client2ClientIndex.end(); ++it) 
    353342      delete [] it->second; 
     
    360349  } 
    361350 
    362   for (boost::unordered_map<int,unsigned char*>::const_iterator it = client2ClientInfoOnReturn.begin(); 
     351  for (std::unordered_map<int,unsigned char*>::const_iterator it = client2ClientInfoOnReturn.begin(); 
    363352                                                               it != client2ClientInfoOnReturn.end(); ++it) 
    364353      delete [] it->second; 
    365354 
    366   for (boost::unordered_map<int,size_t*>::const_iterator it = client2ClientIndexOnReturn.begin(); 
     355  for (std::unordered_map<int,size_t*>::const_iterator it = client2ClientIndexOnReturn.begin(); 
    367356                                            it != client2ClientIndexOnReturn.end(); ++it) 
    368357      delete [] it->second; 
     
    430419  } 
    431420 
    432   boost::unordered_map<int, size_t*> client2ClientIndex; 
    433   boost::unordered_map<int, unsigned char*> client2ClientInfo; 
     421  std::unordered_map<int, size_t*> client2ClientIndex; 
     422  std::unordered_map<int, unsigned char*> client2ClientInfo; 
    434423  for (int idx = 0; idx < nbClient; ++idx) 
    435424  { 
     
    500489    if (0 != recvNbIndexClientCount[idx]) 
    501490    { 
    502       //recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request); 
    503       //recvInfoFromClients(recvRankClient[idx], 
    504       //                    recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
    505       //                    recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(), 
    506       //                    commLevel, request); 
    507491        recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]); 
    508492        recvInfoFromClients(recvRankClient[idx], 
     
    514498  } 
    515499 
    516   boost::unordered_map<int, size_t* >::iterator itbIndex = client2ClientIndex.begin(), itIndex, 
     500  std::unordered_map<int, size_t* >::iterator itbIndex = client2ClientIndex.begin(), itIndex, 
    517501                                                iteIndex = client2ClientIndex.end(); 
    518502  for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex) 
    519503    sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]); 
    520     //sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request); 
    521   boost::unordered_map<int, unsigned char*>::iterator itbInfo = client2ClientInfo.begin(), itInfo, 
     504  std::unordered_map<int, unsigned char*>::iterator itbInfo = client2ClientInfo.begin(), itInfo, 
    522505                                                      iteInfo = client2ClientInfo.end(); 
    523506  for (itInfo = itbInfo; itInfo != iteInfo; ++itInfo) 
    524507    sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, &request[request_position++]); 
    525     //sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, request); 
    526508 
    527509  std::vector<ep_lib::MPI_Status> status(request.size()); 
     
    551533    delete [] recvInfoBuff; 
    552534  } 
    553   for (boost::unordered_map<int,unsigned char*>::const_iterator it = client2ClientInfo.begin(); 
     535  for (std::unordered_map<int,unsigned char*>::const_iterator it = client2ClientInfo.begin(); 
    554536                                                               it != client2ClientInfo.end(); ++it) 
    555537      delete [] it->second; 
    556538 
    557   for (boost::unordered_map<int,size_t*>::const_iterator it = client2ClientIndex.begin(); 
     539  for (std::unordered_map<int,size_t*>::const_iterator it = client2ClientIndex.begin(); 
    558540                                                        it != client2ClientIndex.end(); ++it) 
    559541      delete [] it->second; 
  • XIOS/dev/branch_openmp/src/client_server_mapping.hpp

    r1460 r1545  
    1313#include "array_new.hpp" 
    1414#include "mpi.hpp" 
    15 #include <boost/unordered_map.hpp> 
     15#include <unordered_map> 
    1616 
    1717namespace xios { 
     
    2525{ 
    2626public: 
    27   typedef boost::unordered_map<int, std::vector<size_t> > GlobalIndexMap; 
     27  typedef std::unordered_map<int, std::vector<size_t> > GlobalIndexMap; 
    2828  public: 
    2929    /** Default constructor */ 
  • XIOS/dev/branch_openmp/src/client_server_mapping_distributed.cpp

    r1460 r1545  
    2020{ 
    2121 
    22 CClientServerMappingDistributed::CClientServerMappingDistributed(const boost::unordered_map<size_t,int>& globalIndexOfServer, 
     22CClientServerMappingDistributed::CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer, 
    2323                                                                 const MPI_Comm& clientIntraComm, bool isDataDistributed) 
    2424  : CClientServerMapping(), ccDHT_(0) 
  • XIOS/dev/branch_openmp/src/client_server_mapping_distributed.hpp

    r1460 r1545  
    1616#include "array_new.hpp" 
    1717#include "mpi.hpp" 
    18 #include <boost/unordered_map.hpp> 
     18#include <unordered_map> 
    1919#include "client_client_dht_template.hpp" 
    2020 
     
    3434  public: 
    3535    /** Default constructor */ 
    36     CClientServerMappingDistributed(const boost::unordered_map<size_t,int>& globalIndexOfServer, 
     36    CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer, 
    3737                                    const ep_lib::MPI_Comm& clientIntraComm, 
    3838                                    bool isDataDistributed = true); 
  • XIOS/dev/branch_openmp/src/config/axis_attribute.conf

    r1460 r1545  
    22DECLARE_ATTRIBUTE(StdString, standard_name) 
    33DECLARE_ATTRIBUTE(StdString, long_name) 
     4 
     5DECLARE_ATTRIBUTE(StdString, comment) 
    46 
    57DECLARE_ATTRIBUTE(StdString, unit) 
  • XIOS/dev/branch_openmp/src/config/calendar_wrapper_attribute.conf

    r550 r1545  
     1DECLARE_ATTRIBUTE(StdString, comment) 
    12DECLARE_ENUM6(type, D360, AllLeap, NoLeap, Julian, Gregorian, user_defined) 
    23DECLARE_ATTRIBUTE(CDuration, timestep) 
  • XIOS/dev/branch_openmp/src/config/domain_attribute.conf

    r1460 r1545  
    99DECLARE_ATTRIBUTE(StdString       , dim_i_name) 
    1010DECLARE_ATTRIBUTE(StdString       , dim_j_name) 
     11 
     12DECLARE_ATTRIBUTE(StdString, comment) 
    1113 
    1214/* GLOBAL */ 
  • XIOS/dev/branch_openmp/src/config/field_attribute.conf

    r1205 r1545  
    22DECLARE_ATTRIBUTE(StdString, standard_name) 
    33DECLARE_ATTRIBUTE(StdString, long_name) 
     4 
     5DECLARE_ATTRIBUTE(StdString, comment) 
    46 
    57DECLARE_ATTRIBUTE(StdString, unit) 
     
    1820DECLARE_ATTRIBUTE(bool,      check_if_active) 
    1921 
    20 DECLARE_ATTRIBUTE(StdString, domain_ref) 
    21 DECLARE_ATTRIBUTE(StdString, axis_ref) 
    22 DECLARE_ATTRIBUTE(StdString, scalar_ref) 
     22DECLARE_ATTRIBUTE(StdString, domain_ref, false) 
     23DECLARE_ATTRIBUTE(StdString, axis_ref, false) 
     24DECLARE_ATTRIBUTE(StdString, scalar_ref, false) 
    2325DECLARE_ATTRIBUTE(StdString, grid_ref) 
    2426DECLARE_ATTRIBUTE(StdString, field_ref) 
  • XIOS/dev/branch_openmp/src/config/file_attribute.conf

    r1491 r1545  
    11DECLARE_ATTRIBUTE(StdString, name) 
    22DECLARE_ATTRIBUTE(StdString, description) 
     3 
     4DECLARE_ATTRIBUTE(StdString, comment) 
    35 
    46DECLARE_ATTRIBUTE(StdString, name_suffix) 
  • XIOS/dev/branch_openmp/src/config/grid_attribute.conf

    r1460 r1545  
    11DECLARE_ATTRIBUTE(StdString, name) 
    22DECLARE_ATTRIBUTE(StdString, description) 
     3 
     4DECLARE_ATTRIBUTE(StdString, comment) 
    35 
    46DECLARE_ARRAY(bool, 1, mask_1d, false) 
  • XIOS/dev/branch_openmp/src/config/scalar_attribute.conf

    r1460 r1545  
    22DECLARE_ATTRIBUTE(StdString, standard_name) 
    33DECLARE_ATTRIBUTE(StdString, long_name) 
     4 
     5DECLARE_ATTRIBUTE(StdString, comment) 
    46 
    57DECLARE_ATTRIBUTE(StdString, unit) 
  • XIOS/dev/branch_openmp/src/context_client.cpp

    r1520 r1545  
    102102        typeId_in=event.getTypeId() ; 
    103103        classId_in=event.getClassId() ; 
    104         //MPI_Allreduce(&timeLine,&timeLine_out, 1, MPI_UINT64_T, MPI_SUM, intraComm) ; 
    105104        MPI_Allreduce(&timeLine,&timeLine_out, 1, MPI_LONG_LONG_INT, MPI_SUM, intraComm) ; 
    106105        MPI_Allreduce(&typeId_in,&typeId, 1, MPI_INT, MPI_SUM, intraComm) ; 
     
    342341       if (ratio < minBufferSizeEventSizeRatio) minBufferSizeEventSizeRatio = ratio; 
    343342     } 
    344      //MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, MPI_DOUBLE, MPI_MIN, intraComm); 
    345343     MPI_Allreduce(&minBufferSizeEventSizeRatio, &minBufferSizeEventSizeRatio, 1, MPI_DOUBLE, MPI_MIN, intraComm); 
    346344 
  • XIOS/dev/branch_openmp/src/context_server.cpp

    r1538 r1545  
    130130       MPI_Irecv(&buffSize, 1, MPI_LONG, rank, 20, interComm, &request); 
    131131       MPI_Wait(&request, &status); 
    132        //MPI_Recv(&buffSize, 1, MPI_LONG, rank, 20, interComm, &status); 
    133132       mapBufferSize_.insert(std::make_pair(rank, buffSize)); 
    134133       it=(buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer(buffSize)))).first; 
  • XIOS/dev/branch_openmp/src/cxios.cpp

    r1538 r1545  
    6666    usingServer2=getin<bool>("using_server2",false) ; 
    6767    ratioServer2=getin<int>("ratio_server2",50); 
    68     nbPoolsServer2=getin<int>("number_pools_server2",1); 
     68    nbPoolsServer2=getin<int>("number_pools_server2",0); 
    6969    info.setLevel(getin<int>("info_level",0)) ; 
    7070    report.setLevel(getin<int>("info_level",50)); 
     
    108108      MPI_Comm_create_endpoints(MPI_COMM_WORLD->mpi_comm, num_ep, info, ep_comm);  // servers should reach here too. 
    109109      passage = ep_comm;  
    110       //::MPI_Comm_group(to_mpi_comm(MPI_COMM_WORLD->mpi_comm), &MPI_GROUP_WORLD);  
    111110    } 
    112111         
  • XIOS/dev/branch_openmp/src/data_output.cpp

    r1328 r1545  
    8787      { 
    8888         CContext* context = CContext::getCurrent() ; 
    89          boost::shared_ptr<CCalendar> calendar = context->getCalendar(); 
     89         std::shared_ptr<CCalendar> calendar = context->getCalendar(); 
    9090 
    9191         this->writeTimeAxis_(field, calendar); 
  • XIOS/dev/branch_openmp/src/data_output.hpp

    r1334 r1545  
    5959            virtual void writeTimeDimension_(void)           = 0; 
    6060            virtual void writeTimeAxis_ (CField*     field, 
    61                                          const boost::shared_ptr<CCalendar> cal) = 0; 
     61                                         const std::shared_ptr<CCalendar> cal) = 0; 
    6262 
    6363            /// Propriétés protégées /// 
  • XIOS/dev/branch_openmp/src/date.cpp

    r1105 r1545  
    235235      void CDate::addMonth(int value) 
    236236      {// Value doit être égale à 1 ou -1. 
     237 
     238        const CCalendar& c = getRelCalendar(); 
     239        int nbMonthsPerYear = c.getYearLength(); 
     240 
    237241        this->month += value; 
    238         if (this->month == 13) { year++; this->month = 1; } 
    239         if (this->month == 0)  { year--; this->month = 12; } 
     242 
     243        if (this->month == nbMonthsPerYear + 1) { year++; this->month = 1; } 
     244        if (this->month == 0)  { year--; this->month = nbMonthsPerYear; } 
    240245      } 
    241246 
  • XIOS/dev/branch_openmp/src/distribution.hpp

    r1460 r1545  
    1212#include "xios_spl.hpp" 
    1313#include "array_new.hpp" 
    14 #include <boost/unordered_map.hpp> 
     14#include <unordered_map> 
    1515 
    1616namespace xios { 
     
    2424{ 
    2525  public: 
    26   typedef boost::unordered_map<size_t,int> GlobalLocalMap; 
     26  typedef std::unordered_map<size_t,int> GlobalLocalMap; 
    2727 
    2828  public: 
  • XIOS/dev/branch_openmp/src/duration.cpp

    r1482 r1545  
    77{ 
    88      /// ////////////////////// Définitions ////////////////////// /// 
    9                        
     9 
    1010      const CDuration Year     ( 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ); 
    1111      const CDuration Month    ( 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0 ); 
     
    2525      } 
    2626 
     27      ///--------------------------------------------------------------- 
    2728 
    2829      CDuration& CDuration::operator=(const CDuration& duration) 
  • XIOS/dev/branch_openmp/src/duration.hpp

    r1482 r1545  
    2121         public: 
    2222            CDuration(double year=0.0, double month=0.0, double day=0.0, double hour=0.0, double minute=0.0, double second=0.0, double timestep=0.0); 
    23              
     23 
    2424            /// Opérateurs /// 
    2525            CDuration& operator=(const CDuration& duration); 
  • XIOS/dev/branch_openmp/src/filter/binary_arithmetic_filter.hpp

    r642 r1545  
    55#include <string> 
    66#include "operator_expr.hpp" 
     7#include <unordered_map> 
    78 
    89namespace xios 
  • XIOS/dev/branch_openmp/src/filter/data_packet.hpp

    r643 r1545  
    22#define __XIOS_CDataPacket__ 
    33 
    4 #include <boost/shared_ptr.hpp> 
     4#include <memory> 
    55 
    66#include "array_new.hpp" 
     
    4343  }; // struct CDataPacket 
    4444 
    45   typedef boost::shared_ptr<CDataPacket> CDataPacketPtr; 
    46   typedef boost::shared_ptr<const CDataPacket> CConstDataPacketPtr; 
     45  typedef std::shared_ptr<CDataPacket> CDataPacketPtr; 
     46  typedef std::shared_ptr<const CDataPacket> CConstDataPacketPtr; 
    4747} // namespace xios 
    4848 
  • XIOS/dev/branch_openmp/src/filter/output_pin.cpp

    r1460 r1545  
    99  { /* Nothing to do */ } 
    1010 
    11   void COutputPin::connectOutput(boost::shared_ptr<CInputPin> inputPin, size_t inputSlot) 
     11  void COutputPin::connectOutput(std::shared_ptr<CInputPin> inputPin, size_t inputSlot) 
    1212  { 
    1313    if (!inputPin) 
     
    4242            "The packet cannot be null."); 
    4343 
    44     std::vector<std::pair<boost::shared_ptr<CInputPin>, size_t> >::iterator it, itEnd; 
     44    std::vector<std::pair<std::shared_ptr<CInputPin>, size_t> >::iterator it, itEnd; 
    4545    for (it = outputs.begin(), itEnd = outputs.end(); it != itEnd; ++it) 
    4646      it->first->setInput(it->second, packet); 
     
    6868  bool COutputPin::mustAutoTrigger() const 
    6969  { 
    70     std::vector<std::pair<boost::shared_ptr<CInputPin>, size_t> >::const_iterator it, itEnd; 
     70    std::vector<std::pair<std::shared_ptr<CInputPin>, size_t> >::const_iterator it, itEnd; 
    7171    for (it = outputs.begin(), itEnd = outputs.end(); it != itEnd; ++it) 
    7272    { 
     
    8080  void COutputPin::setOutputTriggers() 
    8181  { 
    82     std::vector<std::pair<boost::shared_ptr<CInputPin>, size_t> >::iterator it, itEnd; 
     82    std::vector<std::pair<std::shared_ptr<CInputPin>, size_t> >::iterator it, itEnd; 
    8383    for (it = outputs.begin(), itEnd = outputs.end(); it != itEnd; ++it) 
    8484      it->first->setInputTrigger(it->second, this); 
     
    8787  bool COutputPin::isDataExpected(const CDate& date) const 
    8888  { 
    89     std::vector<std::pair<boost::shared_ptr<CInputPin>, size_t> >::const_iterator it, itEnd; 
     89    std::vector<std::pair<std::shared_ptr<CInputPin>, size_t> >::const_iterator it, itEnd; 
    9090    for (it = outputs.begin(), itEnd = outputs.end(); it != itEnd; ++it) 
    9191    { 
  • XIOS/dev/branch_openmp/src/filter/output_pin.hpp

    r1460 r1545  
    2929       * \param inputSlot the input slot number 
    3030       */ 
    31       void connectOutput(boost::shared_ptr<CInputPin> inputPin, size_t inputSlot); 
     31      void connectOutput(std::shared_ptr<CInputPin> inputPin, size_t inputSlot); 
    3232 
    3333      /*! 
     
    9393 
    9494      //!< The list of connected filters and the corresponding slot numbers 
    95       std::vector<std::pair<boost::shared_ptr<CInputPin>, size_t> > outputs; 
     95      std::vector<std::pair<std::shared_ptr<CInputPin>, size_t> > outputs; 
    9696 
    9797      //! Output buffer, store the packets until the output is triggered 
  • XIOS/dev/branch_openmp/src/filter/spatial_transform_filter.cpp

    r1482 r1545  
    1313  { /* Nothing to do */ } 
    1414 
    15   std::pair<boost::shared_ptr<CSpatialTransformFilter>, boost::shared_ptr<CSpatialTransformFilter> > 
     15  std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> > 
    1616  CSpatialTransformFilter::buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double missingValue) 
    1717  { 
    1818    if (!srcGrid || !destGrid) 
    19       ERROR("std::pair<boost::shared_ptr<CSpatialTransformFilter>, boost::shared_ptr<CSpatialTransformFilter> >" 
     19      ERROR("std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> >" 
    2020            "buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid)", 
    2121            "Impossible to build the filter graph if either the source or the destination grid are null."); 
    2222 
    23     boost::shared_ptr<CSpatialTransformFilter> firstFilter, lastFilter; 
     23    std::shared_ptr<CSpatialTransformFilter> firstFilter, lastFilter; 
    2424    // Note that this loop goes from the last transformation to the first transformation 
    2525    do 
     
    3838      for (it=algoList.begin();it!=algoList.end();++it)  if (it->second.first == TRANS_TEMPORAL_SPLITTING) isSpatialTemporal=true ; 
    3939 
    40       boost::shared_ptr<CSpatialTransformFilter> filter ; 
    41       if( isSpatialTemporal) filter = boost::shared_ptr<CSpatialTransformFilter>(new CSpatialTemporalFilter(gc, engine, gridTransformation, defaultValue, inputCount)); 
    42       else filter = boost::shared_ptr<CSpatialTransformFilter>(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount)); 
     40      std::shared_ptr<CSpatialTransformFilter> filter ; 
     41      if( isSpatialTemporal) filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTemporalFilter(gc, engine, gridTransformation, defaultValue, inputCount)); 
     42      else filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount)); 
    4343 
    4444       
     
    142142  } 
    143143 
    144   //std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> > CSpatialTransformFilterEngine::engines; 
    145   std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> > *CSpatialTransformFilterEngine::engines_ptr = 0; 
     144  std::map<CGridTransformation*, std::shared_ptr<CSpatialTransformFilterEngine> > *CSpatialTransformFilterEngine::engines_ptr = 0; 
    146145 
    147146  CSpatialTransformFilterEngine* CSpatialTransformFilterEngine::get(CGridTransformation* gridTransformation) 
     
    151150            "Impossible to get the requested engine, the grid transformation is invalid."); 
    152151     
    153     if(engines_ptr == NULL) engines_ptr = new std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> >; 
    154  
    155     //std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> >::iterator it = engines.find(gridTransformation); 
    156     std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> >::iterator it = engines_ptr->find(gridTransformation); 
    157     //if (it == engines.end()) 
     152    if(engines_ptr == NULL) engines_ptr = new std::map<CGridTransformation*, std::shared_ptr<CSpatialTransformFilterEngine> >; 
     153 
     154 
     155    std::map<CGridTransformation*, std::shared_ptr<CSpatialTransformFilterEngine> >::iterator it = engines_ptr->find(gridTransformation); 
    158156    if (it == engines_ptr->end()) 
    159157    { 
    160       boost::shared_ptr<CSpatialTransformFilterEngine> engine(new CSpatialTransformFilterEngine(gridTransformation)); 
    161       //it = engines.insert(std::make_pair(gridTransformation, engine)).first; 
     158      std::shared_ptr<CSpatialTransformFilterEngine> engine(new CSpatialTransformFilterEngine(gridTransformation)); 
    162159      it = engines_ptr->insert(std::make_pair(gridTransformation, engine)).first; 
    163160    } 
  • XIOS/dev/branch_openmp/src/filter/spatial_transform_filter.hpp

    r1460 r1545  
    3636       * \return the first and the last filters of the filter graph 
    3737       */ 
    38       static std::pair<boost::shared_ptr<CSpatialTransformFilter>, boost::shared_ptr<CSpatialTransformFilter> > 
     38      static std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> > 
    3939      buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double defaultValue); 
    4040 
     
    141141 
    142142      //! The allocated engines 
    143       //static std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> > engines; 
    144       static std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> > *engines_ptr; 
     143 
     144      static std::map<CGridTransformation*, std::shared_ptr<CSpatialTransformFilterEngine> > *engines_ptr; 
    145145      #pragma omp threadprivate(engines_ptr) 
    146146  }; // class CSpatialTransformFilterEngine 
  • XIOS/dev/branch_openmp/src/filter/temporal_filter.cpp

    r1482 r1545  
    2222                        this->samplingOffset.second, this->samplingOffset.timestep) 
    2323    , initDate(initDate) 
    24     , nextSamplingDate(initDate + (this->samplingOffset + initDate.getRelCalendar().getTimeStep())) 
     24    , nextSamplingDate(initDate + offsetMonth + ( offsetAllButMonth + initDate.getRelCalendar().getTimeStep())) 
    2525    , nbOperationDates(1) 
    2626    , nbSamplingDates(0) 
  • XIOS/dev/branch_openmp/src/generate_fortran_interface.cpp

    r1460 r1545  
    302302  file.open((path+"iexpand_domain_attr.F90").c_str()); 
    303303  expandDomain.generateFortranInterface(file); 
     304  file.close(); 
    304305 
    305306  file.open((path+"reorder_domain_interface_attr.F90").c_str()); 
  • XIOS/dev/branch_openmp/src/group_factory.hpp

    r1334 r1545  
    11#ifndef __XIOS_CGroupFactory__ 
    22#define __XIOS_CGroupFactory__ 
    3  
    4 /// boost headers /// 
    5 #include <boost/shared_ptr.hpp> 
    63 
    74/// XIOS headers /// 
     
    2320 
    2421         template <typename U> 
    25             static void AddGroup(boost::shared_ptr<U> pgroup, 
    26                                         boost::shared_ptr<U> cgroup); 
     22            static void AddGroup(std::shared_ptr<U> pgroup, 
     23                                        std::shared_ptr<U> cgroup); 
    2724 
    2825         template <typename U> 
    29             static void AddChild(boost::shared_ptr<U> group, 
    30                                         boost::shared_ptr<typename U::RelChild> child); 
     26            static void AddChild(std::shared_ptr<U> group, 
     27                                        std::shared_ptr<typename U::RelChild> child); 
    3128 
    3229         /// Accesseurs /// 
     
    3431 
    3532         template <typename U> 
    36             static boost::shared_ptr<U> 
    37                GetGroup(boost::shared_ptr<U> group, const StdString & id); 
     33            static std::shared_ptr<U> 
     34               GetGroup(std::shared_ptr<U> group, const StdString & id); 
    3835 
    3936         template <typename U> 
    40             static boost::shared_ptr<typename U::RelChild> 
    41                GetChild(boost::shared_ptr<U> group, const StdString & id); 
     37            static std::shared_ptr<typename U::RelChild> 
     38               GetChild(std::shared_ptr<U> group, const StdString & id); 
    4239 
    4340         template <typename U> 
    44             static int GetGroupNum(boost::shared_ptr<U> group); 
     41            static int GetGroupNum(std::shared_ptr<U> group); 
    4542         template <typename U> 
    46             static int GetGroupIdNum(boost::shared_ptr<U> group); 
     43            static int GetGroupIdNum(std::shared_ptr<U> group); 
    4744         template <typename U> 
    48             static int GetChildNum(boost::shared_ptr<U> group); 
     45            static int GetChildNum(std::shared_ptr<U> group); 
    4946         template <typename U> 
    50             static int GetChildIdNum(boost::shared_ptr<U> group); 
     47            static int GetChildIdNum(std::shared_ptr<U> group); 
    5148 
    5249         /// Tests /// 
    5350         template <typename U> 
    54             static bool HasGroup(boost::shared_ptr<U> group, const StdString & id); 
     51            static bool HasGroup(std::shared_ptr<U> group, const StdString & id); 
    5552 
    5653         template <typename U> 
    57             static bool HasChild(boost::shared_ptr<U> group, const StdString & id); 
     54            static bool HasChild(std::shared_ptr<U> group, const StdString & id); 
    5855 
    5956         /// Instanciateur /// 
    6057         template <typename U> 
    61             static boost::shared_ptr<U> 
    62                CreateGroup(boost::shared_ptr<U> group, const StdString & id = StdString("")); 
     58            static std::shared_ptr<U> 
     59               CreateGroup(std::shared_ptr<U> group, const StdString & id = StdString("")); 
    6360 
    6461         template <typename U> 
    65             static boost::shared_ptr<typename U::RelChild> 
    66                CreateChild(boost::shared_ptr<U> group, const StdString & id = StdString("")); 
     62            static std::shared_ptr<typename U::RelChild> 
     63               CreateChild(std::shared_ptr<U> group, const StdString & id = StdString("")); 
    6764 
    6865      private : 
  • XIOS/dev/branch_openmp/src/group_factory_decl.cpp

    r1460 r1545  
    55{ 
    66# define  macro(U) \ 
    7   template void CGroupFactory::AddGroup<U>(boost::shared_ptr<U> pgroup,boost::shared_ptr<U> cgroup); \ 
    8   template void CGroupFactory::AddChild<U>(boost::shared_ptr<U> group, boost::shared_ptr<U::RelChild> child); \ 
    9   template boost::shared_ptr<U>  CGroupFactory::GetGroup<U>(boost::shared_ptr<U> group, const StdString & id); \ 
    10   template boost::shared_ptr<U::RelChild> CGroupFactory::GetChild<U>(boost::shared_ptr<U> group, const StdString & id); \ 
    11   template int CGroupFactory::GetGroupNum<U>(boost::shared_ptr<U> group); \ 
    12   template int CGroupFactory::GetGroupIdNum<U>(boost::shared_ptr<U> group); \ 
    13   template int CGroupFactory::GetChildNum<U>(boost::shared_ptr<U> group); \ 
    14   template int CGroupFactory::GetChildIdNum<U>(boost::shared_ptr<U> group); \ 
    15   template bool CGroupFactory::HasGroup<U>(boost::shared_ptr<U> group, const StdString & id); \ 
    16   template bool CGroupFactory::HasChild<U>(boost::shared_ptr<U> group, const StdString & id); \ 
    17   template boost::shared_ptr<U> CGroupFactory::CreateGroup<U>(boost::shared_ptr<U> group, const StdString & id ); \ 
    18   template boost::shared_ptr<U::RelChild>  CGroupFactory::CreateChild<U>(boost::shared_ptr<U> group, const StdString & id); 
     7  template void CGroupFactory::AddGroup<U>(std::shared_ptr<U> pgroup, std::shared_ptr<U> cgroup); \ 
     8  template void CGroupFactory::AddChild<U>(std::shared_ptr<U> group, std::shared_ptr<U::RelChild> child); \ 
     9  template std::shared_ptr<U>  CGroupFactory::GetGroup<U>(std::shared_ptr<U> group, const StdString & id); \ 
     10  template std::shared_ptr<U::RelChild> CGroupFactory::GetChild<U>( std::shared_ptr<U> group, const StdString & id); \ 
     11  template int CGroupFactory::GetGroupNum<U>(std::shared_ptr<U> group); \ 
     12  template int CGroupFactory::GetGroupIdNum<U>(std::shared_ptr<U> group); \ 
     13  template int CGroupFactory::GetChildNum<U>(std::shared_ptr<U> group); \ 
     14  template int CGroupFactory::GetChildIdNum<U>(std::shared_ptr<U> group); \ 
     15  template bool CGroupFactory::HasGroup<U>(std::shared_ptr<U> group, const StdString & id); \ 
     16  template bool CGroupFactory::HasChild<U>(std::shared_ptr<U> group, const StdString & id); \ 
     17  template std::shared_ptr<U> CGroupFactory::CreateGroup<U>(std::shared_ptr<U> group, const StdString & id ); \ 
     18  template std::shared_ptr<U::RelChild>  CGroupFactory::CreateChild<U>(std::shared_ptr<U> group, const StdString & id); 
    1919 
    2020  macro(CFieldGroup) 
  • XIOS/dev/branch_openmp/src/group_factory_impl.hpp

    r591 r1545  
    99 
    1010   template <typename U> 
    11       void CGroupFactory::AddGroup(boost::shared_ptr<U> pgroup, 
    12                                    boost::shared_ptr<U> cgroup) 
     11      void CGroupFactory::AddGroup(std::shared_ptr<U> pgroup, 
     12                                   std::shared_ptr<U> cgroup) 
    1313   { 
    1414      if (cgroup.get() == NULL || pgroup.get() == NULL ) 
    15          ERROR("CGroupFactory::AddGroup(boost::shared_ptr<U> pgroup, boost::shared_ptr<U> cgroup)", 
     15         ERROR("CGroupFactory::AddGroup(std::shared_ptr<U> pgroup, std::shared_ptr<U> cgroup)", 
    1616               << " pgroup or cgroup NULL !"); 
    1717      if (!cgroup->hasId()) 
     
    2525 
    2626   template <typename U> 
    27       void CGroupFactory::AddChild(boost::shared_ptr<U> group, 
    28                                    boost::shared_ptr<typename U::RelChild> child) 
     27      void CGroupFactory::AddChild(std::shared_ptr<U> group, 
     28                                   std::shared_ptr<typename U::RelChild> child) 
    2929   { 
    3030      if (group.get() == NULL || child.get() == NULL ) 
    31          ERROR("CGroupFactory::AddGroup(boost::shared_ptr<U> pgroup, boost::shared_ptr<U> cgroup)", 
     31         ERROR("CGroupFactory::AddGroup(std::shared_ptr<U> pgroup, std::shared_ptr<U> cgroup)", 
    3232               << " pgroup or cgroup NULL !"); 
    3333      if (!child->hasId()) 
     
    4141 
    4242   template <typename U> 
    43       boost::shared_ptr<U> 
    44          CGroupFactory::CreateGroup(boost::shared_ptr<U> group, const StdString & id) 
     43      std::shared_ptr<U> 
     44         CGroupFactory::CreateGroup(std::shared_ptr<U> group, const StdString & id) 
    4545   { 
    4646      CObjectFactory::SetCurrentContextId 
     
    4848      if (id.size() == 0) 
    4949      { 
    50          boost::shared_ptr<U> value = CObjectFactory::CreateObject<U>(CObjectFactory::GenUId<U>()); 
     50         std::shared_ptr<U> value = CObjectFactory::CreateObject<U>(CObjectFactory::GenUId<U>()); 
    5151         group->groupList.insert(group->groupList.end(), value.get()); 
    5252         group->groupMap.insert(std::make_pair(value->getId(), value.get())); 
     
    5757      else 
    5858      { 
    59          boost::shared_ptr<U> value = CObjectFactory::CreateObject<U>(id); 
     59         std::shared_ptr<U> value = CObjectFactory::CreateObject<U>(id); 
    6060         group->groupList.insert(group->groupList.end(), value.get()); 
    6161         group->groupMap.insert(std::make_pair(id, value.get())); 
     
    6565 
    6666   template <typename U> 
    67       boost::shared_ptr<typename U::RelChild> 
    68          CGroupFactory::CreateChild(boost::shared_ptr<U> group, const StdString & id) 
     67      std::shared_ptr<typename U::RelChild> 
     68         CGroupFactory::CreateChild(std::shared_ptr<U> group, const StdString & id) 
    6969   { 
    7070      CObjectFactory::SetCurrentContextId 
     
    7272      if (id.size() == 0) 
    7373      { 
    74          boost::shared_ptr<typename U::RelChild> value = 
     74         std::shared_ptr<typename U::RelChild> value = 
    7575               CObjectFactory::CreateObject<typename U::RelChild>(); 
    7676         group->childList.insert(group->childList.end(), value.get()); 
     
    8282      else 
    8383      { 
    84          boost::shared_ptr<typename U::RelChild> value = 
     84         std::shared_ptr<typename U::RelChild> value = 
    8585               CObjectFactory::CreateObject<typename U::RelChild>(id); 
    8686         group->childList.insert(group->childList.end(), value.get()); 
     
    9191 
    9292   template <typename U> 
    93       bool CGroupFactory::HasGroup(boost::shared_ptr<U> group, const StdString & id) 
     93      bool CGroupFactory::HasGroup(std::shared_ptr<U> group, const StdString & id) 
    9494   {  return (group->groupMap.find(id) != group->groupMap.end()); } 
    9595 
    9696   template <typename U> 
    97       bool CGroupFactory::HasChild(boost::shared_ptr<U> group, const StdString & id) 
     97      bool CGroupFactory::HasChild(std::shared_ptr<U> group, const StdString & id) 
    9898   {  return (group->childMap.find(id) != group->childMap.end()); } 
    9999 
    100100   template <typename U> 
    101       int CGroupFactory::GetGroupNum(boost::shared_ptr<U> group) 
     101      int CGroupFactory::GetGroupNum(std::shared_ptr<U> group) 
    102102   { return (group->groupList.size()); } 
    103103 
    104104   template <typename U> 
    105       int CGroupFactory::GetGroupIdNum(boost::shared_ptr<U> group) 
     105      int CGroupFactory::GetGroupIdNum(std::shared_ptr<U> group) 
    106106   { return (group->groupMap.size()); } 
    107107 
    108108   template <typename U> 
    109       int CGroupFactory::GetChildNum(boost::shared_ptr<U> group) 
     109      int CGroupFactory::GetChildNum(std::shared_ptr<U> group) 
    110110   { return (group->childList.size()); } 
    111111 
    112112   template <typename U> 
    113       int CGroupFactory::GetChildIdNum(boost::shared_ptr<U> group) 
     113      int CGroupFactory::GetChildIdNum(std::shared_ptr<U> group) 
    114114   { return (group->childMap.size()); } 
    115115 
    116116   template <typename U> 
    117       boost::shared_ptr<U> 
    118          CGroupFactory::GetGroup(boost::shared_ptr<U> group, const StdString & id) 
     117      std::shared_ptr<U> 
     118         CGroupFactory::GetGroup(std::shared_ptr<U> group, const StdString & id) 
    119119   { 
    120120      if (!CGroupFactory::HasGroup<U>(group, id)) 
    121          ERROR("CGroupFactory::GetGroup(boost::shared_ptr<U> group, const StdString & id)", 
     121         ERROR("CGroupFactory::GetGroup(std::shared_ptr<U> group, const StdString & id)", 
    122122               << "[ id = " << id << ", U = " << U::GetName() << " ] " 
    123123               << " group is not referenced !"); 
     
    126126 
    127127   template <typename U> 
    128       boost::shared_ptr<typename U::RelChild> 
    129          CGroupFactory::GetChild(boost::shared_ptr<U> group, const StdString & id) 
     128      std::shared_ptr<typename U::RelChild> 
     129         CGroupFactory::GetChild(std::shared_ptr<U> group, const StdString & id) 
    130130   { 
    131131      if (!CGroupFactory::HasChild<U>(group, id)) 
    132          ERROR("CGroupFactory::GetChild(boost::shared_ptr<U> group, const StdString & id)", 
     132         ERROR("CGroupFactory::GetChild(std::shared_ptr<U> group, const StdString & id)", 
    133133               << "[ id = " << id << ", U = " << U::GetName() << " ] " 
    134134               << " child is not referenced !"); 
  • XIOS/dev/branch_openmp/src/group_template.hpp

    r1460 r1545  
    4646         virtual void fromString(const StdString & str); 
    4747          
    48 //         virtual void toBinary  (StdOStream & os) const; 
    49 //         virtual void fromBinary(StdIStream & is); 
    5048 
    5149         virtual void parse(xml::CXMLNode & node); 
     
    6361         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0); 
    6462         void solveRefInheritance(void); 
    65 //         static bool has(const string & id);  
    66 //         static boost::shared_ptr<V> get(const string& id) ; 
    67 //         static boost::shared_ptr<V> create(const string& id=string("")) ; 
     63 
     64 
    6865         U* createChild(const string& id="") ; 
    6966           
  • XIOS/dev/branch_openmp/src/group_template_impl.hpp

    r1460 r1545  
    319319   { /* Ne rien faire de plus */ } 
    320320    
    321 //   template <class U, class V, class W> 
    322 //   bool CGroupTemplate<U, V, W>::has(const string& id)  
    323 //   { 
    324 //       return CObjectFactory::HasObject<V>(id) ; 
    325 //   } 
    326  
    327 //   template <class U, class V, class W> 
    328 //   boost::shared_ptr<V> CGroupTemplate<U, V, W>::get(const string& id)  
    329 //   { 
    330 //       return CObjectFactory::GetObject<V>(id) ; 
    331 //   } 
    332  
    333 //   template <class U, class V, class W> 
    334 //   boost::shared_ptr<V> CGroupTemplate<U, V, W>::get()  
    335 //   { 
    336 //       return CObjectFactory::GetObject<V>(this) ; 
    337 //   } 
    338     
    339 //   template <class U, class V, class W> 
    340 //   boost::shared_ptr<V> CGroupTemplate<U, V, W>::create(const string& id)  
    341 //   { 
    342 //       return CObjectFactory::CreateObject<V>(id) ; 
    343 //   } 
    344321   ///-------------------------------------------------------------- 
    345322 
  • XIOS/dev/branch_openmp/src/interface/c/icaxis.cpp

    r591 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77 
    88#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/iccalendar.cpp

    r704 r1545  
    2424    CTimer::get("XIOS").resume(); 
    2525    const xios::CContext* context = CContext::getCurrent(); 
    26     const boost::shared_ptr<xios::CCalendar> cal = context->getCalendar(); 
     26    const std::shared_ptr<xios::CCalendar> cal = context->getCalendar(); 
    2727    if (!cal) 
    2828      ERROR("void cxios_get_current_date(cxios_date* current_date_c)", 
     
    4141  { 
    4242    CTimer::get("XIOS").resume(); 
    43     const boost::shared_ptr<xios::CCalendar> cal = CContext::getCurrent()->getCalendar(); 
     43    const std::shared_ptr<xios::CCalendar> cal = CContext::getCurrent()->getCalendar(); 
    4444    if (!cal) 
    4545      ERROR("int cxios_get_year_length_in_seconds(int year)", 
     
    5454  { 
    5555    CTimer::get("XIOS").resume(); 
    56     const boost::shared_ptr<xios::CCalendar> cal = CContext::getCurrent()->getCalendar(); 
     56    const std::shared_ptr<xios::CCalendar> cal = CContext::getCurrent()->getCalendar(); 
    5757    if (!cal) 
    5858      ERROR("int cxios_get_day_length_in_seconds()", 
  • XIOS/dev/branch_openmp/src/interface/c/iccalendar_wrapper.cpp

    r591 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6 
     7#include <memory> 
    78 
    89#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/iccompute_connectivity_domain.cpp

    r934 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
    76 
    87#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/iccontext.cpp

    r591 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6 
     7#include <memory> 
    78 
    89#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icdata.cpp

    r1460 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include <string> 
    88#include <cstring> 
  • XIOS/dev/branch_openmp/src/interface/c/icdate.cpp

    r1482 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
    76 
    87#include "xios.hpp" 
     
    2726  if (!context) 
    2827    ERROR(idFunc, << "Impossible to do calendar operations: no current context available."); 
    29   const boost::shared_ptr<xios::CCalendar> cal = context->getCalendar(); 
     28  const std::shared_ptr<xios::CCalendar> cal = context->getCalendar(); 
    3029  if (!cal) 
    3130    ERROR(idFunc, << "Impossible to do calendar operations: no calendar was defined."); 
     
    8281                                   date_c.hour, date_c.minute, date_c.second); 
    8382    xios::CDuration dur( dur_c.year, dur_c.month, dur_c.day, dur_c.hour, dur_c.minute, dur_c.second, dur_c.timestep ); 
     83 
    8484    xios::CDate res = date - dur; 
    8585    return { res.getYear(), res.getMonth(), res.getDay(), res.getHour(), res.getMinute(), res.getSecond() }; 
  • XIOS/dev/branch_openmp/src/interface/c/icdomain.cpp

    r591 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6 
     7#include <memory> 
    78 
    89#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icduration.cpp

    r1482 r1545  
    88  { 
    99    xios::CDuration dur( dur_c.year, dur_c.month, dur_c.day, dur_c.hour, dur_c.minute, dur_c.second, dur_c.timestep ); 
     10 
    1011    if (!string_copy(dur.toString(), str, str_size)) 
    1112      ERROR("void cxios_duration_convert_to_string(cxios_duration dur_c, char* str, int str_size)", << "Input string is too short"); 
     
    2728    xios::CDuration dur1( dur1_c.year, dur1_c.month, dur1_c.day, dur1_c.hour, dur1_c.minute, dur1_c.second, dur1_c.timestep ); 
    2829    xios::CDuration dur2( dur2_c.year, dur2_c.month, dur2_c.day, dur2_c.hour, dur2_c.minute, dur2_c.second, dur2_c.timestep ); 
     30 
    2931    xios::CDuration res = dur1 + dur2; 
    3032    return { res.year, res.month, res.day, res.hour, res.minute, res.second, res.timestep }; 
     
    3537    xios::CDuration dur1( dur1_c.year, dur1_c.month, dur1_c.day, dur1_c.hour, dur1_c.minute, dur1_c.second, dur1_c.timestep ); 
    3638    xios::CDuration dur2( dur2_c.year, dur2_c.month, dur2_c.day, dur2_c.hour, dur2_c.minute, dur2_c.second, dur2_c.timestep ); 
     39 
    3740    xios::CDuration res = dur1 - dur2; 
    3841    return { res.year, res.month, res.day, res.hour, res.minute, res.second, res.timestep }; 
  • XIOS/dev/branch_openmp/src/interface/c/icexpand_domain.cpp

    r981 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6 
     7#include <memory> 
    78 
    89#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icextract_to_axis.cpp

    r981 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77 
    88#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icextract_to_scalar.cpp

    r981 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77 
    88#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icfield.cpp

    r1119 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6 
     7#include <memory> 
    78 
    89#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icfile.cpp

    r591 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77 
    88#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icgenerate_rectilinear_domain.cpp

    r786 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6 
     7#include <memory> 
    78 
    89#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icgrid.cpp

    r591 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
    76 
    87#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icinterpolate.cpp

    r786 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
    76 
    87#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icinverse_axis.cpp

    r786 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6 
     7#include <memory> 
    78 
    89#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icreduce_to_axis.cpp

    r981 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6 
     7#include <memory> 
    78 
    89#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icreduce_to_scalar.cpp

    r981 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
    76 
    87#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icscalar.cpp

    r891 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77 
    88#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icvariable.cpp

    r591 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6 
     7#include <memory> 
    78 
    89#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/icxml_tree.cpp

    r981 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77 
    88#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c/iczoom.cpp

    r786 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6 
     7#include <memory> 
    78 
    89#include "xios.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icaxis_attr.cpp

    r1052 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    4444 
    4545 
     46  void cxios_set_axis_axis_type(axis_Ptr axis_hdl, const char * axis_type, int axis_type_size) 
     47  { 
     48    std::string axis_type_str; 
     49    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return; 
     50    CTimer::get("XIOS").resume(); 
     51    axis_hdl->axis_type.fromString(axis_type_str); 
     52    CTimer::get("XIOS").suspend(); 
     53  } 
     54 
     55  void cxios_get_axis_axis_type(axis_Ptr axis_hdl, char * axis_type, int axis_type_size) 
     56  { 
     57    CTimer::get("XIOS").resume(); 
     58    if (!string_copy(axis_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size)) 
     59      ERROR("void cxios_get_axis_axis_type(axis_Ptr axis_hdl, char * axis_type, int axis_type_size)", << "Input string is too short"); 
     60    CTimer::get("XIOS").suspend(); 
     61  } 
     62 
     63  bool cxios_is_defined_axis_axis_type(axis_Ptr axis_hdl) 
     64  { 
     65     CTimer::get("XIOS").resume(); 
     66     bool isDefined = axis_hdl->axis_type.hasInheritedValue(); 
     67     CTimer::get("XIOS").suspend(); 
     68     return isDefined; 
     69  } 
     70 
     71 
    4672  void cxios_set_axis_begin(axis_Ptr axis_hdl, int begin) 
    4773  { 
     
    92118 
    93119 
     120  void cxios_set_axis_bounds_name(axis_Ptr axis_hdl, const char * bounds_name, int bounds_name_size) 
     121  { 
     122    std::string bounds_name_str; 
     123    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return; 
     124    CTimer::get("XIOS").resume(); 
     125    axis_hdl->bounds_name.setValue(bounds_name_str); 
     126    CTimer::get("XIOS").suspend(); 
     127  } 
     128 
     129  void cxios_get_axis_bounds_name(axis_Ptr axis_hdl, char * bounds_name, int bounds_name_size) 
     130  { 
     131    CTimer::get("XIOS").resume(); 
     132    if (!string_copy(axis_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size)) 
     133      ERROR("void cxios_get_axis_bounds_name(axis_Ptr axis_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short"); 
     134    CTimer::get("XIOS").suspend(); 
     135  } 
     136 
     137  bool cxios_is_defined_axis_bounds_name(axis_Ptr axis_hdl) 
     138  { 
     139     CTimer::get("XIOS").resume(); 
     140     bool isDefined = axis_hdl->bounds_name.hasInheritedValue(); 
     141     CTimer::get("XIOS").suspend(); 
     142     return isDefined; 
     143  } 
     144 
     145 
     146  void cxios_set_axis_comment(axis_Ptr axis_hdl, const char * comment, int comment_size) 
     147  { 
     148    std::string comment_str; 
     149    if (!cstr2string(comment, comment_size, comment_str)) return; 
     150    CTimer::get("XIOS").resume(); 
     151    axis_hdl->comment.setValue(comment_str); 
     152    CTimer::get("XIOS").suspend(); 
     153  } 
     154 
     155  void cxios_get_axis_comment(axis_Ptr axis_hdl, char * comment, int comment_size) 
     156  { 
     157    CTimer::get("XIOS").resume(); 
     158    if (!string_copy(axis_hdl->comment.getInheritedValue(), comment, comment_size)) 
     159      ERROR("void cxios_get_axis_comment(axis_Ptr axis_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     160    CTimer::get("XIOS").suspend(); 
     161  } 
     162 
     163  bool cxios_is_defined_axis_comment(axis_Ptr axis_hdl) 
     164  { 
     165     CTimer::get("XIOS").resume(); 
     166     bool isDefined = axis_hdl->comment.hasInheritedValue(); 
     167     CTimer::get("XIOS").suspend(); 
     168     return isDefined; 
     169  } 
     170 
     171 
    94172  void cxios_set_axis_data_begin(axis_Ptr axis_hdl, int data_begin) 
    95173  { 
     
    158236     CTimer::get("XIOS").resume(); 
    159237     bool isDefined = axis_hdl->data_n.hasInheritedValue(); 
     238     CTimer::get("XIOS").suspend(); 
     239     return isDefined; 
     240  } 
     241 
     242 
     243  void cxios_set_axis_dim_name(axis_Ptr axis_hdl, const char * dim_name, int dim_name_size) 
     244  { 
     245    std::string dim_name_str; 
     246    if (!cstr2string(dim_name, dim_name_size, dim_name_str)) return; 
     247    CTimer::get("XIOS").resume(); 
     248    axis_hdl->dim_name.setValue(dim_name_str); 
     249    CTimer::get("XIOS").suspend(); 
     250  } 
     251 
     252  void cxios_get_axis_dim_name(axis_Ptr axis_hdl, char * dim_name, int dim_name_size) 
     253  { 
     254    CTimer::get("XIOS").resume(); 
     255    if (!string_copy(axis_hdl->dim_name.getInheritedValue(), dim_name, dim_name_size)) 
     256      ERROR("void cxios_get_axis_dim_name(axis_Ptr axis_hdl, char * dim_name, int dim_name_size)", << "Input string is too short"); 
     257    CTimer::get("XIOS").suspend(); 
     258  } 
     259 
     260  bool cxios_is_defined_axis_dim_name(axis_Ptr axis_hdl) 
     261  { 
     262     CTimer::get("XIOS").resume(); 
     263     bool isDefined = axis_hdl->dim_name.hasInheritedValue(); 
     264     CTimer::get("XIOS").suspend(); 
     265     return isDefined; 
     266  } 
     267 
     268 
     269  void cxios_set_axis_formula(axis_Ptr axis_hdl, const char * formula, int formula_size) 
     270  { 
     271    std::string formula_str; 
     272    if (!cstr2string(formula, formula_size, formula_str)) return; 
     273    CTimer::get("XIOS").resume(); 
     274    axis_hdl->formula.setValue(formula_str); 
     275    CTimer::get("XIOS").suspend(); 
     276  } 
     277 
     278  void cxios_get_axis_formula(axis_Ptr axis_hdl, char * formula, int formula_size) 
     279  { 
     280    CTimer::get("XIOS").resume(); 
     281    if (!string_copy(axis_hdl->formula.getInheritedValue(), formula, formula_size)) 
     282      ERROR("void cxios_get_axis_formula(axis_Ptr axis_hdl, char * formula, int formula_size)", << "Input string is too short"); 
     283    CTimer::get("XIOS").suspend(); 
     284  } 
     285 
     286  bool cxios_is_defined_axis_formula(axis_Ptr axis_hdl) 
     287  { 
     288     CTimer::get("XIOS").resume(); 
     289     bool isDefined = axis_hdl->formula.hasInheritedValue(); 
     290     CTimer::get("XIOS").suspend(); 
     291     return isDefined; 
     292  } 
     293 
     294 
     295  void cxios_set_axis_formula_bounds(axis_Ptr axis_hdl, const char * formula_bounds, int formula_bounds_size) 
     296  { 
     297    std::string formula_bounds_str; 
     298    if (!cstr2string(formula_bounds, formula_bounds_size, formula_bounds_str)) return; 
     299    CTimer::get("XIOS").resume(); 
     300    axis_hdl->formula_bounds.setValue(formula_bounds_str); 
     301    CTimer::get("XIOS").suspend(); 
     302  } 
     303 
     304  void cxios_get_axis_formula_bounds(axis_Ptr axis_hdl, char * formula_bounds, int formula_bounds_size) 
     305  { 
     306    CTimer::get("XIOS").resume(); 
     307    if (!string_copy(axis_hdl->formula_bounds.getInheritedValue(), formula_bounds, formula_bounds_size)) 
     308      ERROR("void cxios_get_axis_formula_bounds(axis_Ptr axis_hdl, char * formula_bounds, int formula_bounds_size)", << "Input string is too short"); 
     309    CTimer::get("XIOS").suspend(); 
     310  } 
     311 
     312  bool cxios_is_defined_axis_formula_bounds(axis_Ptr axis_hdl) 
     313  { 
     314     CTimer::get("XIOS").resume(); 
     315     bool isDefined = axis_hdl->formula_bounds.hasInheritedValue(); 
     316     CTimer::get("XIOS").suspend(); 
     317     return isDefined; 
     318  } 
     319 
     320 
     321  void cxios_set_axis_formula_term(axis_Ptr axis_hdl, const char * formula_term, int formula_term_size) 
     322  { 
     323    std::string formula_term_str; 
     324    if (!cstr2string(formula_term, formula_term_size, formula_term_str)) return; 
     325    CTimer::get("XIOS").resume(); 
     326    axis_hdl->formula_term.setValue(formula_term_str); 
     327    CTimer::get("XIOS").suspend(); 
     328  } 
     329 
     330  void cxios_get_axis_formula_term(axis_Ptr axis_hdl, char * formula_term, int formula_term_size) 
     331  { 
     332    CTimer::get("XIOS").resume(); 
     333    if (!string_copy(axis_hdl->formula_term.getInheritedValue(), formula_term, formula_term_size)) 
     334      ERROR("void cxios_get_axis_formula_term(axis_Ptr axis_hdl, char * formula_term, int formula_term_size)", << "Input string is too short"); 
     335    CTimer::get("XIOS").suspend(); 
     336  } 
     337 
     338  bool cxios_is_defined_axis_formula_term(axis_Ptr axis_hdl) 
     339  { 
     340     CTimer::get("XIOS").resume(); 
     341     bool isDefined = axis_hdl->formula_term.hasInheritedValue(); 
     342     CTimer::get("XIOS").suspend(); 
     343     return isDefined; 
     344  } 
     345 
     346 
     347  void cxios_set_axis_formula_term_bounds(axis_Ptr axis_hdl, const char * formula_term_bounds, int formula_term_bounds_size) 
     348  { 
     349    std::string formula_term_bounds_str; 
     350    if (!cstr2string(formula_term_bounds, formula_term_bounds_size, formula_term_bounds_str)) return; 
     351    CTimer::get("XIOS").resume(); 
     352    axis_hdl->formula_term_bounds.setValue(formula_term_bounds_str); 
     353    CTimer::get("XIOS").suspend(); 
     354  } 
     355 
     356  void cxios_get_axis_formula_term_bounds(axis_Ptr axis_hdl, char * formula_term_bounds, int formula_term_bounds_size) 
     357  { 
     358    CTimer::get("XIOS").resume(); 
     359    if (!string_copy(axis_hdl->formula_term_bounds.getInheritedValue(), formula_term_bounds, formula_term_bounds_size)) 
     360      ERROR("void cxios_get_axis_formula_term_bounds(axis_Ptr axis_hdl, char * formula_term_bounds, int formula_term_bounds_size)", << "Input string is too short"); 
     361    CTimer::get("XIOS").suspend(); 
     362  } 
     363 
     364  bool cxios_is_defined_axis_formula_term_bounds(axis_Ptr axis_hdl) 
     365  { 
     366     CTimer::get("XIOS").resume(); 
     367     bool isDefined = axis_hdl->formula_term_bounds.hasInheritedValue(); 
    160368     CTimer::get("XIOS").suspend(); 
    161369     return isDefined; 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icaxisgroup_attr.cpp

    r1052 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    4444 
    4545 
     46  void cxios_set_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl, const char * axis_type, int axis_type_size) 
     47  { 
     48    std::string axis_type_str; 
     49    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return; 
     50    CTimer::get("XIOS").resume(); 
     51    axisgroup_hdl->axis_type.fromString(axis_type_str); 
     52    CTimer::get("XIOS").suspend(); 
     53  } 
     54 
     55  void cxios_get_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl, char * axis_type, int axis_type_size) 
     56  { 
     57    CTimer::get("XIOS").resume(); 
     58    if (!string_copy(axisgroup_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size)) 
     59      ERROR("void cxios_get_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl, char * axis_type, int axis_type_size)", << "Input string is too short"); 
     60    CTimer::get("XIOS").suspend(); 
     61  } 
     62 
     63  bool cxios_is_defined_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl) 
     64  { 
     65     CTimer::get("XIOS").resume(); 
     66     bool isDefined = axisgroup_hdl->axis_type.hasInheritedValue(); 
     67     CTimer::get("XIOS").suspend(); 
     68     return isDefined; 
     69  } 
     70 
     71 
    4672  void cxios_set_axisgroup_begin(axisgroup_Ptr axisgroup_hdl, int begin) 
    4773  { 
     
    92118 
    93119 
     120  void cxios_set_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl, const char * bounds_name, int bounds_name_size) 
     121  { 
     122    std::string bounds_name_str; 
     123    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return; 
     124    CTimer::get("XIOS").resume(); 
     125    axisgroup_hdl->bounds_name.setValue(bounds_name_str); 
     126    CTimer::get("XIOS").suspend(); 
     127  } 
     128 
     129  void cxios_get_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl, char * bounds_name, int bounds_name_size) 
     130  { 
     131    CTimer::get("XIOS").resume(); 
     132    if (!string_copy(axisgroup_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size)) 
     133      ERROR("void cxios_get_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short"); 
     134    CTimer::get("XIOS").suspend(); 
     135  } 
     136 
     137  bool cxios_is_defined_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl) 
     138  { 
     139     CTimer::get("XIOS").resume(); 
     140     bool isDefined = axisgroup_hdl->bounds_name.hasInheritedValue(); 
     141     CTimer::get("XIOS").suspend(); 
     142     return isDefined; 
     143  } 
     144 
     145 
     146  void cxios_set_axisgroup_comment(axisgroup_Ptr axisgroup_hdl, const char * comment, int comment_size) 
     147  { 
     148    std::string comment_str; 
     149    if (!cstr2string(comment, comment_size, comment_str)) return; 
     150    CTimer::get("XIOS").resume(); 
     151    axisgroup_hdl->comment.setValue(comment_str); 
     152    CTimer::get("XIOS").suspend(); 
     153  } 
     154 
     155  void cxios_get_axisgroup_comment(axisgroup_Ptr axisgroup_hdl, char * comment, int comment_size) 
     156  { 
     157    CTimer::get("XIOS").resume(); 
     158    if (!string_copy(axisgroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     159      ERROR("void cxios_get_axisgroup_comment(axisgroup_Ptr axisgroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     160    CTimer::get("XIOS").suspend(); 
     161  } 
     162 
     163  bool cxios_is_defined_axisgroup_comment(axisgroup_Ptr axisgroup_hdl) 
     164  { 
     165     CTimer::get("XIOS").resume(); 
     166     bool isDefined = axisgroup_hdl->comment.hasInheritedValue(); 
     167     CTimer::get("XIOS").suspend(); 
     168     return isDefined; 
     169  } 
     170 
     171 
    94172  void cxios_set_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl, int data_begin) 
    95173  { 
     
    158236     CTimer::get("XIOS").resume(); 
    159237     bool isDefined = axisgroup_hdl->data_n.hasInheritedValue(); 
     238     CTimer::get("XIOS").suspend(); 
     239     return isDefined; 
     240  } 
     241 
     242 
     243  void cxios_set_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl, const char * dim_name, int dim_name_size) 
     244  { 
     245    std::string dim_name_str; 
     246    if (!cstr2string(dim_name, dim_name_size, dim_name_str)) return; 
     247    CTimer::get("XIOS").resume(); 
     248    axisgroup_hdl->dim_name.setValue(dim_name_str); 
     249    CTimer::get("XIOS").suspend(); 
     250  } 
     251 
     252  void cxios_get_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl, char * dim_name, int dim_name_size) 
     253  { 
     254    CTimer::get("XIOS").resume(); 
     255    if (!string_copy(axisgroup_hdl->dim_name.getInheritedValue(), dim_name, dim_name_size)) 
     256      ERROR("void cxios_get_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl, char * dim_name, int dim_name_size)", << "Input string is too short"); 
     257    CTimer::get("XIOS").suspend(); 
     258  } 
     259 
     260  bool cxios_is_defined_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl) 
     261  { 
     262     CTimer::get("XIOS").resume(); 
     263     bool isDefined = axisgroup_hdl->dim_name.hasInheritedValue(); 
     264     CTimer::get("XIOS").suspend(); 
     265     return isDefined; 
     266  } 
     267 
     268 
     269  void cxios_set_axisgroup_formula(axisgroup_Ptr axisgroup_hdl, const char * formula, int formula_size) 
     270  { 
     271    std::string formula_str; 
     272    if (!cstr2string(formula, formula_size, formula_str)) return; 
     273    CTimer::get("XIOS").resume(); 
     274    axisgroup_hdl->formula.setValue(formula_str); 
     275    CTimer::get("XIOS").suspend(); 
     276  } 
     277 
     278  void cxios_get_axisgroup_formula(axisgroup_Ptr axisgroup_hdl, char * formula, int formula_size) 
     279  { 
     280    CTimer::get("XIOS").resume(); 
     281    if (!string_copy(axisgroup_hdl->formula.getInheritedValue(), formula, formula_size)) 
     282      ERROR("void cxios_get_axisgroup_formula(axisgroup_Ptr axisgroup_hdl, char * formula, int formula_size)", << "Input string is too short"); 
     283    CTimer::get("XIOS").suspend(); 
     284  } 
     285 
     286  bool cxios_is_defined_axisgroup_formula(axisgroup_Ptr axisgroup_hdl) 
     287  { 
     288     CTimer::get("XIOS").resume(); 
     289     bool isDefined = axisgroup_hdl->formula.hasInheritedValue(); 
     290     CTimer::get("XIOS").suspend(); 
     291     return isDefined; 
     292  } 
     293 
     294 
     295  void cxios_set_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl, const char * formula_bounds, int formula_bounds_size) 
     296  { 
     297    std::string formula_bounds_str; 
     298    if (!cstr2string(formula_bounds, formula_bounds_size, formula_bounds_str)) return; 
     299    CTimer::get("XIOS").resume(); 
     300    axisgroup_hdl->formula_bounds.setValue(formula_bounds_str); 
     301    CTimer::get("XIOS").suspend(); 
     302  } 
     303 
     304  void cxios_get_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_bounds, int formula_bounds_size) 
     305  { 
     306    CTimer::get("XIOS").resume(); 
     307    if (!string_copy(axisgroup_hdl->formula_bounds.getInheritedValue(), formula_bounds, formula_bounds_size)) 
     308      ERROR("void cxios_get_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_bounds, int formula_bounds_size)", << "Input string is too short"); 
     309    CTimer::get("XIOS").suspend(); 
     310  } 
     311 
     312  bool cxios_is_defined_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl) 
     313  { 
     314     CTimer::get("XIOS").resume(); 
     315     bool isDefined = axisgroup_hdl->formula_bounds.hasInheritedValue(); 
     316     CTimer::get("XIOS").suspend(); 
     317     return isDefined; 
     318  } 
     319 
     320 
     321  void cxios_set_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl, const char * formula_term, int formula_term_size) 
     322  { 
     323    std::string formula_term_str; 
     324    if (!cstr2string(formula_term, formula_term_size, formula_term_str)) return; 
     325    CTimer::get("XIOS").resume(); 
     326    axisgroup_hdl->formula_term.setValue(formula_term_str); 
     327    CTimer::get("XIOS").suspend(); 
     328  } 
     329 
     330  void cxios_get_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl, char * formula_term, int formula_term_size) 
     331  { 
     332    CTimer::get("XIOS").resume(); 
     333    if (!string_copy(axisgroup_hdl->formula_term.getInheritedValue(), formula_term, formula_term_size)) 
     334      ERROR("void cxios_get_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl, char * formula_term, int formula_term_size)", << "Input string is too short"); 
     335    CTimer::get("XIOS").suspend(); 
     336  } 
     337 
     338  bool cxios_is_defined_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl) 
     339  { 
     340     CTimer::get("XIOS").resume(); 
     341     bool isDefined = axisgroup_hdl->formula_term.hasInheritedValue(); 
     342     CTimer::get("XIOS").suspend(); 
     343     return isDefined; 
     344  } 
     345 
     346 
     347  void cxios_set_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl, const char * formula_term_bounds, int formula_term_bounds_size) 
     348  { 
     349    std::string formula_term_bounds_str; 
     350    if (!cstr2string(formula_term_bounds, formula_term_bounds_size, formula_term_bounds_str)) return; 
     351    CTimer::get("XIOS").resume(); 
     352    axisgroup_hdl->formula_term_bounds.setValue(formula_term_bounds_str); 
     353    CTimer::get("XIOS").suspend(); 
     354  } 
     355 
     356  void cxios_get_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_term_bounds, int formula_term_bounds_size) 
     357  { 
     358    CTimer::get("XIOS").resume(); 
     359    if (!string_copy(axisgroup_hdl->formula_term_bounds.getInheritedValue(), formula_term_bounds, formula_term_bounds_size)) 
     360      ERROR("void cxios_get_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_term_bounds, int formula_term_bounds_size)", << "Input string is too short"); 
     361    CTimer::get("XIOS").suspend(); 
     362  } 
     363 
     364  bool cxios_is_defined_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl) 
     365  { 
     366     CTimer::get("XIOS").resume(); 
     367     bool isDefined = axisgroup_hdl->formula_term_bounds.hasInheritedValue(); 
    160368     CTimer::get("XIOS").suspend(); 
    161369     return isDefined; 
  • XIOS/dev/branch_openmp/src/interface/c_attr/iccalendar_wrapper_attr.cpp

    r674 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    1717{ 
    1818  typedef xios::CCalendarWrapper* calendar_wrapper_Ptr; 
     19 
     20  void cxios_set_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl, const char * comment, int comment_size) 
     21  { 
     22    std::string comment_str; 
     23    if (!cstr2string(comment, comment_size, comment_str)) return; 
     24    CTimer::get("XIOS").resume(); 
     25    calendar_wrapper_hdl->comment.setValue(comment_str); 
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
     29  void cxios_get_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl, char * comment, int comment_size) 
     30  { 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(calendar_wrapper_hdl->comment.getInheritedValue(), comment, comment_size)) 
     33      ERROR("void cxios_get_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = calendar_wrapper_hdl->comment.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
    1945 
    2046  void cxios_set_calendar_wrapper_day_length(calendar_wrapper_Ptr calendar_wrapper_hdl, int day_length) 
  • XIOS/dev/branch_openmp/src/interface/c_attr/iccompute_connectivity_domain_attr.cpp

    r934 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/iccontext_attr.cpp

    r591 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icdomain_attr.cpp

    r1052 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    9393 
    9494 
     95  void cxios_set_domain_bounds_lat_name(domain_Ptr domain_hdl, const char * bounds_lat_name, int bounds_lat_name_size) 
     96  { 
     97    std::string bounds_lat_name_str; 
     98    if (!cstr2string(bounds_lat_name, bounds_lat_name_size, bounds_lat_name_str)) return; 
     99    CTimer::get("XIOS").resume(); 
     100    domain_hdl->bounds_lat_name.setValue(bounds_lat_name_str); 
     101    CTimer::get("XIOS").suspend(); 
     102  } 
     103 
     104  void cxios_get_domain_bounds_lat_name(domain_Ptr domain_hdl, char * bounds_lat_name, int bounds_lat_name_size) 
     105  { 
     106    CTimer::get("XIOS").resume(); 
     107    if (!string_copy(domain_hdl->bounds_lat_name.getInheritedValue(), bounds_lat_name, bounds_lat_name_size)) 
     108      ERROR("void cxios_get_domain_bounds_lat_name(domain_Ptr domain_hdl, char * bounds_lat_name, int bounds_lat_name_size)", << "Input string is too short"); 
     109    CTimer::get("XIOS").suspend(); 
     110  } 
     111 
     112  bool cxios_is_defined_domain_bounds_lat_name(domain_Ptr domain_hdl) 
     113  { 
     114     CTimer::get("XIOS").resume(); 
     115     bool isDefined = domain_hdl->bounds_lat_name.hasInheritedValue(); 
     116     CTimer::get("XIOS").suspend(); 
     117     return isDefined; 
     118  } 
     119 
     120 
    95121  void cxios_set_domain_bounds_lon_1d(domain_Ptr domain_hdl, double* bounds_lon_1d, int* extent) 
    96122  { 
     
    143169 
    144170 
     171  void cxios_set_domain_bounds_lon_name(domain_Ptr domain_hdl, const char * bounds_lon_name, int bounds_lon_name_size) 
     172  { 
     173    std::string bounds_lon_name_str; 
     174    if (!cstr2string(bounds_lon_name, bounds_lon_name_size, bounds_lon_name_str)) return; 
     175    CTimer::get("XIOS").resume(); 
     176    domain_hdl->bounds_lon_name.setValue(bounds_lon_name_str); 
     177    CTimer::get("XIOS").suspend(); 
     178  } 
     179 
     180  void cxios_get_domain_bounds_lon_name(domain_Ptr domain_hdl, char * bounds_lon_name, int bounds_lon_name_size) 
     181  { 
     182    CTimer::get("XIOS").resume(); 
     183    if (!string_copy(domain_hdl->bounds_lon_name.getInheritedValue(), bounds_lon_name, bounds_lon_name_size)) 
     184      ERROR("void cxios_get_domain_bounds_lon_name(domain_Ptr domain_hdl, char * bounds_lon_name, int bounds_lon_name_size)", << "Input string is too short"); 
     185    CTimer::get("XIOS").suspend(); 
     186  } 
     187 
     188  bool cxios_is_defined_domain_bounds_lon_name(domain_Ptr domain_hdl) 
     189  { 
     190     CTimer::get("XIOS").resume(); 
     191     bool isDefined = domain_hdl->bounds_lon_name.hasInheritedValue(); 
     192     CTimer::get("XIOS").suspend(); 
     193     return isDefined; 
     194  } 
     195 
     196 
     197  void cxios_set_domain_comment(domain_Ptr domain_hdl, const char * comment, int comment_size) 
     198  { 
     199    std::string comment_str; 
     200    if (!cstr2string(comment, comment_size, comment_str)) return; 
     201    CTimer::get("XIOS").resume(); 
     202    domain_hdl->comment.setValue(comment_str); 
     203    CTimer::get("XIOS").suspend(); 
     204  } 
     205 
     206  void cxios_get_domain_comment(domain_Ptr domain_hdl, char * comment, int comment_size) 
     207  { 
     208    CTimer::get("XIOS").resume(); 
     209    if (!string_copy(domain_hdl->comment.getInheritedValue(), comment, comment_size)) 
     210      ERROR("void cxios_get_domain_comment(domain_Ptr domain_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     211    CTimer::get("XIOS").suspend(); 
     212  } 
     213 
     214  bool cxios_is_defined_domain_comment(domain_Ptr domain_hdl) 
     215  { 
     216     CTimer::get("XIOS").resume(); 
     217     bool isDefined = domain_hdl->comment.hasInheritedValue(); 
     218     CTimer::get("XIOS").suspend(); 
     219     return isDefined; 
     220  } 
     221 
     222 
    145223  void cxios_set_domain_data_dim(domain_Ptr domain_hdl, int data_dim) 
    146224  { 
     
    308386 
    309387 
     388  void cxios_set_domain_dim_i_name(domain_Ptr domain_hdl, const char * dim_i_name, int dim_i_name_size) 
     389  { 
     390    std::string dim_i_name_str; 
     391    if (!cstr2string(dim_i_name, dim_i_name_size, dim_i_name_str)) return; 
     392    CTimer::get("XIOS").resume(); 
     393    domain_hdl->dim_i_name.setValue(dim_i_name_str); 
     394    CTimer::get("XIOS").suspend(); 
     395  } 
     396 
     397  void cxios_get_domain_dim_i_name(domain_Ptr domain_hdl, char * dim_i_name, int dim_i_name_size) 
     398  { 
     399    CTimer::get("XIOS").resume(); 
     400    if (!string_copy(domain_hdl->dim_i_name.getInheritedValue(), dim_i_name, dim_i_name_size)) 
     401      ERROR("void cxios_get_domain_dim_i_name(domain_Ptr domain_hdl, char * dim_i_name, int dim_i_name_size)", << "Input string is too short"); 
     402    CTimer::get("XIOS").suspend(); 
     403  } 
     404 
     405  bool cxios_is_defined_domain_dim_i_name(domain_Ptr domain_hdl) 
     406  { 
     407     CTimer::get("XIOS").resume(); 
     408     bool isDefined = domain_hdl->dim_i_name.hasInheritedValue(); 
     409     CTimer::get("XIOS").suspend(); 
     410     return isDefined; 
     411  } 
     412 
     413 
     414  void cxios_set_domain_dim_j_name(domain_Ptr domain_hdl, const char * dim_j_name, int dim_j_name_size) 
     415  { 
     416    std::string dim_j_name_str; 
     417    if (!cstr2string(dim_j_name, dim_j_name_size, dim_j_name_str)) return; 
     418    CTimer::get("XIOS").resume(); 
     419    domain_hdl->dim_j_name.setValue(dim_j_name_str); 
     420    CTimer::get("XIOS").suspend(); 
     421  } 
     422 
     423  void cxios_get_domain_dim_j_name(domain_Ptr domain_hdl, char * dim_j_name, int dim_j_name_size) 
     424  { 
     425    CTimer::get("XIOS").resume(); 
     426    if (!string_copy(domain_hdl->dim_j_name.getInheritedValue(), dim_j_name, dim_j_name_size)) 
     427      ERROR("void cxios_get_domain_dim_j_name(domain_Ptr domain_hdl, char * dim_j_name, int dim_j_name_size)", << "Input string is too short"); 
     428    CTimer::get("XIOS").suspend(); 
     429  } 
     430 
     431  bool cxios_is_defined_domain_dim_j_name(domain_Ptr domain_hdl) 
     432  { 
     433     CTimer::get("XIOS").resume(); 
     434     bool isDefined = domain_hdl->dim_j_name.hasInheritedValue(); 
     435     CTimer::get("XIOS").suspend(); 
     436     return isDefined; 
     437  } 
     438 
     439 
    310440  void cxios_set_domain_domain_ref(domain_Ptr domain_hdl, const char * domain_ref, int domain_ref_size) 
    311441  { 
     
    430560 
    431561 
     562  void cxios_set_domain_lat_name(domain_Ptr domain_hdl, const char * lat_name, int lat_name_size) 
     563  { 
     564    std::string lat_name_str; 
     565    if (!cstr2string(lat_name, lat_name_size, lat_name_str)) return; 
     566    CTimer::get("XIOS").resume(); 
     567    domain_hdl->lat_name.setValue(lat_name_str); 
     568    CTimer::get("XIOS").suspend(); 
     569  } 
     570 
     571  void cxios_get_domain_lat_name(domain_Ptr domain_hdl, char * lat_name, int lat_name_size) 
     572  { 
     573    CTimer::get("XIOS").resume(); 
     574    if (!string_copy(domain_hdl->lat_name.getInheritedValue(), lat_name, lat_name_size)) 
     575      ERROR("void cxios_get_domain_lat_name(domain_Ptr domain_hdl, char * lat_name, int lat_name_size)", << "Input string is too short"); 
     576    CTimer::get("XIOS").suspend(); 
     577  } 
     578 
     579  bool cxios_is_defined_domain_lat_name(domain_Ptr domain_hdl) 
     580  { 
     581     CTimer::get("XIOS").resume(); 
     582     bool isDefined = domain_hdl->lat_name.hasInheritedValue(); 
     583     CTimer::get("XIOS").suspend(); 
     584     return isDefined; 
     585  } 
     586 
     587 
    432588  void cxios_set_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int* extent) 
    433589  { 
     
    480636 
    481637 
     638  void cxios_set_domain_lon_name(domain_Ptr domain_hdl, const char * lon_name, int lon_name_size) 
     639  { 
     640    std::string lon_name_str; 
     641    if (!cstr2string(lon_name, lon_name_size, lon_name_str)) return; 
     642    CTimer::get("XIOS").resume(); 
     643    domain_hdl->lon_name.setValue(lon_name_str); 
     644    CTimer::get("XIOS").suspend(); 
     645  } 
     646 
     647  void cxios_get_domain_lon_name(domain_Ptr domain_hdl, char * lon_name, int lon_name_size) 
     648  { 
     649    CTimer::get("XIOS").resume(); 
     650    if (!string_copy(domain_hdl->lon_name.getInheritedValue(), lon_name, lon_name_size)) 
     651      ERROR("void cxios_get_domain_lon_name(domain_Ptr domain_hdl, char * lon_name, int lon_name_size)", << "Input string is too short"); 
     652    CTimer::get("XIOS").suspend(); 
     653  } 
     654 
     655  bool cxios_is_defined_domain_lon_name(domain_Ptr domain_hdl) 
     656  { 
     657     CTimer::get("XIOS").resume(); 
     658     bool isDefined = domain_hdl->lon_name.hasInheritedValue(); 
     659     CTimer::get("XIOS").suspend(); 
     660     return isDefined; 
     661  } 
     662 
     663 
    482664  void cxios_set_domain_long_name(domain_Ptr domain_hdl, const char * long_name, int long_name_size) 
    483665  { 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icdomaingroup_attr.cpp

    r1052 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    9393 
    9494 
     95  void cxios_set_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl, const char * bounds_lat_name, int bounds_lat_name_size) 
     96  { 
     97    std::string bounds_lat_name_str; 
     98    if (!cstr2string(bounds_lat_name, bounds_lat_name_size, bounds_lat_name_str)) return; 
     99    CTimer::get("XIOS").resume(); 
     100    domaingroup_hdl->bounds_lat_name.setValue(bounds_lat_name_str); 
     101    CTimer::get("XIOS").suspend(); 
     102  } 
     103 
     104  void cxios_get_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lat_name, int bounds_lat_name_size) 
     105  { 
     106    CTimer::get("XIOS").resume(); 
     107    if (!string_copy(domaingroup_hdl->bounds_lat_name.getInheritedValue(), bounds_lat_name, bounds_lat_name_size)) 
     108      ERROR("void cxios_get_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lat_name, int bounds_lat_name_size)", << "Input string is too short"); 
     109    CTimer::get("XIOS").suspend(); 
     110  } 
     111 
     112  bool cxios_is_defined_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl) 
     113  { 
     114     CTimer::get("XIOS").resume(); 
     115     bool isDefined = domaingroup_hdl->bounds_lat_name.hasInheritedValue(); 
     116     CTimer::get("XIOS").suspend(); 
     117     return isDefined; 
     118  } 
     119 
     120 
    95121  void cxios_set_domaingroup_bounds_lon_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lon_1d, int* extent) 
    96122  { 
     
    143169 
    144170 
     171  void cxios_set_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl, const char * bounds_lon_name, int bounds_lon_name_size) 
     172  { 
     173    std::string bounds_lon_name_str; 
     174    if (!cstr2string(bounds_lon_name, bounds_lon_name_size, bounds_lon_name_str)) return; 
     175    CTimer::get("XIOS").resume(); 
     176    domaingroup_hdl->bounds_lon_name.setValue(bounds_lon_name_str); 
     177    CTimer::get("XIOS").suspend(); 
     178  } 
     179 
     180  void cxios_get_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lon_name, int bounds_lon_name_size) 
     181  { 
     182    CTimer::get("XIOS").resume(); 
     183    if (!string_copy(domaingroup_hdl->bounds_lon_name.getInheritedValue(), bounds_lon_name, bounds_lon_name_size)) 
     184      ERROR("void cxios_get_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lon_name, int bounds_lon_name_size)", << "Input string is too short"); 
     185    CTimer::get("XIOS").suspend(); 
     186  } 
     187 
     188  bool cxios_is_defined_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl) 
     189  { 
     190     CTimer::get("XIOS").resume(); 
     191     bool isDefined = domaingroup_hdl->bounds_lon_name.hasInheritedValue(); 
     192     CTimer::get("XIOS").suspend(); 
     193     return isDefined; 
     194  } 
     195 
     196 
     197  void cxios_set_domaingroup_comment(domaingroup_Ptr domaingroup_hdl, const char * comment, int comment_size) 
     198  { 
     199    std::string comment_str; 
     200    if (!cstr2string(comment, comment_size, comment_str)) return; 
     201    CTimer::get("XIOS").resume(); 
     202    domaingroup_hdl->comment.setValue(comment_str); 
     203    CTimer::get("XIOS").suspend(); 
     204  } 
     205 
     206  void cxios_get_domaingroup_comment(domaingroup_Ptr domaingroup_hdl, char * comment, int comment_size) 
     207  { 
     208    CTimer::get("XIOS").resume(); 
     209    if (!string_copy(domaingroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     210      ERROR("void cxios_get_domaingroup_comment(domaingroup_Ptr domaingroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     211    CTimer::get("XIOS").suspend(); 
     212  } 
     213 
     214  bool cxios_is_defined_domaingroup_comment(domaingroup_Ptr domaingroup_hdl) 
     215  { 
     216     CTimer::get("XIOS").resume(); 
     217     bool isDefined = domaingroup_hdl->comment.hasInheritedValue(); 
     218     CTimer::get("XIOS").suspend(); 
     219     return isDefined; 
     220  } 
     221 
     222 
    145223  void cxios_set_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int data_dim) 
    146224  { 
     
    308386 
    309387 
     388  void cxios_set_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl, const char * dim_i_name, int dim_i_name_size) 
     389  { 
     390    std::string dim_i_name_str; 
     391    if (!cstr2string(dim_i_name, dim_i_name_size, dim_i_name_str)) return; 
     392    CTimer::get("XIOS").resume(); 
     393    domaingroup_hdl->dim_i_name.setValue(dim_i_name_str); 
     394    CTimer::get("XIOS").suspend(); 
     395  } 
     396 
     397  void cxios_get_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl, char * dim_i_name, int dim_i_name_size) 
     398  { 
     399    CTimer::get("XIOS").resume(); 
     400    if (!string_copy(domaingroup_hdl->dim_i_name.getInheritedValue(), dim_i_name, dim_i_name_size)) 
     401      ERROR("void cxios_get_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl, char * dim_i_name, int dim_i_name_size)", << "Input string is too short"); 
     402    CTimer::get("XIOS").suspend(); 
     403  } 
     404 
     405  bool cxios_is_defined_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl) 
     406  { 
     407     CTimer::get("XIOS").resume(); 
     408     bool isDefined = domaingroup_hdl->dim_i_name.hasInheritedValue(); 
     409     CTimer::get("XIOS").suspend(); 
     410     return isDefined; 
     411  } 
     412 
     413 
     414  void cxios_set_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl, const char * dim_j_name, int dim_j_name_size) 
     415  { 
     416    std::string dim_j_name_str; 
     417    if (!cstr2string(dim_j_name, dim_j_name_size, dim_j_name_str)) return; 
     418    CTimer::get("XIOS").resume(); 
     419    domaingroup_hdl->dim_j_name.setValue(dim_j_name_str); 
     420    CTimer::get("XIOS").suspend(); 
     421  } 
     422 
     423  void cxios_get_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl, char * dim_j_name, int dim_j_name_size) 
     424  { 
     425    CTimer::get("XIOS").resume(); 
     426    if (!string_copy(domaingroup_hdl->dim_j_name.getInheritedValue(), dim_j_name, dim_j_name_size)) 
     427      ERROR("void cxios_get_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl, char * dim_j_name, int dim_j_name_size)", << "Input string is too short"); 
     428    CTimer::get("XIOS").suspend(); 
     429  } 
     430 
     431  bool cxios_is_defined_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl) 
     432  { 
     433     CTimer::get("XIOS").resume(); 
     434     bool isDefined = domaingroup_hdl->dim_j_name.hasInheritedValue(); 
     435     CTimer::get("XIOS").suspend(); 
     436     return isDefined; 
     437  } 
     438 
     439 
    310440  void cxios_set_domaingroup_domain_ref(domaingroup_Ptr domaingroup_hdl, const char * domain_ref, int domain_ref_size) 
    311441  { 
     
    456586 
    457587 
     588  void cxios_set_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl, const char * lat_name, int lat_name_size) 
     589  { 
     590    std::string lat_name_str; 
     591    if (!cstr2string(lat_name, lat_name_size, lat_name_str)) return; 
     592    CTimer::get("XIOS").resume(); 
     593    domaingroup_hdl->lat_name.setValue(lat_name_str); 
     594    CTimer::get("XIOS").suspend(); 
     595  } 
     596 
     597  void cxios_get_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl, char * lat_name, int lat_name_size) 
     598  { 
     599    CTimer::get("XIOS").resume(); 
     600    if (!string_copy(domaingroup_hdl->lat_name.getInheritedValue(), lat_name, lat_name_size)) 
     601      ERROR("void cxios_get_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl, char * lat_name, int lat_name_size)", << "Input string is too short"); 
     602    CTimer::get("XIOS").suspend(); 
     603  } 
     604 
     605  bool cxios_is_defined_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl) 
     606  { 
     607     CTimer::get("XIOS").resume(); 
     608     bool isDefined = domaingroup_hdl->lat_name.hasInheritedValue(); 
     609     CTimer::get("XIOS").suspend(); 
     610     return isDefined; 
     611  } 
     612 
     613 
    458614  void cxios_set_domaingroup_latvalue_1d(domaingroup_Ptr domaingroup_hdl, double* latvalue_1d, int* extent) 
    459615  { 
     
    506662 
    507663 
     664  void cxios_set_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl, const char * lon_name, int lon_name_size) 
     665  { 
     666    std::string lon_name_str; 
     667    if (!cstr2string(lon_name, lon_name_size, lon_name_str)) return; 
     668    CTimer::get("XIOS").resume(); 
     669    domaingroup_hdl->lon_name.setValue(lon_name_str); 
     670    CTimer::get("XIOS").suspend(); 
     671  } 
     672 
     673  void cxios_get_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl, char * lon_name, int lon_name_size) 
     674  { 
     675    CTimer::get("XIOS").resume(); 
     676    if (!string_copy(domaingroup_hdl->lon_name.getInheritedValue(), lon_name, lon_name_size)) 
     677      ERROR("void cxios_get_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl, char * lon_name, int lon_name_size)", << "Input string is too short"); 
     678    CTimer::get("XIOS").suspend(); 
     679  } 
     680 
     681  bool cxios_is_defined_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl) 
     682  { 
     683     CTimer::get("XIOS").resume(); 
     684     bool isDefined = domaingroup_hdl->lon_name.hasInheritedValue(); 
     685     CTimer::get("XIOS").suspend(); 
     686     return isDefined; 
     687  } 
     688 
     689 
    508690  void cxios_set_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, const char * long_name, int long_name_size) 
    509691  { 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icexpand_domain_attr.cpp

    r1078 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icextract_axis_to_scalar_attr.cpp

    r981 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icextract_domain_to_axis_attr.cpp

    r981 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icfield_attr.cpp

    r1205 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    137137     CTimer::get("XIOS").resume(); 
    138138     bool isDefined = field_hdl->check_if_active.hasInheritedValue(); 
     139     CTimer::get("XIOS").suspend(); 
     140     return isDefined; 
     141  } 
     142 
     143 
     144  void cxios_set_field_comment(field_Ptr field_hdl, const char * comment, int comment_size) 
     145  { 
     146    std::string comment_str; 
     147    if (!cstr2string(comment, comment_size, comment_str)) return; 
     148    CTimer::get("XIOS").resume(); 
     149    field_hdl->comment.setValue(comment_str); 
     150    CTimer::get("XIOS").suspend(); 
     151  } 
     152 
     153  void cxios_get_field_comment(field_Ptr field_hdl, char * comment, int comment_size) 
     154  { 
     155    CTimer::get("XIOS").resume(); 
     156    if (!string_copy(field_hdl->comment.getInheritedValue(), comment, comment_size)) 
     157      ERROR("void cxios_get_field_comment(field_Ptr field_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     158    CTimer::get("XIOS").suspend(); 
     159  } 
     160 
     161  bool cxios_is_defined_field_comment(field_Ptr field_hdl) 
     162  { 
     163     CTimer::get("XIOS").resume(); 
     164     bool isDefined = field_hdl->comment.hasInheritedValue(); 
    139165     CTimer::get("XIOS").suspend(); 
    140166     return isDefined; 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icfieldgroup_attr.cpp

    r1205 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    137137     CTimer::get("XIOS").resume(); 
    138138     bool isDefined = fieldgroup_hdl->check_if_active.hasInheritedValue(); 
     139     CTimer::get("XIOS").suspend(); 
     140     return isDefined; 
     141  } 
     142 
     143 
     144  void cxios_set_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, const char * comment, int comment_size) 
     145  { 
     146    std::string comment_str; 
     147    if (!cstr2string(comment, comment_size, comment_str)) return; 
     148    CTimer::get("XIOS").resume(); 
     149    fieldgroup_hdl->comment.setValue(comment_str); 
     150    CTimer::get("XIOS").suspend(); 
     151  } 
     152 
     153  void cxios_get_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, char * comment, int comment_size) 
     154  { 
     155    CTimer::get("XIOS").resume(); 
     156    if (!string_copy(fieldgroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     157      ERROR("void cxios_get_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     158    CTimer::get("XIOS").suspend(); 
     159  } 
     160 
     161  bool cxios_is_defined_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl) 
     162  { 
     163     CTimer::get("XIOS").resume(); 
     164     bool isDefined = fieldgroup_hdl->comment.hasInheritedValue(); 
    139165     CTimer::get("XIOS").suspend(); 
    140166     return isDefined; 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icfile_attr.cpp

    r1205 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    3636     CTimer::get("XIOS").resume(); 
    3737     bool isDefined = file_hdl->append.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
     42 
     43  void cxios_set_file_comment(file_Ptr file_hdl, const char * comment, int comment_size) 
     44  { 
     45    std::string comment_str; 
     46    if (!cstr2string(comment, comment_size, comment_str)) return; 
     47    CTimer::get("XIOS").resume(); 
     48    file_hdl->comment.setValue(comment_str); 
     49    CTimer::get("XIOS").suspend(); 
     50  } 
     51 
     52  void cxios_get_file_comment(file_Ptr file_hdl, char * comment, int comment_size) 
     53  { 
     54    CTimer::get("XIOS").resume(); 
     55    if (!string_copy(file_hdl->comment.getInheritedValue(), comment, comment_size)) 
     56      ERROR("void cxios_get_file_comment(file_Ptr file_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_file_comment(file_Ptr file_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = file_hdl->comment.hasInheritedValue(); 
    3864     CTimer::get("XIOS").suspend(); 
    3965     return isDefined; 
     
    402428 
    403429 
     430  void cxios_set_file_read_metadata_par(file_Ptr file_hdl, bool read_metadata_par) 
     431  { 
     432    CTimer::get("XIOS").resume(); 
     433    file_hdl->read_metadata_par.setValue(read_metadata_par); 
     434    CTimer::get("XIOS").suspend(); 
     435  } 
     436 
     437  void cxios_get_file_read_metadata_par(file_Ptr file_hdl, bool* read_metadata_par) 
     438  { 
     439    CTimer::get("XIOS").resume(); 
     440    *read_metadata_par = file_hdl->read_metadata_par.getInheritedValue(); 
     441    CTimer::get("XIOS").suspend(); 
     442  } 
     443 
     444  bool cxios_is_defined_file_read_metadata_par(file_Ptr file_hdl) 
     445  { 
     446     CTimer::get("XIOS").resume(); 
     447     bool isDefined = file_hdl->read_metadata_par.hasInheritedValue(); 
     448     CTimer::get("XIOS").suspend(); 
     449     return isDefined; 
     450  } 
     451 
     452 
    404453  void cxios_set_file_record_offset(file_Ptr file_hdl, int record_offset) 
    405454  { 
     
    420469     CTimer::get("XIOS").resume(); 
    421470     bool isDefined = file_hdl->record_offset.hasInheritedValue(); 
     471     CTimer::get("XIOS").suspend(); 
     472     return isDefined; 
     473  } 
     474 
     475 
     476  void cxios_set_file_split_end_offset(file_Ptr file_hdl, cxios_duration split_end_offset_c) 
     477  { 
     478    CTimer::get("XIOS").resume(); 
     479    file_hdl->split_end_offset.allocate(); 
     480    CDuration& split_end_offset = file_hdl->split_end_offset.get(); 
     481    split_end_offset.year = split_end_offset_c.year; 
     482    split_end_offset.month = split_end_offset_c.month; 
     483    split_end_offset.day = split_end_offset_c.day; 
     484    split_end_offset.hour = split_end_offset_c.hour; 
     485    split_end_offset.minute = split_end_offset_c.minute; 
     486    split_end_offset.second = split_end_offset_c.second; 
     487    split_end_offset.timestep = split_end_offset_c.timestep; 
     488    CTimer::get("XIOS").suspend(); 
     489  } 
     490 
     491  void cxios_get_file_split_end_offset(file_Ptr file_hdl, cxios_duration* split_end_offset_c) 
     492  { 
     493    CTimer::get("XIOS").resume(); 
     494    CDuration split_end_offset = file_hdl->split_end_offset.getInheritedValue(); 
     495    split_end_offset_c->year = split_end_offset.year; 
     496    split_end_offset_c->month = split_end_offset.month; 
     497    split_end_offset_c->day = split_end_offset.day; 
     498    split_end_offset_c->hour = split_end_offset.hour; 
     499    split_end_offset_c->minute = split_end_offset.minute; 
     500    split_end_offset_c->second = split_end_offset.second; 
     501    split_end_offset_c->timestep = split_end_offset.timestep; 
     502    CTimer::get("XIOS").suspend(); 
     503  } 
     504 
     505  bool cxios_is_defined_file_split_end_offset(file_Ptr file_hdl) 
     506  { 
     507     CTimer::get("XIOS").resume(); 
     508     bool isDefined = file_hdl->split_end_offset.hasInheritedValue(); 
    422509     CTimer::get("XIOS").suspend(); 
    423510     return isDefined; 
     
    489576 
    490577 
     578  void cxios_set_file_split_last_date(file_Ptr file_hdl, const char * split_last_date, int split_last_date_size) 
     579  { 
     580    std::string split_last_date_str; 
     581    if (!cstr2string(split_last_date, split_last_date_size, split_last_date_str)) return; 
     582    CTimer::get("XIOS").resume(); 
     583    file_hdl->split_last_date.setValue(split_last_date_str); 
     584    CTimer::get("XIOS").suspend(); 
     585  } 
     586 
     587  void cxios_get_file_split_last_date(file_Ptr file_hdl, char * split_last_date, int split_last_date_size) 
     588  { 
     589    CTimer::get("XIOS").resume(); 
     590    if (!string_copy(file_hdl->split_last_date.getInheritedValue(), split_last_date, split_last_date_size)) 
     591      ERROR("void cxios_get_file_split_last_date(file_Ptr file_hdl, char * split_last_date, int split_last_date_size)", << "Input string is too short"); 
     592    CTimer::get("XIOS").suspend(); 
     593  } 
     594 
     595  bool cxios_is_defined_file_split_last_date(file_Ptr file_hdl) 
     596  { 
     597     CTimer::get("XIOS").resume(); 
     598     bool isDefined = file_hdl->split_last_date.hasInheritedValue(); 
     599     CTimer::get("XIOS").suspend(); 
     600     return isDefined; 
     601  } 
     602 
     603 
     604  void cxios_set_file_split_start_offset(file_Ptr file_hdl, cxios_duration split_start_offset_c) 
     605  { 
     606    CTimer::get("XIOS").resume(); 
     607    file_hdl->split_start_offset.allocate(); 
     608    CDuration& split_start_offset = file_hdl->split_start_offset.get(); 
     609    split_start_offset.year = split_start_offset_c.year; 
     610    split_start_offset.month = split_start_offset_c.month; 
     611    split_start_offset.day = split_start_offset_c.day; 
     612    split_start_offset.hour = split_start_offset_c.hour; 
     613    split_start_offset.minute = split_start_offset_c.minute; 
     614    split_start_offset.second = split_start_offset_c.second; 
     615    split_start_offset.timestep = split_start_offset_c.timestep; 
     616    CTimer::get("XIOS").suspend(); 
     617  } 
     618 
     619  void cxios_get_file_split_start_offset(file_Ptr file_hdl, cxios_duration* split_start_offset_c) 
     620  { 
     621    CTimer::get("XIOS").resume(); 
     622    CDuration split_start_offset = file_hdl->split_start_offset.getInheritedValue(); 
     623    split_start_offset_c->year = split_start_offset.year; 
     624    split_start_offset_c->month = split_start_offset.month; 
     625    split_start_offset_c->day = split_start_offset.day; 
     626    split_start_offset_c->hour = split_start_offset.hour; 
     627    split_start_offset_c->minute = split_start_offset.minute; 
     628    split_start_offset_c->second = split_start_offset.second; 
     629    split_start_offset_c->timestep = split_start_offset.timestep; 
     630    CTimer::get("XIOS").suspend(); 
     631  } 
     632 
     633  bool cxios_is_defined_file_split_start_offset(file_Ptr file_hdl) 
     634  { 
     635     CTimer::get("XIOS").resume(); 
     636     bool isDefined = file_hdl->split_start_offset.hasInheritedValue(); 
     637     CTimer::get("XIOS").suspend(); 
     638     return isDefined; 
     639  } 
     640 
     641 
    491642  void cxios_set_file_sync_freq(file_Ptr file_hdl, cxios_duration sync_freq_c) 
    492643  { 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icfilegroup_attr.cpp

    r1205 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    3636     CTimer::get("XIOS").resume(); 
    3737     bool isDefined = filegroup_hdl->append.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
     42 
     43  void cxios_set_filegroup_comment(filegroup_Ptr filegroup_hdl, const char * comment, int comment_size) 
     44  { 
     45    std::string comment_str; 
     46    if (!cstr2string(comment, comment_size, comment_str)) return; 
     47    CTimer::get("XIOS").resume(); 
     48    filegroup_hdl->comment.setValue(comment_str); 
     49    CTimer::get("XIOS").suspend(); 
     50  } 
     51 
     52  void cxios_get_filegroup_comment(filegroup_Ptr filegroup_hdl, char * comment, int comment_size) 
     53  { 
     54    CTimer::get("XIOS").resume(); 
     55    if (!string_copy(filegroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     56      ERROR("void cxios_get_filegroup_comment(filegroup_Ptr filegroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_filegroup_comment(filegroup_Ptr filegroup_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = filegroup_hdl->comment.hasInheritedValue(); 
    3864     CTimer::get("XIOS").suspend(); 
    3965     return isDefined; 
     
    428454 
    429455 
     456  void cxios_set_filegroup_read_metadata_par(filegroup_Ptr filegroup_hdl, bool read_metadata_par) 
     457  { 
     458    CTimer::get("XIOS").resume(); 
     459    filegroup_hdl->read_metadata_par.setValue(read_metadata_par); 
     460    CTimer::get("XIOS").suspend(); 
     461  } 
     462 
     463  void cxios_get_filegroup_read_metadata_par(filegroup_Ptr filegroup_hdl, bool* read_metadata_par) 
     464  { 
     465    CTimer::get("XIOS").resume(); 
     466    *read_metadata_par = filegroup_hdl->read_metadata_par.getInheritedValue(); 
     467    CTimer::get("XIOS").suspend(); 
     468  } 
     469 
     470  bool cxios_is_defined_filegroup_read_metadata_par(filegroup_Ptr filegroup_hdl) 
     471  { 
     472     CTimer::get("XIOS").resume(); 
     473     bool isDefined = filegroup_hdl->read_metadata_par.hasInheritedValue(); 
     474     CTimer::get("XIOS").suspend(); 
     475     return isDefined; 
     476  } 
     477 
     478 
    430479  void cxios_set_filegroup_record_offset(filegroup_Ptr filegroup_hdl, int record_offset) 
    431480  { 
     
    446495     CTimer::get("XIOS").resume(); 
    447496     bool isDefined = filegroup_hdl->record_offset.hasInheritedValue(); 
     497     CTimer::get("XIOS").suspend(); 
     498     return isDefined; 
     499  } 
     500 
     501 
     502  void cxios_set_filegroup_split_end_offset(filegroup_Ptr filegroup_hdl, cxios_duration split_end_offset_c) 
     503  { 
     504    CTimer::get("XIOS").resume(); 
     505    filegroup_hdl->split_end_offset.allocate(); 
     506    CDuration& split_end_offset = filegroup_hdl->split_end_offset.get(); 
     507    split_end_offset.year = split_end_offset_c.year; 
     508    split_end_offset.month = split_end_offset_c.month; 
     509    split_end_offset.day = split_end_offset_c.day; 
     510    split_end_offset.hour = split_end_offset_c.hour; 
     511    split_end_offset.minute = split_end_offset_c.minute; 
     512    split_end_offset.second = split_end_offset_c.second; 
     513    split_end_offset.timestep = split_end_offset_c.timestep; 
     514    CTimer::get("XIOS").suspend(); 
     515  } 
     516 
     517  void cxios_get_filegroup_split_end_offset(filegroup_Ptr filegroup_hdl, cxios_duration* split_end_offset_c) 
     518  { 
     519    CTimer::get("XIOS").resume(); 
     520    CDuration split_end_offset = filegroup_hdl->split_end_offset.getInheritedValue(); 
     521    split_end_offset_c->year = split_end_offset.year; 
     522    split_end_offset_c->month = split_end_offset.month; 
     523    split_end_offset_c->day = split_end_offset.day; 
     524    split_end_offset_c->hour = split_end_offset.hour; 
     525    split_end_offset_c->minute = split_end_offset.minute; 
     526    split_end_offset_c->second = split_end_offset.second; 
     527    split_end_offset_c->timestep = split_end_offset.timestep; 
     528    CTimer::get("XIOS").suspend(); 
     529  } 
     530 
     531  bool cxios_is_defined_filegroup_split_end_offset(filegroup_Ptr filegroup_hdl) 
     532  { 
     533     CTimer::get("XIOS").resume(); 
     534     bool isDefined = filegroup_hdl->split_end_offset.hasInheritedValue(); 
    448535     CTimer::get("XIOS").suspend(); 
    449536     return isDefined; 
     
    515602 
    516603 
     604  void cxios_set_filegroup_split_last_date(filegroup_Ptr filegroup_hdl, const char * split_last_date, int split_last_date_size) 
     605  { 
     606    std::string split_last_date_str; 
     607    if (!cstr2string(split_last_date, split_last_date_size, split_last_date_str)) return; 
     608    CTimer::get("XIOS").resume(); 
     609    filegroup_hdl->split_last_date.setValue(split_last_date_str); 
     610    CTimer::get("XIOS").suspend(); 
     611  } 
     612 
     613  void cxios_get_filegroup_split_last_date(filegroup_Ptr filegroup_hdl, char * split_last_date, int split_last_date_size) 
     614  { 
     615    CTimer::get("XIOS").resume(); 
     616    if (!string_copy(filegroup_hdl->split_last_date.getInheritedValue(), split_last_date, split_last_date_size)) 
     617      ERROR("void cxios_get_filegroup_split_last_date(filegroup_Ptr filegroup_hdl, char * split_last_date, int split_last_date_size)", << "Input string is too short"); 
     618    CTimer::get("XIOS").suspend(); 
     619  } 
     620 
     621  bool cxios_is_defined_filegroup_split_last_date(filegroup_Ptr filegroup_hdl) 
     622  { 
     623     CTimer::get("XIOS").resume(); 
     624     bool isDefined = filegroup_hdl->split_last_date.hasInheritedValue(); 
     625     CTimer::get("XIOS").suspend(); 
     626     return isDefined; 
     627  } 
     628 
     629 
     630  void cxios_set_filegroup_split_start_offset(filegroup_Ptr filegroup_hdl, cxios_duration split_start_offset_c) 
     631  { 
     632    CTimer::get("XIOS").resume(); 
     633    filegroup_hdl->split_start_offset.allocate(); 
     634    CDuration& split_start_offset = filegroup_hdl->split_start_offset.get(); 
     635    split_start_offset.year = split_start_offset_c.year; 
     636    split_start_offset.month = split_start_offset_c.month; 
     637    split_start_offset.day = split_start_offset_c.day; 
     638    split_start_offset.hour = split_start_offset_c.hour; 
     639    split_start_offset.minute = split_start_offset_c.minute; 
     640    split_start_offset.second = split_start_offset_c.second; 
     641    split_start_offset.timestep = split_start_offset_c.timestep; 
     642    CTimer::get("XIOS").suspend(); 
     643  } 
     644 
     645  void cxios_get_filegroup_split_start_offset(filegroup_Ptr filegroup_hdl, cxios_duration* split_start_offset_c) 
     646  { 
     647    CTimer::get("XIOS").resume(); 
     648    CDuration split_start_offset = filegroup_hdl->split_start_offset.getInheritedValue(); 
     649    split_start_offset_c->year = split_start_offset.year; 
     650    split_start_offset_c->month = split_start_offset.month; 
     651    split_start_offset_c->day = split_start_offset.day; 
     652    split_start_offset_c->hour = split_start_offset.hour; 
     653    split_start_offset_c->minute = split_start_offset.minute; 
     654    split_start_offset_c->second = split_start_offset.second; 
     655    split_start_offset_c->timestep = split_start_offset.timestep; 
     656    CTimer::get("XIOS").suspend(); 
     657  } 
     658 
     659  bool cxios_is_defined_filegroup_split_start_offset(filegroup_Ptr filegroup_hdl) 
     660  { 
     661     CTimer::get("XIOS").resume(); 
     662     bool isDefined = filegroup_hdl->split_start_offset.hasInheritedValue(); 
     663     CTimer::get("XIOS").suspend(); 
     664     return isDefined; 
     665  } 
     666 
     667 
    517668  void cxios_set_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, cxios_duration sync_freq_c) 
    518669  { 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icgenerate_rectilinear_domain_attr.cpp

    r786 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icgrid_attr.cpp

    r932 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    1818  typedef xios::CGrid* grid_Ptr; 
    1919 
     20  void cxios_set_grid_comment(grid_Ptr grid_hdl, const char * comment, int comment_size) 
     21  { 
     22    std::string comment_str; 
     23    if (!cstr2string(comment, comment_size, comment_str)) return; 
     24    CTimer::get("XIOS").resume(); 
     25    grid_hdl->comment.setValue(comment_str); 
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
     29  void cxios_get_grid_comment(grid_Ptr grid_hdl, char * comment, int comment_size) 
     30  { 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(grid_hdl->comment.getInheritedValue(), comment, comment_size)) 
     33      ERROR("void cxios_get_grid_comment(grid_Ptr grid_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_grid_comment(grid_Ptr grid_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = grid_hdl->comment.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
     45 
    2046  void cxios_set_grid_description(grid_Ptr grid_hdl, const char * description, int description_size) 
    2147  { 
     
    4470 
    4571 
     72  void cxios_set_grid_mask_0d(grid_Ptr grid_hdl, bool* mask_0d, int* extent) 
     73  { 
     74    CTimer::get("XIOS").resume(); 
     75    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData); 
     76    grid_hdl->mask_0d.reference(tmp.copy()); 
     77     CTimer::get("XIOS").suspend(); 
     78  } 
     79 
     80  void cxios_get_grid_mask_0d(grid_Ptr grid_hdl, bool* mask_0d, int* extent) 
     81  { 
     82    CTimer::get("XIOS").resume(); 
     83    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData); 
     84    tmp=grid_hdl->mask_0d.getInheritedValue(); 
     85     CTimer::get("XIOS").suspend(); 
     86  } 
     87 
     88  bool cxios_is_defined_grid_mask_0d(grid_Ptr grid_hdl) 
     89  { 
     90     CTimer::get("XIOS").resume(); 
     91     bool isDefined = grid_hdl->mask_0d.hasInheritedValue(); 
     92     CTimer::get("XIOS").suspend(); 
     93     return isDefined; 
     94  } 
     95 
     96 
    4697  void cxios_set_grid_mask_1d(grid_Ptr grid_hdl, bool* mask_1d, int* extent) 
    4798  { 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icgridgroup_attr.cpp

    r932 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    1818  typedef xios::CGridGroup* gridgroup_Ptr; 
    1919 
     20  void cxios_set_gridgroup_comment(gridgroup_Ptr gridgroup_hdl, const char * comment, int comment_size) 
     21  { 
     22    std::string comment_str; 
     23    if (!cstr2string(comment, comment_size, comment_str)) return; 
     24    CTimer::get("XIOS").resume(); 
     25    gridgroup_hdl->comment.setValue(comment_str); 
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
     29  void cxios_get_gridgroup_comment(gridgroup_Ptr gridgroup_hdl, char * comment, int comment_size) 
     30  { 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(gridgroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     33      ERROR("void cxios_get_gridgroup_comment(gridgroup_Ptr gridgroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_gridgroup_comment(gridgroup_Ptr gridgroup_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = gridgroup_hdl->comment.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
     45 
    2046  void cxios_set_gridgroup_description(gridgroup_Ptr gridgroup_hdl, const char * description, int description_size) 
    2147  { 
     
    7096 
    7197 
     98  void cxios_set_gridgroup_mask_0d(gridgroup_Ptr gridgroup_hdl, bool* mask_0d, int* extent) 
     99  { 
     100    CTimer::get("XIOS").resume(); 
     101    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData); 
     102    gridgroup_hdl->mask_0d.reference(tmp.copy()); 
     103     CTimer::get("XIOS").suspend(); 
     104  } 
     105 
     106  void cxios_get_gridgroup_mask_0d(gridgroup_Ptr gridgroup_hdl, bool* mask_0d, int* extent) 
     107  { 
     108    CTimer::get("XIOS").resume(); 
     109    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData); 
     110    tmp=gridgroup_hdl->mask_0d.getInheritedValue(); 
     111     CTimer::get("XIOS").suspend(); 
     112  } 
     113 
     114  bool cxios_is_defined_gridgroup_mask_0d(gridgroup_Ptr gridgroup_hdl) 
     115  { 
     116     CTimer::get("XIOS").resume(); 
     117     bool isDefined = gridgroup_hdl->mask_0d.hasInheritedValue(); 
     118     CTimer::get("XIOS").suspend(); 
     119     return isDefined; 
     120  } 
     121 
     122 
    72123  void cxios_set_gridgroup_mask_1d(gridgroup_Ptr gridgroup_hdl, bool* mask_1d, int* extent) 
    73124  { 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icinterpolate_axis_attr.cpp

    r891 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icinterpolate_domain_attr.cpp

    r1205 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    1818  typedef xios::CInterpolateDomain* interpolate_domain_Ptr; 
    1919 
     20  void cxios_set_interpolate_domain_detect_missing_value(interpolate_domain_Ptr interpolate_domain_hdl, bool detect_missing_value) 
     21  { 
     22    CTimer::get("XIOS").resume(); 
     23    interpolate_domain_hdl->detect_missing_value.setValue(detect_missing_value); 
     24    CTimer::get("XIOS").suspend(); 
     25  } 
     26 
     27  void cxios_get_interpolate_domain_detect_missing_value(interpolate_domain_Ptr interpolate_domain_hdl, bool* detect_missing_value) 
     28  { 
     29    CTimer::get("XIOS").resume(); 
     30    *detect_missing_value = interpolate_domain_hdl->detect_missing_value.getInheritedValue(); 
     31    CTimer::get("XIOS").suspend(); 
     32  } 
     33 
     34  bool cxios_is_defined_interpolate_domain_detect_missing_value(interpolate_domain_Ptr interpolate_domain_hdl) 
     35  { 
     36     CTimer::get("XIOS").resume(); 
     37     bool isDefined = interpolate_domain_hdl->detect_missing_value.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
     42 
    2043  void cxios_set_interpolate_domain_mode(interpolate_domain_Ptr interpolate_domain_hdl, const char * mode, int mode_size) 
    2144  { 
     
    90113 
    91114 
     115  void cxios_set_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl, const char * read_write_convention, int read_write_convention_size) 
     116  { 
     117    std::string read_write_convention_str; 
     118    if (!cstr2string(read_write_convention, read_write_convention_size, read_write_convention_str)) return; 
     119    CTimer::get("XIOS").resume(); 
     120    interpolate_domain_hdl->read_write_convention.fromString(read_write_convention_str); 
     121    CTimer::get("XIOS").suspend(); 
     122  } 
     123 
     124  void cxios_get_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl, char * read_write_convention, int read_write_convention_size) 
     125  { 
     126    CTimer::get("XIOS").resume(); 
     127    if (!string_copy(interpolate_domain_hdl->read_write_convention.getInheritedStringValue(), read_write_convention, read_write_convention_size)) 
     128      ERROR("void cxios_get_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl, char * read_write_convention, int read_write_convention_size)", << "Input string is too short"); 
     129    CTimer::get("XIOS").suspend(); 
     130  } 
     131 
     132  bool cxios_is_defined_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl) 
     133  { 
     134     CTimer::get("XIOS").resume(); 
     135     bool isDefined = interpolate_domain_hdl->read_write_convention.hasInheritedValue(); 
     136     CTimer::get("XIOS").suspend(); 
     137     return isDefined; 
     138  } 
     139 
     140 
    92141  void cxios_set_interpolate_domain_renormalize(interpolate_domain_Ptr interpolate_domain_hdl, bool renormalize) 
    93142  { 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icinverse_axis_attr.cpp

    r786 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icreduce_axis_to_scalar_attr.cpp

    r980 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icreduce_domain_to_axis_attr.cpp

    r981 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    4444 
    4545 
     46  void cxios_set_reduce_domain_to_axis_local(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl, bool local) 
     47  { 
     48    CTimer::get("XIOS").resume(); 
     49    reduce_domain_to_axis_hdl->local.setValue(local); 
     50    CTimer::get("XIOS").suspend(); 
     51  } 
     52 
     53  void cxios_get_reduce_domain_to_axis_local(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl, bool* local) 
     54  { 
     55    CTimer::get("XIOS").resume(); 
     56    *local = reduce_domain_to_axis_hdl->local.getInheritedValue(); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_reduce_domain_to_axis_local(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = reduce_domain_to_axis_hdl->local.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    4669  void cxios_set_reduce_domain_to_axis_operation(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl, const char * operation, int operation_size) 
    4770  { 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icreduce_domain_to_scalar_attr.cpp

    r981 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    1717{ 
    1818  typedef xios::CReduceDomainToScalar* reduce_domain_to_scalar_Ptr; 
     19 
     20  void cxios_set_reduce_domain_to_scalar_local(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl, bool local) 
     21  { 
     22    CTimer::get("XIOS").resume(); 
     23    reduce_domain_to_scalar_hdl->local.setValue(local); 
     24    CTimer::get("XIOS").suspend(); 
     25  } 
     26 
     27  void cxios_get_reduce_domain_to_scalar_local(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl, bool* local) 
     28  { 
     29    CTimer::get("XIOS").resume(); 
     30    *local = reduce_domain_to_scalar_hdl->local.getInheritedValue(); 
     31    CTimer::get("XIOS").suspend(); 
     32  } 
     33 
     34  bool cxios_is_defined_reduce_domain_to_scalar_local(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl) 
     35  { 
     36     CTimer::get("XIOS").resume(); 
     37     bool isDefined = reduce_domain_to_scalar_hdl->local.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
    1942 
    2043  void cxios_set_reduce_domain_to_scalar_operation(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl, const char * operation, int operation_size) 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icscalar_attr.cpp

    r1052 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    1818  typedef xios::CScalar* scalar_Ptr; 
    1919 
     20  void cxios_set_scalar_axis_type(scalar_Ptr scalar_hdl, const char * axis_type, int axis_type_size) 
     21  { 
     22    std::string axis_type_str; 
     23    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return; 
     24    CTimer::get("XIOS").resume(); 
     25    scalar_hdl->axis_type.fromString(axis_type_str); 
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
     29  void cxios_get_scalar_axis_type(scalar_Ptr scalar_hdl, char * axis_type, int axis_type_size) 
     30  { 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(scalar_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size)) 
     33      ERROR("void cxios_get_scalar_axis_type(scalar_Ptr scalar_hdl, char * axis_type, int axis_type_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_scalar_axis_type(scalar_Ptr scalar_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = scalar_hdl->axis_type.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
     45 
     46  void cxios_set_scalar_bounds(scalar_Ptr scalar_hdl, double* bounds, int* extent) 
     47  { 
     48    CTimer::get("XIOS").resume(); 
     49    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData); 
     50    scalar_hdl->bounds.reference(tmp.copy()); 
     51     CTimer::get("XIOS").suspend(); 
     52  } 
     53 
     54  void cxios_get_scalar_bounds(scalar_Ptr scalar_hdl, double* bounds, int* extent) 
     55  { 
     56    CTimer::get("XIOS").resume(); 
     57    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData); 
     58    tmp=scalar_hdl->bounds.getInheritedValue(); 
     59     CTimer::get("XIOS").suspend(); 
     60  } 
     61 
     62  bool cxios_is_defined_scalar_bounds(scalar_Ptr scalar_hdl) 
     63  { 
     64     CTimer::get("XIOS").resume(); 
     65     bool isDefined = scalar_hdl->bounds.hasInheritedValue(); 
     66     CTimer::get("XIOS").suspend(); 
     67     return isDefined; 
     68  } 
     69 
     70 
     71  void cxios_set_scalar_bounds_name(scalar_Ptr scalar_hdl, const char * bounds_name, int bounds_name_size) 
     72  { 
     73    std::string bounds_name_str; 
     74    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return; 
     75    CTimer::get("XIOS").resume(); 
     76    scalar_hdl->bounds_name.setValue(bounds_name_str); 
     77    CTimer::get("XIOS").suspend(); 
     78  } 
     79 
     80  void cxios_get_scalar_bounds_name(scalar_Ptr scalar_hdl, char * bounds_name, int bounds_name_size) 
     81  { 
     82    CTimer::get("XIOS").resume(); 
     83    if (!string_copy(scalar_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size)) 
     84      ERROR("void cxios_get_scalar_bounds_name(scalar_Ptr scalar_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short"); 
     85    CTimer::get("XIOS").suspend(); 
     86  } 
     87 
     88  bool cxios_is_defined_scalar_bounds_name(scalar_Ptr scalar_hdl) 
     89  { 
     90     CTimer::get("XIOS").resume(); 
     91     bool isDefined = scalar_hdl->bounds_name.hasInheritedValue(); 
     92     CTimer::get("XIOS").suspend(); 
     93     return isDefined; 
     94  } 
     95 
     96 
     97  void cxios_set_scalar_comment(scalar_Ptr scalar_hdl, const char * comment, int comment_size) 
     98  { 
     99    std::string comment_str; 
     100    if (!cstr2string(comment, comment_size, comment_str)) return; 
     101    CTimer::get("XIOS").resume(); 
     102    scalar_hdl->comment.setValue(comment_str); 
     103    CTimer::get("XIOS").suspend(); 
     104  } 
     105 
     106  void cxios_get_scalar_comment(scalar_Ptr scalar_hdl, char * comment, int comment_size) 
     107  { 
     108    CTimer::get("XIOS").resume(); 
     109    if (!string_copy(scalar_hdl->comment.getInheritedValue(), comment, comment_size)) 
     110      ERROR("void cxios_get_scalar_comment(scalar_Ptr scalar_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     111    CTimer::get("XIOS").suspend(); 
     112  } 
     113 
     114  bool cxios_is_defined_scalar_comment(scalar_Ptr scalar_hdl) 
     115  { 
     116     CTimer::get("XIOS").resume(); 
     117     bool isDefined = scalar_hdl->comment.hasInheritedValue(); 
     118     CTimer::get("XIOS").suspend(); 
     119     return isDefined; 
     120  } 
     121 
     122 
     123  void cxios_set_scalar_label(scalar_Ptr scalar_hdl, const char * label, int label_size) 
     124  { 
     125    std::string label_str; 
     126    if (!cstr2string(label, label_size, label_str)) return; 
     127    CTimer::get("XIOS").resume(); 
     128    scalar_hdl->label.setValue(label_str); 
     129    CTimer::get("XIOS").suspend(); 
     130  } 
     131 
     132  void cxios_get_scalar_label(scalar_Ptr scalar_hdl, char * label, int label_size) 
     133  { 
     134    CTimer::get("XIOS").resume(); 
     135    if (!string_copy(scalar_hdl->label.getInheritedValue(), label, label_size)) 
     136      ERROR("void cxios_get_scalar_label(scalar_Ptr scalar_hdl, char * label, int label_size)", << "Input string is too short"); 
     137    CTimer::get("XIOS").suspend(); 
     138  } 
     139 
     140  bool cxios_is_defined_scalar_label(scalar_Ptr scalar_hdl) 
     141  { 
     142     CTimer::get("XIOS").resume(); 
     143     bool isDefined = scalar_hdl->label.hasInheritedValue(); 
     144     CTimer::get("XIOS").suspend(); 
     145     return isDefined; 
     146  } 
     147 
     148 
    20149  void cxios_set_scalar_long_name(scalar_Ptr scalar_hdl, const char * long_name, int long_name_size) 
    21150  { 
     
    70199 
    71200 
     201  void cxios_set_scalar_positive(scalar_Ptr scalar_hdl, const char * positive, int positive_size) 
     202  { 
     203    std::string positive_str; 
     204    if (!cstr2string(positive, positive_size, positive_str)) return; 
     205    CTimer::get("XIOS").resume(); 
     206    scalar_hdl->positive.fromString(positive_str); 
     207    CTimer::get("XIOS").suspend(); 
     208  } 
     209 
     210  void cxios_get_scalar_positive(scalar_Ptr scalar_hdl, char * positive, int positive_size) 
     211  { 
     212    CTimer::get("XIOS").resume(); 
     213    if (!string_copy(scalar_hdl->positive.getInheritedStringValue(), positive, positive_size)) 
     214      ERROR("void cxios_get_scalar_positive(scalar_Ptr scalar_hdl, char * positive, int positive_size)", << "Input string is too short"); 
     215    CTimer::get("XIOS").suspend(); 
     216  } 
     217 
     218  bool cxios_is_defined_scalar_positive(scalar_Ptr scalar_hdl) 
     219  { 
     220     CTimer::get("XIOS").resume(); 
     221     bool isDefined = scalar_hdl->positive.hasInheritedValue(); 
     222     CTimer::get("XIOS").suspend(); 
     223     return isDefined; 
     224  } 
     225 
     226 
    72227  void cxios_set_scalar_prec(scalar_Ptr scalar_hdl, int prec) 
    73228  { 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icscalargroup_attr.cpp

    r1052 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
     
    1818  typedef xios::CScalarGroup* scalargroup_Ptr; 
    1919 
     20  void cxios_set_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl, const char * axis_type, int axis_type_size) 
     21  { 
     22    std::string axis_type_str; 
     23    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return; 
     24    CTimer::get("XIOS").resume(); 
     25    scalargroup_hdl->axis_type.fromString(axis_type_str); 
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
     29  void cxios_get_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl, char * axis_type, int axis_type_size) 
     30  { 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(scalargroup_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size)) 
     33      ERROR("void cxios_get_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl, char * axis_type, int axis_type_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = scalargroup_hdl->axis_type.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
     45 
     46  void cxios_set_scalargroup_bounds(scalargroup_Ptr scalargroup_hdl, double* bounds, int* extent) 
     47  { 
     48    CTimer::get("XIOS").resume(); 
     49    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData); 
     50    scalargroup_hdl->bounds.reference(tmp.copy()); 
     51     CTimer::get("XIOS").suspend(); 
     52  } 
     53 
     54  void cxios_get_scalargroup_bounds(scalargroup_Ptr scalargroup_hdl, double* bounds, int* extent) 
     55  { 
     56    CTimer::get("XIOS").resume(); 
     57    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData); 
     58    tmp=scalargroup_hdl->bounds.getInheritedValue(); 
     59     CTimer::get("XIOS").suspend(); 
     60  } 
     61 
     62  bool cxios_is_defined_scalargroup_bounds(scalargroup_Ptr scalargroup_hdl) 
     63  { 
     64     CTimer::get("XIOS").resume(); 
     65     bool isDefined = scalargroup_hdl->bounds.hasInheritedValue(); 
     66     CTimer::get("XIOS").suspend(); 
     67     return isDefined; 
     68  } 
     69 
     70 
     71  void cxios_set_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl, const char * bounds_name, int bounds_name_size) 
     72  { 
     73    std::string bounds_name_str; 
     74    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return; 
     75    CTimer::get("XIOS").resume(); 
     76    scalargroup_hdl->bounds_name.setValue(bounds_name_str); 
     77    CTimer::get("XIOS").suspend(); 
     78  } 
     79 
     80  void cxios_get_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl, char * bounds_name, int bounds_name_size) 
     81  { 
     82    CTimer::get("XIOS").resume(); 
     83    if (!string_copy(scalargroup_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size)) 
     84      ERROR("void cxios_get_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short"); 
     85    CTimer::get("XIOS").suspend(); 
     86  } 
     87 
     88  bool cxios_is_defined_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl) 
     89  { 
     90     CTimer::get("XIOS").resume(); 
     91     bool isDefined = scalargroup_hdl->bounds_name.hasInheritedValue(); 
     92     CTimer::get("XIOS").suspend(); 
     93     return isDefined; 
     94  } 
     95 
     96 
     97  void cxios_set_scalargroup_comment(scalargroup_Ptr scalargroup_hdl, const char * comment, int comment_size) 
     98  { 
     99    std::string comment_str; 
     100    if (!cstr2string(comment, comment_size, comment_str)) return; 
     101    CTimer::get("XIOS").resume(); 
     102    scalargroup_hdl->comment.setValue(comment_str); 
     103    CTimer::get("XIOS").suspend(); 
     104  } 
     105 
     106  void cxios_get_scalargroup_comment(scalargroup_Ptr scalargroup_hdl, char * comment, int comment_size) 
     107  { 
     108    CTimer::get("XIOS").resume(); 
     109    if (!string_copy(scalargroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     110      ERROR("void cxios_get_scalargroup_comment(scalargroup_Ptr scalargroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     111    CTimer::get("XIOS").suspend(); 
     112  } 
     113 
     114  bool cxios_is_defined_scalargroup_comment(scalargroup_Ptr scalargroup_hdl) 
     115  { 
     116     CTimer::get("XIOS").resume(); 
     117     bool isDefined = scalargroup_hdl->comment.hasInheritedValue(); 
     118     CTimer::get("XIOS").suspend(); 
     119     return isDefined; 
     120  } 
     121 
     122 
    20123  void cxios_set_scalargroup_group_ref(scalargroup_Ptr scalargroup_hdl, const char * group_ref, int group_ref_size) 
    21124  { 
     
    44147 
    45148 
     149  void cxios_set_scalargroup_label(scalargroup_Ptr scalargroup_hdl, const char * label, int label_size) 
     150  { 
     151    std::string label_str; 
     152    if (!cstr2string(label, label_size, label_str)) return; 
     153    CTimer::get("XIOS").resume(); 
     154    scalargroup_hdl->label.setValue(label_str); 
     155    CTimer::get("XIOS").suspend(); 
     156  } 
     157 
     158  void cxios_get_scalargroup_label(scalargroup_Ptr scalargroup_hdl, char * label, int label_size) 
     159  { 
     160    CTimer::get("XIOS").resume(); 
     161    if (!string_copy(scalargroup_hdl->label.getInheritedValue(), label, label_size)) 
     162      ERROR("void cxios_get_scalargroup_label(scalargroup_Ptr scalargroup_hdl, char * label, int label_size)", << "Input string is too short"); 
     163    CTimer::get("XIOS").suspend(); 
     164  } 
     165 
     166  bool cxios_is_defined_scalargroup_label(scalargroup_Ptr scalargroup_hdl) 
     167  { 
     168     CTimer::get("XIOS").resume(); 
     169     bool isDefined = scalargroup_hdl->label.hasInheritedValue(); 
     170     CTimer::get("XIOS").suspend(); 
     171     return isDefined; 
     172  } 
     173 
     174 
    46175  void cxios_set_scalargroup_long_name(scalargroup_Ptr scalargroup_hdl, const char * long_name, int long_name_size) 
    47176  { 
     
    96225 
    97226 
     227  void cxios_set_scalargroup_positive(scalargroup_Ptr scalargroup_hdl, const char * positive, int positive_size) 
     228  { 
     229    std::string positive_str; 
     230    if (!cstr2string(positive, positive_size, positive_str)) return; 
     231    CTimer::get("XIOS").resume(); 
     232    scalargroup_hdl->positive.fromString(positive_str); 
     233    CTimer::get("XIOS").suspend(); 
     234  } 
     235 
     236  void cxios_get_scalargroup_positive(scalargroup_Ptr scalargroup_hdl, char * positive, int positive_size) 
     237  { 
     238    CTimer::get("XIOS").resume(); 
     239    if (!string_copy(scalargroup_hdl->positive.getInheritedStringValue(), positive, positive_size)) 
     240      ERROR("void cxios_get_scalargroup_positive(scalargroup_Ptr scalargroup_hdl, char * positive, int positive_size)", << "Input string is too short"); 
     241    CTimer::get("XIOS").suspend(); 
     242  } 
     243 
     244  bool cxios_is_defined_scalargroup_positive(scalargroup_Ptr scalargroup_hdl) 
     245  { 
     246     CTimer::get("XIOS").resume(); 
     247     bool isDefined = scalargroup_hdl->positive.hasInheritedValue(); 
     248     CTimer::get("XIOS").suspend(); 
     249     return isDefined; 
     250  } 
     251 
     252 
    98253  void cxios_set_scalargroup_prec(scalargroup_Ptr scalargroup_hdl, int prec) 
    99254  { 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icvariable_attr.cpp

    r1041 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/icvariablegroup_attr.cpp

    r1041 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/iczoom_axis_attr.cpp

    r1205 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/c_attr/iczoom_domain_attr.cpp

    r787 r1545  
    44 
    55#include <boost/multi_array.hpp> 
    6 #include <boost/shared_ptr.hpp> 
     6#include <memory> 
    77#include "xios.hpp" 
    88#include "attribute_template.hpp" 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/axis_interface_attr.F90

    r1052 r1545  
    3131 
    3232 
     33    SUBROUTINE cxios_set_axis_axis_type(axis_hdl, axis_type, axis_type_size) BIND(C) 
     34      USE ISO_C_BINDING 
     35      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     36      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_type 
     37      INTEGER  (kind = C_INT)     , VALUE        :: axis_type_size 
     38    END SUBROUTINE cxios_set_axis_axis_type 
     39 
     40    SUBROUTINE cxios_get_axis_axis_type(axis_hdl, axis_type, axis_type_size) BIND(C) 
     41      USE ISO_C_BINDING 
     42      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     43      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_type 
     44      INTEGER  (kind = C_INT)     , VALUE        :: axis_type_size 
     45    END SUBROUTINE cxios_get_axis_axis_type 
     46 
     47    FUNCTION cxios_is_defined_axis_axis_type(axis_hdl) BIND(C) 
     48      USE ISO_C_BINDING 
     49      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_axis_type 
     50      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     51    END FUNCTION cxios_is_defined_axis_axis_type 
     52 
     53 
    3354    SUBROUTINE cxios_set_axis_begin(axis_hdl, begin) BIND(C) 
    3455      USE ISO_C_BINDING 
     
    7192 
    7293 
     94    SUBROUTINE cxios_set_axis_bounds_name(axis_hdl, bounds_name, bounds_name_size) BIND(C) 
     95      USE ISO_C_BINDING 
     96      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     97      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_name 
     98      INTEGER  (kind = C_INT)     , VALUE        :: bounds_name_size 
     99    END SUBROUTINE cxios_set_axis_bounds_name 
     100 
     101    SUBROUTINE cxios_get_axis_bounds_name(axis_hdl, bounds_name, bounds_name_size) BIND(C) 
     102      USE ISO_C_BINDING 
     103      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     104      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_name 
     105      INTEGER  (kind = C_INT)     , VALUE        :: bounds_name_size 
     106    END SUBROUTINE cxios_get_axis_bounds_name 
     107 
     108    FUNCTION cxios_is_defined_axis_bounds_name(axis_hdl) BIND(C) 
     109      USE ISO_C_BINDING 
     110      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_bounds_name 
     111      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     112    END FUNCTION cxios_is_defined_axis_bounds_name 
     113 
     114 
     115    SUBROUTINE cxios_set_axis_comment(axis_hdl, comment, comment_size) BIND(C) 
     116      USE ISO_C_BINDING 
     117      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     118      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     119      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     120    END SUBROUTINE cxios_set_axis_comment 
     121 
     122    SUBROUTINE cxios_get_axis_comment(axis_hdl, comment, comment_size) BIND(C) 
     123      USE ISO_C_BINDING 
     124      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     125      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     126      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     127    END SUBROUTINE cxios_get_axis_comment 
     128 
     129    FUNCTION cxios_is_defined_axis_comment(axis_hdl) BIND(C) 
     130      USE ISO_C_BINDING 
     131      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_comment 
     132      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     133    END FUNCTION cxios_is_defined_axis_comment 
     134 
     135 
    73136    SUBROUTINE cxios_set_axis_data_begin(axis_hdl, data_begin) BIND(C) 
    74137      USE ISO_C_BINDING 
     
    128191      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    129192    END FUNCTION cxios_is_defined_axis_data_n 
     193 
     194 
     195    SUBROUTINE cxios_set_axis_dim_name(axis_hdl, dim_name, dim_name_size) BIND(C) 
     196      USE ISO_C_BINDING 
     197      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     198      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_name 
     199      INTEGER  (kind = C_INT)     , VALUE        :: dim_name_size 
     200    END SUBROUTINE cxios_set_axis_dim_name 
     201 
     202    SUBROUTINE cxios_get_axis_dim_name(axis_hdl, dim_name, dim_name_size) BIND(C) 
     203      USE ISO_C_BINDING 
     204      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     205      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_name 
     206      INTEGER  (kind = C_INT)     , VALUE        :: dim_name_size 
     207    END SUBROUTINE cxios_get_axis_dim_name 
     208 
     209    FUNCTION cxios_is_defined_axis_dim_name(axis_hdl) BIND(C) 
     210      USE ISO_C_BINDING 
     211      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_dim_name 
     212      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     213    END FUNCTION cxios_is_defined_axis_dim_name 
     214 
     215 
     216    SUBROUTINE cxios_set_axis_formula(axis_hdl, formula, formula_size) BIND(C) 
     217      USE ISO_C_BINDING 
     218      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     219      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula 
     220      INTEGER  (kind = C_INT)     , VALUE        :: formula_size 
     221    END SUBROUTINE cxios_set_axis_formula 
     222 
     223    SUBROUTINE cxios_get_axis_formula(axis_hdl, formula, formula_size) BIND(C) 
     224      USE ISO_C_BINDING 
     225      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     226      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula 
     227      INTEGER  (kind = C_INT)     , VALUE        :: formula_size 
     228    END SUBROUTINE cxios_get_axis_formula 
     229 
     230    FUNCTION cxios_is_defined_axis_formula(axis_hdl) BIND(C) 
     231      USE ISO_C_BINDING 
     232      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_formula 
     233      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     234    END FUNCTION cxios_is_defined_axis_formula 
     235 
     236 
     237    SUBROUTINE cxios_set_axis_formula_bounds(axis_hdl, formula_bounds, formula_bounds_size) BIND(C) 
     238      USE ISO_C_BINDING 
     239      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     240      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_bounds 
     241      INTEGER  (kind = C_INT)     , VALUE        :: formula_bounds_size 
     242    END SUBROUTINE cxios_set_axis_formula_bounds 
     243 
     244    SUBROUTINE cxios_get_axis_formula_bounds(axis_hdl, formula_bounds, formula_bounds_size) BIND(C) 
     245      USE ISO_C_BINDING 
     246      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     247      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_bounds 
     248      INTEGER  (kind = C_INT)     , VALUE        :: formula_bounds_size 
     249    END SUBROUTINE cxios_get_axis_formula_bounds 
     250 
     251    FUNCTION cxios_is_defined_axis_formula_bounds(axis_hdl) BIND(C) 
     252      USE ISO_C_BINDING 
     253      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_formula_bounds 
     254      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     255    END FUNCTION cxios_is_defined_axis_formula_bounds 
     256 
     257 
     258    SUBROUTINE cxios_set_axis_formula_term(axis_hdl, formula_term, formula_term_size) BIND(C) 
     259      USE ISO_C_BINDING 
     260      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     261      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term 
     262      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_size 
     263    END SUBROUTINE cxios_set_axis_formula_term 
     264 
     265    SUBROUTINE cxios_get_axis_formula_term(axis_hdl, formula_term, formula_term_size) BIND(C) 
     266      USE ISO_C_BINDING 
     267      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     268      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term 
     269      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_size 
     270    END SUBROUTINE cxios_get_axis_formula_term 
     271 
     272    FUNCTION cxios_is_defined_axis_formula_term(axis_hdl) BIND(C) 
     273      USE ISO_C_BINDING 
     274      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_formula_term 
     275      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     276    END FUNCTION cxios_is_defined_axis_formula_term 
     277 
     278 
     279    SUBROUTINE cxios_set_axis_formula_term_bounds(axis_hdl, formula_term_bounds, formula_term_bounds_size) BIND(C) 
     280      USE ISO_C_BINDING 
     281      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     282      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term_bounds 
     283      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_bounds_size 
     284    END SUBROUTINE cxios_set_axis_formula_term_bounds 
     285 
     286    SUBROUTINE cxios_get_axis_formula_term_bounds(axis_hdl, formula_term_bounds, formula_term_bounds_size) BIND(C) 
     287      USE ISO_C_BINDING 
     288      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     289      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term_bounds 
     290      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_bounds_size 
     291    END SUBROUTINE cxios_get_axis_formula_term_bounds 
     292 
     293    FUNCTION cxios_is_defined_axis_formula_term_bounds(axis_hdl) BIND(C) 
     294      USE ISO_C_BINDING 
     295      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_formula_term_bounds 
     296      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     297    END FUNCTION cxios_is_defined_axis_formula_term_bounds 
    130298 
    131299 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/axisgroup_interface_attr.F90

    r1052 r1545  
    3131 
    3232 
     33    SUBROUTINE cxios_set_axisgroup_axis_type(axisgroup_hdl, axis_type, axis_type_size) BIND(C) 
     34      USE ISO_C_BINDING 
     35      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     36      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_type 
     37      INTEGER  (kind = C_INT)     , VALUE        :: axis_type_size 
     38    END SUBROUTINE cxios_set_axisgroup_axis_type 
     39 
     40    SUBROUTINE cxios_get_axisgroup_axis_type(axisgroup_hdl, axis_type, axis_type_size) BIND(C) 
     41      USE ISO_C_BINDING 
     42      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     43      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_type 
     44      INTEGER  (kind = C_INT)     , VALUE        :: axis_type_size 
     45    END SUBROUTINE cxios_get_axisgroup_axis_type 
     46 
     47    FUNCTION cxios_is_defined_axisgroup_axis_type(axisgroup_hdl) BIND(C) 
     48      USE ISO_C_BINDING 
     49      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_axis_type 
     50      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     51    END FUNCTION cxios_is_defined_axisgroup_axis_type 
     52 
     53 
    3354    SUBROUTINE cxios_set_axisgroup_begin(axisgroup_hdl, begin) BIND(C) 
    3455      USE ISO_C_BINDING 
     
    7192 
    7293 
     94    SUBROUTINE cxios_set_axisgroup_bounds_name(axisgroup_hdl, bounds_name, bounds_name_size) BIND(C) 
     95      USE ISO_C_BINDING 
     96      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     97      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_name 
     98      INTEGER  (kind = C_INT)     , VALUE        :: bounds_name_size 
     99    END SUBROUTINE cxios_set_axisgroup_bounds_name 
     100 
     101    SUBROUTINE cxios_get_axisgroup_bounds_name(axisgroup_hdl, bounds_name, bounds_name_size) BIND(C) 
     102      USE ISO_C_BINDING 
     103      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     104      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_name 
     105      INTEGER  (kind = C_INT)     , VALUE        :: bounds_name_size 
     106    END SUBROUTINE cxios_get_axisgroup_bounds_name 
     107 
     108    FUNCTION cxios_is_defined_axisgroup_bounds_name(axisgroup_hdl) BIND(C) 
     109      USE ISO_C_BINDING 
     110      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_bounds_name 
     111      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     112    END FUNCTION cxios_is_defined_axisgroup_bounds_name 
     113 
     114 
     115    SUBROUTINE cxios_set_axisgroup_comment(axisgroup_hdl, comment, comment_size) BIND(C) 
     116      USE ISO_C_BINDING 
     117      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     118      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     119      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     120    END SUBROUTINE cxios_set_axisgroup_comment 
     121 
     122    SUBROUTINE cxios_get_axisgroup_comment(axisgroup_hdl, comment, comment_size) BIND(C) 
     123      USE ISO_C_BINDING 
     124      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     125      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     126      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     127    END SUBROUTINE cxios_get_axisgroup_comment 
     128 
     129    FUNCTION cxios_is_defined_axisgroup_comment(axisgroup_hdl) BIND(C) 
     130      USE ISO_C_BINDING 
     131      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_comment 
     132      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     133    END FUNCTION cxios_is_defined_axisgroup_comment 
     134 
     135 
    73136    SUBROUTINE cxios_set_axisgroup_data_begin(axisgroup_hdl, data_begin) BIND(C) 
    74137      USE ISO_C_BINDING 
     
    128191      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    129192    END FUNCTION cxios_is_defined_axisgroup_data_n 
     193 
     194 
     195    SUBROUTINE cxios_set_axisgroup_dim_name(axisgroup_hdl, dim_name, dim_name_size) BIND(C) 
     196      USE ISO_C_BINDING 
     197      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     198      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_name 
     199      INTEGER  (kind = C_INT)     , VALUE        :: dim_name_size 
     200    END SUBROUTINE cxios_set_axisgroup_dim_name 
     201 
     202    SUBROUTINE cxios_get_axisgroup_dim_name(axisgroup_hdl, dim_name, dim_name_size) BIND(C) 
     203      USE ISO_C_BINDING 
     204      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     205      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_name 
     206      INTEGER  (kind = C_INT)     , VALUE        :: dim_name_size 
     207    END SUBROUTINE cxios_get_axisgroup_dim_name 
     208 
     209    FUNCTION cxios_is_defined_axisgroup_dim_name(axisgroup_hdl) BIND(C) 
     210      USE ISO_C_BINDING 
     211      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_dim_name 
     212      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     213    END FUNCTION cxios_is_defined_axisgroup_dim_name 
     214 
     215 
     216    SUBROUTINE cxios_set_axisgroup_formula(axisgroup_hdl, formula, formula_size) BIND(C) 
     217      USE ISO_C_BINDING 
     218      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     219      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula 
     220      INTEGER  (kind = C_INT)     , VALUE        :: formula_size 
     221    END SUBROUTINE cxios_set_axisgroup_formula 
     222 
     223    SUBROUTINE cxios_get_axisgroup_formula(axisgroup_hdl, formula, formula_size) BIND(C) 
     224      USE ISO_C_BINDING 
     225      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     226      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula 
     227      INTEGER  (kind = C_INT)     , VALUE        :: formula_size 
     228    END SUBROUTINE cxios_get_axisgroup_formula 
     229 
     230    FUNCTION cxios_is_defined_axisgroup_formula(axisgroup_hdl) BIND(C) 
     231      USE ISO_C_BINDING 
     232      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_formula 
     233      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     234    END FUNCTION cxios_is_defined_axisgroup_formula 
     235 
     236 
     237    SUBROUTINE cxios_set_axisgroup_formula_bounds(axisgroup_hdl, formula_bounds, formula_bounds_size) BIND(C) 
     238      USE ISO_C_BINDING 
     239      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     240      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_bounds 
     241      INTEGER  (kind = C_INT)     , VALUE        :: formula_bounds_size 
     242    END SUBROUTINE cxios_set_axisgroup_formula_bounds 
     243 
     244    SUBROUTINE cxios_get_axisgroup_formula_bounds(axisgroup_hdl, formula_bounds, formula_bounds_size) BIND(C) 
     245      USE ISO_C_BINDING 
     246      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     247      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_bounds 
     248      INTEGER  (kind = C_INT)     , VALUE        :: formula_bounds_size 
     249    END SUBROUTINE cxios_get_axisgroup_formula_bounds 
     250 
     251    FUNCTION cxios_is_defined_axisgroup_formula_bounds(axisgroup_hdl) BIND(C) 
     252      USE ISO_C_BINDING 
     253      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_formula_bounds 
     254      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     255    END FUNCTION cxios_is_defined_axisgroup_formula_bounds 
     256 
     257 
     258    SUBROUTINE cxios_set_axisgroup_formula_term(axisgroup_hdl, formula_term, formula_term_size) BIND(C) 
     259      USE ISO_C_BINDING 
     260      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     261      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term 
     262      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_size 
     263    END SUBROUTINE cxios_set_axisgroup_formula_term 
     264 
     265    SUBROUTINE cxios_get_axisgroup_formula_term(axisgroup_hdl, formula_term, formula_term_size) BIND(C) 
     266      USE ISO_C_BINDING 
     267      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     268      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term 
     269      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_size 
     270    END SUBROUTINE cxios_get_axisgroup_formula_term 
     271 
     272    FUNCTION cxios_is_defined_axisgroup_formula_term(axisgroup_hdl) BIND(C) 
     273      USE ISO_C_BINDING 
     274      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_formula_term 
     275      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     276    END FUNCTION cxios_is_defined_axisgroup_formula_term 
     277 
     278 
     279    SUBROUTINE cxios_set_axisgroup_formula_term_bounds(axisgroup_hdl, formula_term_bounds, formula_term_bounds_size) BIND(C) 
     280      USE ISO_C_BINDING 
     281      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     282      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term_bounds 
     283      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_bounds_size 
     284    END SUBROUTINE cxios_set_axisgroup_formula_term_bounds 
     285 
     286    SUBROUTINE cxios_get_axisgroup_formula_term_bounds(axisgroup_hdl, formula_term_bounds, formula_term_bounds_size) BIND(C) 
     287      USE ISO_C_BINDING 
     288      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     289      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term_bounds 
     290      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_bounds_size 
     291    END SUBROUTINE cxios_get_axisgroup_formula_term_bounds 
     292 
     293    FUNCTION cxios_is_defined_axisgroup_formula_term_bounds(axisgroup_hdl) BIND(C) 
     294      USE ISO_C_BINDING 
     295      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_formula_term_bounds 
     296      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     297    END FUNCTION cxios_is_defined_axisgroup_formula_term_bounds 
    130298 
    131299 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/calendar_wrapper_interface_attr.F90

    r674 r1545  
    1010    ! Do not call directly / interface FORTRAN 2003 <-> C99 
    1111 
     12    SUBROUTINE cxios_set_calendar_wrapper_comment(calendar_wrapper_hdl, comment, comment_size) BIND(C) 
     13      USE ISO_C_BINDING 
     14      INTEGER (kind = C_INTPTR_T), VALUE :: calendar_wrapper_hdl 
     15      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     16      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     17    END SUBROUTINE cxios_set_calendar_wrapper_comment 
     18 
     19    SUBROUTINE cxios_get_calendar_wrapper_comment(calendar_wrapper_hdl, comment, comment_size) BIND(C) 
     20      USE ISO_C_BINDING 
     21      INTEGER (kind = C_INTPTR_T), VALUE :: calendar_wrapper_hdl 
     22      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     23      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     24    END SUBROUTINE cxios_get_calendar_wrapper_comment 
     25 
     26    FUNCTION cxios_is_defined_calendar_wrapper_comment(calendar_wrapper_hdl) BIND(C) 
     27      USE ISO_C_BINDING 
     28      LOGICAL(kind=C_BOOL) :: cxios_is_defined_calendar_wrapper_comment 
     29      INTEGER (kind = C_INTPTR_T), VALUE :: calendar_wrapper_hdl 
     30    END FUNCTION cxios_is_defined_calendar_wrapper_comment 
     31 
     32 
    1233    SUBROUTINE cxios_set_calendar_wrapper_day_length(calendar_wrapper_hdl, day_length) BIND(C) 
    1334      USE ISO_C_BINDING 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/domain_interface_attr.F90

    r1052 r1545  
    7373 
    7474 
     75    SUBROUTINE cxios_set_domain_bounds_lat_name(domain_hdl, bounds_lat_name, bounds_lat_name_size) BIND(C) 
     76      USE ISO_C_BINDING 
     77      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     78      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lat_name 
     79      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lat_name_size 
     80    END SUBROUTINE cxios_set_domain_bounds_lat_name 
     81 
     82    SUBROUTINE cxios_get_domain_bounds_lat_name(domain_hdl, bounds_lat_name, bounds_lat_name_size) BIND(C) 
     83      USE ISO_C_BINDING 
     84      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     85      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lat_name 
     86      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lat_name_size 
     87    END SUBROUTINE cxios_get_domain_bounds_lat_name 
     88 
     89    FUNCTION cxios_is_defined_domain_bounds_lat_name(domain_hdl) BIND(C) 
     90      USE ISO_C_BINDING 
     91      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lat_name 
     92      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     93    END FUNCTION cxios_is_defined_domain_bounds_lat_name 
     94 
     95 
    7596    SUBROUTINE cxios_set_domain_bounds_lon_1d(domain_hdl, bounds_lon_1d, extent) BIND(C) 
    7697      USE ISO_C_BINDING 
     
    113134      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    114135    END FUNCTION cxios_is_defined_domain_bounds_lon_2d 
     136 
     137 
     138    SUBROUTINE cxios_set_domain_bounds_lon_name(domain_hdl, bounds_lon_name, bounds_lon_name_size) BIND(C) 
     139      USE ISO_C_BINDING 
     140      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     141      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lon_name 
     142      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lon_name_size 
     143    END SUBROUTINE cxios_set_domain_bounds_lon_name 
     144 
     145    SUBROUTINE cxios_get_domain_bounds_lon_name(domain_hdl, bounds_lon_name, bounds_lon_name_size) BIND(C) 
     146      USE ISO_C_BINDING 
     147      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     148      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lon_name 
     149      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lon_name_size 
     150    END SUBROUTINE cxios_get_domain_bounds_lon_name 
     151 
     152    FUNCTION cxios_is_defined_domain_bounds_lon_name(domain_hdl) BIND(C) 
     153      USE ISO_C_BINDING 
     154      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lon_name 
     155      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     156    END FUNCTION cxios_is_defined_domain_bounds_lon_name 
     157 
     158 
     159    SUBROUTINE cxios_set_domain_comment(domain_hdl, comment, comment_size) BIND(C) 
     160      USE ISO_C_BINDING 
     161      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     162      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     163      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     164    END SUBROUTINE cxios_set_domain_comment 
     165 
     166    SUBROUTINE cxios_get_domain_comment(domain_hdl, comment, comment_size) BIND(C) 
     167      USE ISO_C_BINDING 
     168      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     169      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     170      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     171    END SUBROUTINE cxios_get_domain_comment 
     172 
     173    FUNCTION cxios_is_defined_domain_comment(domain_hdl) BIND(C) 
     174      USE ISO_C_BINDING 
     175      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_comment 
     176      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     177    END FUNCTION cxios_is_defined_domain_comment 
    115178 
    116179 
     
    250313      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    251314    END FUNCTION cxios_is_defined_domain_data_nj 
     315 
     316 
     317    SUBROUTINE cxios_set_domain_dim_i_name(domain_hdl, dim_i_name, dim_i_name_size) BIND(C) 
     318      USE ISO_C_BINDING 
     319      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     320      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_i_name 
     321      INTEGER  (kind = C_INT)     , VALUE        :: dim_i_name_size 
     322    END SUBROUTINE cxios_set_domain_dim_i_name 
     323 
     324    SUBROUTINE cxios_get_domain_dim_i_name(domain_hdl, dim_i_name, dim_i_name_size) BIND(C) 
     325      USE ISO_C_BINDING 
     326      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     327      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_i_name 
     328      INTEGER  (kind = C_INT)     , VALUE        :: dim_i_name_size 
     329    END SUBROUTINE cxios_get_domain_dim_i_name 
     330 
     331    FUNCTION cxios_is_defined_domain_dim_i_name(domain_hdl) BIND(C) 
     332      USE ISO_C_BINDING 
     333      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_dim_i_name 
     334      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     335    END FUNCTION cxios_is_defined_domain_dim_i_name 
     336 
     337 
     338    SUBROUTINE cxios_set_domain_dim_j_name(domain_hdl, dim_j_name, dim_j_name_size) BIND(C) 
     339      USE ISO_C_BINDING 
     340      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     341      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_j_name 
     342      INTEGER  (kind = C_INT)     , VALUE        :: dim_j_name_size 
     343    END SUBROUTINE cxios_set_domain_dim_j_name 
     344 
     345    SUBROUTINE cxios_get_domain_dim_j_name(domain_hdl, dim_j_name, dim_j_name_size) BIND(C) 
     346      USE ISO_C_BINDING 
     347      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     348      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_j_name 
     349      INTEGER  (kind = C_INT)     , VALUE        :: dim_j_name_size 
     350    END SUBROUTINE cxios_get_domain_dim_j_name 
     351 
     352    FUNCTION cxios_is_defined_domain_dim_j_name(domain_hdl) BIND(C) 
     353      USE ISO_C_BINDING 
     354      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_dim_j_name 
     355      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     356    END FUNCTION cxios_is_defined_domain_dim_j_name 
    252357 
    253358 
     
    353458 
    354459 
     460    SUBROUTINE cxios_set_domain_lat_name(domain_hdl, lat_name, lat_name_size) BIND(C) 
     461      USE ISO_C_BINDING 
     462      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     463      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lat_name 
     464      INTEGER  (kind = C_INT)     , VALUE        :: lat_name_size 
     465    END SUBROUTINE cxios_set_domain_lat_name 
     466 
     467    SUBROUTINE cxios_get_domain_lat_name(domain_hdl, lat_name, lat_name_size) BIND(C) 
     468      USE ISO_C_BINDING 
     469      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     470      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lat_name 
     471      INTEGER  (kind = C_INT)     , VALUE        :: lat_name_size 
     472    END SUBROUTINE cxios_get_domain_lat_name 
     473 
     474    FUNCTION cxios_is_defined_domain_lat_name(domain_hdl) BIND(C) 
     475      USE ISO_C_BINDING 
     476      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_lat_name 
     477      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     478    END FUNCTION cxios_is_defined_domain_lat_name 
     479 
     480 
    355481    SUBROUTINE cxios_set_domain_latvalue_1d(domain_hdl, latvalue_1d, extent) BIND(C) 
    356482      USE ISO_C_BINDING 
     
    393519      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    394520    END FUNCTION cxios_is_defined_domain_latvalue_2d 
     521 
     522 
     523    SUBROUTINE cxios_set_domain_lon_name(domain_hdl, lon_name, lon_name_size) BIND(C) 
     524      USE ISO_C_BINDING 
     525      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     526      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lon_name 
     527      INTEGER  (kind = C_INT)     , VALUE        :: lon_name_size 
     528    END SUBROUTINE cxios_set_domain_lon_name 
     529 
     530    SUBROUTINE cxios_get_domain_lon_name(domain_hdl, lon_name, lon_name_size) BIND(C) 
     531      USE ISO_C_BINDING 
     532      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     533      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lon_name 
     534      INTEGER  (kind = C_INT)     , VALUE        :: lon_name_size 
     535    END SUBROUTINE cxios_get_domain_lon_name 
     536 
     537    FUNCTION cxios_is_defined_domain_lon_name(domain_hdl) BIND(C) 
     538      USE ISO_C_BINDING 
     539      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_lon_name 
     540      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     541    END FUNCTION cxios_is_defined_domain_lon_name 
    395542 
    396543 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/domaingroup_interface_attr.F90

    r1052 r1545  
    7373 
    7474 
     75    SUBROUTINE cxios_set_domaingroup_bounds_lat_name(domaingroup_hdl, bounds_lat_name, bounds_lat_name_size) BIND(C) 
     76      USE ISO_C_BINDING 
     77      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     78      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lat_name 
     79      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lat_name_size 
     80    END SUBROUTINE cxios_set_domaingroup_bounds_lat_name 
     81 
     82    SUBROUTINE cxios_get_domaingroup_bounds_lat_name(domaingroup_hdl, bounds_lat_name, bounds_lat_name_size) BIND(C) 
     83      USE ISO_C_BINDING 
     84      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     85      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lat_name 
     86      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lat_name_size 
     87    END SUBROUTINE cxios_get_domaingroup_bounds_lat_name 
     88 
     89    FUNCTION cxios_is_defined_domaingroup_bounds_lat_name(domaingroup_hdl) BIND(C) 
     90      USE ISO_C_BINDING 
     91      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lat_name 
     92      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     93    END FUNCTION cxios_is_defined_domaingroup_bounds_lat_name 
     94 
     95 
    7596    SUBROUTINE cxios_set_domaingroup_bounds_lon_1d(domaingroup_hdl, bounds_lon_1d, extent) BIND(C) 
    7697      USE ISO_C_BINDING 
     
    113134      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    114135    END FUNCTION cxios_is_defined_domaingroup_bounds_lon_2d 
     136 
     137 
     138    SUBROUTINE cxios_set_domaingroup_bounds_lon_name(domaingroup_hdl, bounds_lon_name, bounds_lon_name_size) BIND(C) 
     139      USE ISO_C_BINDING 
     140      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     141      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lon_name 
     142      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lon_name_size 
     143    END SUBROUTINE cxios_set_domaingroup_bounds_lon_name 
     144 
     145    SUBROUTINE cxios_get_domaingroup_bounds_lon_name(domaingroup_hdl, bounds_lon_name, bounds_lon_name_size) BIND(C) 
     146      USE ISO_C_BINDING 
     147      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     148      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lon_name 
     149      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lon_name_size 
     150    END SUBROUTINE cxios_get_domaingroup_bounds_lon_name 
     151 
     152    FUNCTION cxios_is_defined_domaingroup_bounds_lon_name(domaingroup_hdl) BIND(C) 
     153      USE ISO_C_BINDING 
     154      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lon_name 
     155      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     156    END FUNCTION cxios_is_defined_domaingroup_bounds_lon_name 
     157 
     158 
     159    SUBROUTINE cxios_set_domaingroup_comment(domaingroup_hdl, comment, comment_size) BIND(C) 
     160      USE ISO_C_BINDING 
     161      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     162      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     163      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     164    END SUBROUTINE cxios_set_domaingroup_comment 
     165 
     166    SUBROUTINE cxios_get_domaingroup_comment(domaingroup_hdl, comment, comment_size) BIND(C) 
     167      USE ISO_C_BINDING 
     168      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     169      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     170      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     171    END SUBROUTINE cxios_get_domaingroup_comment 
     172 
     173    FUNCTION cxios_is_defined_domaingroup_comment(domaingroup_hdl) BIND(C) 
     174      USE ISO_C_BINDING 
     175      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_comment 
     176      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     177    END FUNCTION cxios_is_defined_domaingroup_comment 
    115178 
    116179 
     
    250313      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    251314    END FUNCTION cxios_is_defined_domaingroup_data_nj 
     315 
     316 
     317    SUBROUTINE cxios_set_domaingroup_dim_i_name(domaingroup_hdl, dim_i_name, dim_i_name_size) BIND(C) 
     318      USE ISO_C_BINDING 
     319      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     320      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_i_name 
     321      INTEGER  (kind = C_INT)     , VALUE        :: dim_i_name_size 
     322    END SUBROUTINE cxios_set_domaingroup_dim_i_name 
     323 
     324    SUBROUTINE cxios_get_domaingroup_dim_i_name(domaingroup_hdl, dim_i_name, dim_i_name_size) BIND(C) 
     325      USE ISO_C_BINDING 
     326      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     327      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_i_name 
     328      INTEGER  (kind = C_INT)     , VALUE        :: dim_i_name_size 
     329    END SUBROUTINE cxios_get_domaingroup_dim_i_name 
     330 
     331    FUNCTION cxios_is_defined_domaingroup_dim_i_name(domaingroup_hdl) BIND(C) 
     332      USE ISO_C_BINDING 
     333      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_dim_i_name 
     334      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     335    END FUNCTION cxios_is_defined_domaingroup_dim_i_name 
     336 
     337 
     338    SUBROUTINE cxios_set_domaingroup_dim_j_name(domaingroup_hdl, dim_j_name, dim_j_name_size) BIND(C) 
     339      USE ISO_C_BINDING 
     340      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     341      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_j_name 
     342      INTEGER  (kind = C_INT)     , VALUE        :: dim_j_name_size 
     343    END SUBROUTINE cxios_set_domaingroup_dim_j_name 
     344 
     345    SUBROUTINE cxios_get_domaingroup_dim_j_name(domaingroup_hdl, dim_j_name, dim_j_name_size) BIND(C) 
     346      USE ISO_C_BINDING 
     347      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     348      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_j_name 
     349      INTEGER  (kind = C_INT)     , VALUE        :: dim_j_name_size 
     350    END SUBROUTINE cxios_get_domaingroup_dim_j_name 
     351 
     352    FUNCTION cxios_is_defined_domaingroup_dim_j_name(domaingroup_hdl) BIND(C) 
     353      USE ISO_C_BINDING 
     354      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_dim_j_name 
     355      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     356    END FUNCTION cxios_is_defined_domaingroup_dim_j_name 
    252357 
    253358 
     
    374479 
    375480 
     481    SUBROUTINE cxios_set_domaingroup_lat_name(domaingroup_hdl, lat_name, lat_name_size) BIND(C) 
     482      USE ISO_C_BINDING 
     483      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     484      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lat_name 
     485      INTEGER  (kind = C_INT)     , VALUE        :: lat_name_size 
     486    END SUBROUTINE cxios_set_domaingroup_lat_name 
     487 
     488    SUBROUTINE cxios_get_domaingroup_lat_name(domaingroup_hdl, lat_name, lat_name_size) BIND(C) 
     489      USE ISO_C_BINDING 
     490      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     491      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lat_name 
     492      INTEGER  (kind = C_INT)     , VALUE        :: lat_name_size 
     493    END SUBROUTINE cxios_get_domaingroup_lat_name 
     494 
     495    FUNCTION cxios_is_defined_domaingroup_lat_name(domaingroup_hdl) BIND(C) 
     496      USE ISO_C_BINDING 
     497      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_lat_name 
     498      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     499    END FUNCTION cxios_is_defined_domaingroup_lat_name 
     500 
     501 
    376502    SUBROUTINE cxios_set_domaingroup_latvalue_1d(domaingroup_hdl, latvalue_1d, extent) BIND(C) 
    377503      USE ISO_C_BINDING 
     
    414540      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    415541    END FUNCTION cxios_is_defined_domaingroup_latvalue_2d 
     542 
     543 
     544    SUBROUTINE cxios_set_domaingroup_lon_name(domaingroup_hdl, lon_name, lon_name_size) BIND(C) 
     545      USE ISO_C_BINDING 
     546      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     547      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lon_name 
     548      INTEGER  (kind = C_INT)     , VALUE        :: lon_name_size 
     549    END SUBROUTINE cxios_set_domaingroup_lon_name 
     550 
     551    SUBROUTINE cxios_get_domaingroup_lon_name(domaingroup_hdl, lon_name, lon_name_size) BIND(C) 
     552      USE ISO_C_BINDING 
     553      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     554      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lon_name 
     555      INTEGER  (kind = C_INT)     , VALUE        :: lon_name_size 
     556    END SUBROUTINE cxios_get_domaingroup_lon_name 
     557 
     558    FUNCTION cxios_is_defined_domaingroup_lon_name(domaingroup_hdl) BIND(C) 
     559      USE ISO_C_BINDING 
     560      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_lon_name 
     561      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     562    END FUNCTION cxios_is_defined_domaingroup_lon_name 
    416563 
    417564 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/field_interface_attr.F90

    r1205 r1545  
    111111 
    112112 
     113    SUBROUTINE cxios_set_field_comment(field_hdl, comment, comment_size) BIND(C) 
     114      USE ISO_C_BINDING 
     115      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     116      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     117      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     118    END SUBROUTINE cxios_set_field_comment 
     119 
     120    SUBROUTINE cxios_get_field_comment(field_hdl, comment, comment_size) BIND(C) 
     121      USE ISO_C_BINDING 
     122      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     123      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     124      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     125    END SUBROUTINE cxios_get_field_comment 
     126 
     127    FUNCTION cxios_is_defined_field_comment(field_hdl) BIND(C) 
     128      USE ISO_C_BINDING 
     129      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_comment 
     130      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     131    END FUNCTION cxios_is_defined_field_comment 
     132 
     133 
    113134    SUBROUTINE cxios_set_field_compression_level(field_hdl, compression_level) BIND(C) 
    114135      USE ISO_C_BINDING 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/fieldgroup_interface_attr.F90

    r1205 r1545  
    111111 
    112112 
     113    SUBROUTINE cxios_set_fieldgroup_comment(fieldgroup_hdl, comment, comment_size) BIND(C) 
     114      USE ISO_C_BINDING 
     115      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     116      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     117      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     118    END SUBROUTINE cxios_set_fieldgroup_comment 
     119 
     120    SUBROUTINE cxios_get_fieldgroup_comment(fieldgroup_hdl, comment, comment_size) BIND(C) 
     121      USE ISO_C_BINDING 
     122      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     123      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     124      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     125    END SUBROUTINE cxios_get_fieldgroup_comment 
     126 
     127    FUNCTION cxios_is_defined_fieldgroup_comment(fieldgroup_hdl) BIND(C) 
     128      USE ISO_C_BINDING 
     129      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_comment 
     130      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     131    END FUNCTION cxios_is_defined_fieldgroup_comment 
     132 
     133 
    113134    SUBROUTINE cxios_set_fieldgroup_compression_level(fieldgroup_hdl, compression_level) BIND(C) 
    114135      USE ISO_C_BINDING 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/file_interface_attr.F90

    r1205 r1545  
    2929 
    3030 
     31    SUBROUTINE cxios_set_file_comment(file_hdl, comment, comment_size) BIND(C) 
     32      USE ISO_C_BINDING 
     33      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     34      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     35      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     36    END SUBROUTINE cxios_set_file_comment 
     37 
     38    SUBROUTINE cxios_get_file_comment(file_hdl, comment, comment_size) BIND(C) 
     39      USE ISO_C_BINDING 
     40      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     41      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     42      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     43    END SUBROUTINE cxios_get_file_comment 
     44 
     45    FUNCTION cxios_is_defined_file_comment(file_hdl) BIND(C) 
     46      USE ISO_C_BINDING 
     47      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_comment 
     48      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     49    END FUNCTION cxios_is_defined_file_comment 
     50 
     51 
    3152    SUBROUTINE cxios_set_file_compression_level(file_hdl, compression_level) BIND(C) 
    3253      USE ISO_C_BINDING 
     
    313334 
    314335 
     336    SUBROUTINE cxios_set_file_read_metadata_par(file_hdl, read_metadata_par) BIND(C) 
     337      USE ISO_C_BINDING 
     338      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     339      LOGICAL (KIND=C_BOOL)      , VALUE :: read_metadata_par 
     340    END SUBROUTINE cxios_set_file_read_metadata_par 
     341 
     342    SUBROUTINE cxios_get_file_read_metadata_par(file_hdl, read_metadata_par) BIND(C) 
     343      USE ISO_C_BINDING 
     344      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     345      LOGICAL (KIND=C_BOOL)             :: read_metadata_par 
     346    END SUBROUTINE cxios_get_file_read_metadata_par 
     347 
     348    FUNCTION cxios_is_defined_file_read_metadata_par(file_hdl) BIND(C) 
     349      USE ISO_C_BINDING 
     350      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_read_metadata_par 
     351      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     352    END FUNCTION cxios_is_defined_file_read_metadata_par 
     353 
     354 
    315355    SUBROUTINE cxios_set_file_record_offset(file_hdl, record_offset) BIND(C) 
    316356      USE ISO_C_BINDING 
     
    330370      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
    331371    END FUNCTION cxios_is_defined_file_record_offset 
     372 
     373 
     374    SUBROUTINE cxios_set_file_split_end_offset(file_hdl, split_end_offset) BIND(C) 
     375      USE ISO_C_BINDING 
     376      USE IDURATION 
     377      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     378      TYPE(txios(duration)), VALUE :: split_end_offset 
     379    END SUBROUTINE cxios_set_file_split_end_offset 
     380 
     381    SUBROUTINE cxios_get_file_split_end_offset(file_hdl, split_end_offset) BIND(C) 
     382      USE ISO_C_BINDING 
     383      USE IDURATION 
     384      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     385      TYPE(txios(duration)) :: split_end_offset 
     386    END SUBROUTINE cxios_get_file_split_end_offset 
     387 
     388    FUNCTION cxios_is_defined_file_split_end_offset(file_hdl) BIND(C) 
     389      USE ISO_C_BINDING 
     390      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_split_end_offset 
     391      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     392    END FUNCTION cxios_is_defined_file_split_end_offset 
    332393 
    333394 
     
    374435 
    375436 
     437    SUBROUTINE cxios_set_file_split_last_date(file_hdl, split_last_date, split_last_date_size) BIND(C) 
     438      USE ISO_C_BINDING 
     439      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     440      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_last_date 
     441      INTEGER  (kind = C_INT)     , VALUE        :: split_last_date_size 
     442    END SUBROUTINE cxios_set_file_split_last_date 
     443 
     444    SUBROUTINE cxios_get_file_split_last_date(file_hdl, split_last_date, split_last_date_size) BIND(C) 
     445      USE ISO_C_BINDING 
     446      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     447      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_last_date 
     448      INTEGER  (kind = C_INT)     , VALUE        :: split_last_date_size 
     449    END SUBROUTINE cxios_get_file_split_last_date 
     450 
     451    FUNCTION cxios_is_defined_file_split_last_date(file_hdl) BIND(C) 
     452      USE ISO_C_BINDING 
     453      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_split_last_date 
     454      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     455    END FUNCTION cxios_is_defined_file_split_last_date 
     456 
     457 
     458    SUBROUTINE cxios_set_file_split_start_offset(file_hdl, split_start_offset) BIND(C) 
     459      USE ISO_C_BINDING 
     460      USE IDURATION 
     461      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     462      TYPE(txios(duration)), VALUE :: split_start_offset 
     463    END SUBROUTINE cxios_set_file_split_start_offset 
     464 
     465    SUBROUTINE cxios_get_file_split_start_offset(file_hdl, split_start_offset) BIND(C) 
     466      USE ISO_C_BINDING 
     467      USE IDURATION 
     468      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     469      TYPE(txios(duration)) :: split_start_offset 
     470    END SUBROUTINE cxios_get_file_split_start_offset 
     471 
     472    FUNCTION cxios_is_defined_file_split_start_offset(file_hdl) BIND(C) 
     473      USE ISO_C_BINDING 
     474      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_split_start_offset 
     475      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     476    END FUNCTION cxios_is_defined_file_split_start_offset 
     477 
     478 
    376479    SUBROUTINE cxios_set_file_sync_freq(file_hdl, sync_freq) BIND(C) 
    377480      USE ISO_C_BINDING 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/filegroup_interface_attr.F90

    r1205 r1545  
    2929 
    3030 
     31    SUBROUTINE cxios_set_filegroup_comment(filegroup_hdl, comment, comment_size) BIND(C) 
     32      USE ISO_C_BINDING 
     33      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     34      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     35      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     36    END SUBROUTINE cxios_set_filegroup_comment 
     37 
     38    SUBROUTINE cxios_get_filegroup_comment(filegroup_hdl, comment, comment_size) BIND(C) 
     39      USE ISO_C_BINDING 
     40      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     41      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     42      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     43    END SUBROUTINE cxios_get_filegroup_comment 
     44 
     45    FUNCTION cxios_is_defined_filegroup_comment(filegroup_hdl) BIND(C) 
     46      USE ISO_C_BINDING 
     47      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_comment 
     48      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     49    END FUNCTION cxios_is_defined_filegroup_comment 
     50 
     51 
    3152    SUBROUTINE cxios_set_filegroup_compression_level(filegroup_hdl, compression_level) BIND(C) 
    3253      USE ISO_C_BINDING 
     
    334355 
    335356 
     357    SUBROUTINE cxios_set_filegroup_read_metadata_par(filegroup_hdl, read_metadata_par) BIND(C) 
     358      USE ISO_C_BINDING 
     359      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     360      LOGICAL (KIND=C_BOOL)      , VALUE :: read_metadata_par 
     361    END SUBROUTINE cxios_set_filegroup_read_metadata_par 
     362 
     363    SUBROUTINE cxios_get_filegroup_read_metadata_par(filegroup_hdl, read_metadata_par) BIND(C) 
     364      USE ISO_C_BINDING 
     365      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     366      LOGICAL (KIND=C_BOOL)             :: read_metadata_par 
     367    END SUBROUTINE cxios_get_filegroup_read_metadata_par 
     368 
     369    FUNCTION cxios_is_defined_filegroup_read_metadata_par(filegroup_hdl) BIND(C) 
     370      USE ISO_C_BINDING 
     371      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_read_metadata_par 
     372      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     373    END FUNCTION cxios_is_defined_filegroup_read_metadata_par 
     374 
     375 
    336376    SUBROUTINE cxios_set_filegroup_record_offset(filegroup_hdl, record_offset) BIND(C) 
    337377      USE ISO_C_BINDING 
     
    351391      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
    352392    END FUNCTION cxios_is_defined_filegroup_record_offset 
     393 
     394 
     395    SUBROUTINE cxios_set_filegroup_split_end_offset(filegroup_hdl, split_end_offset) BIND(C) 
     396      USE ISO_C_BINDING 
     397      USE IDURATION 
     398      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     399      TYPE(txios(duration)), VALUE :: split_end_offset 
     400    END SUBROUTINE cxios_set_filegroup_split_end_offset 
     401 
     402    SUBROUTINE cxios_get_filegroup_split_end_offset(filegroup_hdl, split_end_offset) BIND(C) 
     403      USE ISO_C_BINDING 
     404      USE IDURATION 
     405      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     406      TYPE(txios(duration)) :: split_end_offset 
     407    END SUBROUTINE cxios_get_filegroup_split_end_offset 
     408 
     409    FUNCTION cxios_is_defined_filegroup_split_end_offset(filegroup_hdl) BIND(C) 
     410      USE ISO_C_BINDING 
     411      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_split_end_offset 
     412      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     413    END FUNCTION cxios_is_defined_filegroup_split_end_offset 
    353414 
    354415 
     
    395456 
    396457 
     458    SUBROUTINE cxios_set_filegroup_split_last_date(filegroup_hdl, split_last_date, split_last_date_size) BIND(C) 
     459      USE ISO_C_BINDING 
     460      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     461      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_last_date 
     462      INTEGER  (kind = C_INT)     , VALUE        :: split_last_date_size 
     463    END SUBROUTINE cxios_set_filegroup_split_last_date 
     464 
     465    SUBROUTINE cxios_get_filegroup_split_last_date(filegroup_hdl, split_last_date, split_last_date_size) BIND(C) 
     466      USE ISO_C_BINDING 
     467      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     468      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_last_date 
     469      INTEGER  (kind = C_INT)     , VALUE        :: split_last_date_size 
     470    END SUBROUTINE cxios_get_filegroup_split_last_date 
     471 
     472    FUNCTION cxios_is_defined_filegroup_split_last_date(filegroup_hdl) BIND(C) 
     473      USE ISO_C_BINDING 
     474      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_split_last_date 
     475      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     476    END FUNCTION cxios_is_defined_filegroup_split_last_date 
     477 
     478 
     479    SUBROUTINE cxios_set_filegroup_split_start_offset(filegroup_hdl, split_start_offset) BIND(C) 
     480      USE ISO_C_BINDING 
     481      USE IDURATION 
     482      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     483      TYPE(txios(duration)), VALUE :: split_start_offset 
     484    END SUBROUTINE cxios_set_filegroup_split_start_offset 
     485 
     486    SUBROUTINE cxios_get_filegroup_split_start_offset(filegroup_hdl, split_start_offset) BIND(C) 
     487      USE ISO_C_BINDING 
     488      USE IDURATION 
     489      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     490      TYPE(txios(duration)) :: split_start_offset 
     491    END SUBROUTINE cxios_get_filegroup_split_start_offset 
     492 
     493    FUNCTION cxios_is_defined_filegroup_split_start_offset(filegroup_hdl) BIND(C) 
     494      USE ISO_C_BINDING 
     495      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_split_start_offset 
     496      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     497    END FUNCTION cxios_is_defined_filegroup_split_start_offset 
     498 
     499 
    397500    SUBROUTINE cxios_set_filegroup_sync_freq(filegroup_hdl, sync_freq) BIND(C) 
    398501      USE ISO_C_BINDING 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/grid_interface_attr.F90

    r932 r1545  
    1010    ! Do not call directly / interface FORTRAN 2003 <-> C99 
    1111 
     12    SUBROUTINE cxios_set_grid_comment(grid_hdl, comment, comment_size) BIND(C) 
     13      USE ISO_C_BINDING 
     14      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl 
     15      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     16      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     17    END SUBROUTINE cxios_set_grid_comment 
     18 
     19    SUBROUTINE cxios_get_grid_comment(grid_hdl, comment, comment_size) BIND(C) 
     20      USE ISO_C_BINDING 
     21      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl 
     22      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     23      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     24    END SUBROUTINE cxios_get_grid_comment 
     25 
     26    FUNCTION cxios_is_defined_grid_comment(grid_hdl) BIND(C) 
     27      USE ISO_C_BINDING 
     28      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_comment 
     29      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl 
     30    END FUNCTION cxios_is_defined_grid_comment 
     31 
     32 
    1233    SUBROUTINE cxios_set_grid_description(grid_hdl, description, description_size) BIND(C) 
    1334      USE ISO_C_BINDING 
     
    3152 
    3253 
     54    SUBROUTINE cxios_set_grid_mask_0d(grid_hdl, mask_0d, extent) BIND(C) 
     55      USE ISO_C_BINDING 
     56      INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl 
     57      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_0d 
     58      INTEGER (kind = C_INT), DIMENSION(*)     :: extent 
     59    END SUBROUTINE cxios_set_grid_mask_0d 
     60 
     61    SUBROUTINE cxios_get_grid_mask_0d(grid_hdl, mask_0d, extent) BIND(C) 
     62      USE ISO_C_BINDING 
     63      INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl 
     64      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_0d 
     65      INTEGER (kind = C_INT), DIMENSION(*)     :: extent 
     66    END SUBROUTINE cxios_get_grid_mask_0d 
     67 
     68    FUNCTION cxios_is_defined_grid_mask_0d(grid_hdl) BIND(C) 
     69      USE ISO_C_BINDING 
     70      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_mask_0d 
     71      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl 
     72    END FUNCTION cxios_is_defined_grid_mask_0d 
     73 
     74 
    3375    SUBROUTINE cxios_set_grid_mask_1d(grid_hdl, mask_1d, extent) BIND(C) 
    3476      USE ISO_C_BINDING 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/gridgroup_interface_attr.F90

    r932 r1545  
    1010    ! Do not call directly / interface FORTRAN 2003 <-> C99 
    1111 
     12    SUBROUTINE cxios_set_gridgroup_comment(gridgroup_hdl, comment, comment_size) BIND(C) 
     13      USE ISO_C_BINDING 
     14      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl 
     15      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     16      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     17    END SUBROUTINE cxios_set_gridgroup_comment 
     18 
     19    SUBROUTINE cxios_get_gridgroup_comment(gridgroup_hdl, comment, comment_size) BIND(C) 
     20      USE ISO_C_BINDING 
     21      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl 
     22      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     23      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     24    END SUBROUTINE cxios_get_gridgroup_comment 
     25 
     26    FUNCTION cxios_is_defined_gridgroup_comment(gridgroup_hdl) BIND(C) 
     27      USE ISO_C_BINDING 
     28      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_comment 
     29      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl 
     30    END FUNCTION cxios_is_defined_gridgroup_comment 
     31 
     32 
    1233    SUBROUTINE cxios_set_gridgroup_description(gridgroup_hdl, description, description_size) BIND(C) 
    1334      USE ISO_C_BINDING 
     
    5273 
    5374 
     75    SUBROUTINE cxios_set_gridgroup_mask_0d(gridgroup_hdl, mask_0d, extent) BIND(C) 
     76      USE ISO_C_BINDING 
     77      INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl 
     78      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_0d 
     79      INTEGER (kind = C_INT), DIMENSION(*)     :: extent 
     80    END SUBROUTINE cxios_set_gridgroup_mask_0d 
     81 
     82    SUBROUTINE cxios_get_gridgroup_mask_0d(gridgroup_hdl, mask_0d, extent) BIND(C) 
     83      USE ISO_C_BINDING 
     84      INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl 
     85      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_0d 
     86      INTEGER (kind = C_INT), DIMENSION(*)     :: extent 
     87    END SUBROUTINE cxios_get_gridgroup_mask_0d 
     88 
     89    FUNCTION cxios_is_defined_gridgroup_mask_0d(gridgroup_hdl) BIND(C) 
     90      USE ISO_C_BINDING 
     91      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_mask_0d 
     92      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl 
     93    END FUNCTION cxios_is_defined_gridgroup_mask_0d 
     94 
     95 
    5496    SUBROUTINE cxios_set_gridgroup_mask_1d(gridgroup_hdl, mask_1d, extent) BIND(C) 
    5597      USE ISO_C_BINDING 
  • XIOS/dev/branch_openmp/src/interface/fortran_attr/iaxis_attr.F90

    r1052 r1545  
    1212 
    1313  SUBROUTINE xios(set_axis_attr)  & 
    14     ( axis_id, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    15     , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    16      ) 
     14    ( axis_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     15    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     16    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     17    , value ) 
    1718 
    1819    IMPLICIT NONE 
     
    2021      CHARACTER(LEN=*), INTENT(IN) ::axis_id 
    2122      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref 
     23      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_type 
    2224      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
    2325      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:) 
     26      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name 
     27      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    2428      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin 
    2529      INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:) 
    2630      INTEGER  , OPTIONAL, INTENT(IN) :: data_n 
     31      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_name 
     32      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula 
     33      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_bounds 
     34      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term 
     35      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_bounds 
    2736      INTEGER  , OPTIONAL, INTENT(IN) :: index(:) 
    2837      CHARACTER(len=*) , OPTIONAL, INTENT(IN) :: label(:) 
     
    4352      (axis_id,axis_hdl) 
    4453      CALL xios(set_axis_attr_hdl_)   & 
    45       ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    46       , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    47        ) 
     54      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     55      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     56      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     57      , value ) 
    4858 
    4959  END SUBROUTINE xios(set_axis_attr) 
    5060 
    5161  SUBROUTINE xios(set_axis_attr_hdl)  & 
    52     ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    53     , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    54      ) 
     62    ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     63    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     64    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     65    , value ) 
    5566 
    5667    IMPLICIT NONE 
    5768      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    5869      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref 
     70      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_type 
    5971      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
    6072      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:) 
     73      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name 
     74      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    6175      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin 
    6276      INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:) 
    6377      INTEGER  , OPTIONAL, INTENT(IN) :: data_n 
     78      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_name 
     79      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula 
     80      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_bounds 
     81      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term 
     82      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_bounds 
    6483      INTEGER  , OPTIONAL, INTENT(IN) :: index(:) 
    6584      CHARACTER(len=*) , OPTIONAL, INTENT(IN) :: label(:) 
     
    7897 
    7998      CALL xios(set_axis_attr_hdl_)  & 
    80       ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    81       , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    82        ) 
     99      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     100      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     101      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     102      , value ) 
    83103 
    84104  END SUBROUTINE xios(set_axis_attr_hdl) 
    85105 
    86106  SUBROUTINE xios(set_axis_attr_hdl_)   & 
    87     ( axis_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, index_, label_, long_name_  & 
    88     , mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_, unit_  & 
    89     , value_ ) 
     107    ( axis_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_, data_index_  & 
     108    , data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_, index_  & 
     109    , label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_  & 
     110    , unit_, value_ ) 
    90111 
    91112    IMPLICIT NONE 
    92113      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    93114      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref_ 
     115      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_type_ 
    94116      INTEGER  , OPTIONAL, INTENT(IN) :: begin_ 
    95117      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_(:,:) 
     118      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name_ 
     119      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_ 
    96120      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin_ 
    97121      INTEGER  , OPTIONAL, INTENT(IN) :: data_index_(:) 
    98122      INTEGER  , OPTIONAL, INTENT(IN) :: data_n_ 
     123      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_name_ 
     124      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_ 
     125      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_bounds_ 
     126      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_ 
     127      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_bounds_ 
    99128      INTEGER  , OPTIONAL, INTENT(IN) :: index_(:) 
    100129      CHARACTER(len=*) , OPTIONAL, INTENT(IN) :: label_(:) 
     
    117146      ENDIF 
    118147 
     148      IF (PRESENT(axis_type_)) THEN 
     149        CALL cxios_set_axis_axis_type & 
     150      (axis_hdl%daddr, axis_type_, len(axis_type_)) 
     151      ENDIF 
     152 
    119153      IF (PRESENT(begin_)) THEN 
    120154        CALL cxios_set_axis_begin & 
     
    127161      ENDIF 
    128162 
     163      IF (PRESENT(bounds_name_)) THEN 
     164        CALL cxios_set_axis_bounds_name & 
     165      (axis_hdl%daddr, bounds_name_, len(bounds_name_)) 
     166      ENDIF 
     167 
     168      IF (PRESENT(comment_)) THEN 
     169        CALL cxios_set_axis_comment & 
     170      (axis_hdl%daddr, comment_, len(comment_)) 
     171      ENDIF 
     172 
    129173      IF (PRESENT(data_begin_)) THEN 
    130174        CALL cxios_set_axis_data_begin & 
     
    140184        CALL cxios_set_axis_data_n & 
    141185      (axis_hdl%daddr, data_n_) 
     186      ENDIF 
     187 
     188      IF (PRESENT(dim_name_)) THEN 
     189        CALL cxios_set_axis_dim_name & 
     190      (axis_hdl%daddr, dim_name_, len(dim_name_)) 
     191      ENDIF 
     192 
     193      IF (PRESENT(formula_)) THEN 
     194        CALL cxios_set_axis_formula & 
     195      (axis_hdl%daddr, formula_, len(formula_)) 
     196      ENDIF 
     197 
     198      IF (PRESENT(formula_bounds_)) THEN 
     199        CALL cxios_set_axis_formula_bounds & 
     200      (axis_hdl%daddr, formula_bounds_, len(formula_bounds_)) 
     201      ENDIF 
     202 
     203      IF (PRESENT(formula_term_)) THEN 
     204        CALL cxios_set_axis_formula_term & 
     205      (axis_hdl%daddr, formula_term_, len(formula_term_)) 
     206      ENDIF 
     207 
     208      IF (PRESENT(formula_term_bounds_)) THEN 
     209        CALL cxios_set_axis_formula_term_bounds & 
     210      (axis_hdl%daddr, formula_term_bounds_, len(formula_term_bounds_)) 
    142211      ENDIF 
    143212 
     
    212281 
    213282  SUBROUTINE xios(get_axis_attr)  & 
    214     ( axis_id, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    215     , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    216      ) 
     283    ( axis_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     284    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     285    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     286    , value ) 
    217287 
    218288    IMPLICIT NONE 
     
    220290      CHARACTER(LEN=*), INTENT(IN) ::axis_id 
    221291      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref 
     292      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_type 
    222293      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
    223294      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:) 
     295      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name 
     296      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment 
    224297      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin 
    225298      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:) 
    226299      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n 
     300      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_name 
     301      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula 
     302      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_bounds 
     303      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term 
     304      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_bounds 
    227305      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:) 
    228306      CHARACTER(len=*) , OPTIONAL, INTENT(OUT) :: label(:) 
     
    243321      (axis_id,axis_hdl) 
    244322      CALL xios(get_axis_attr_hdl_)   & 
    245       ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    246       , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    247        ) 
     323      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     324      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     325      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     326      , value ) 
    248327 
    249328  END SUBROUTINE xios(get_axis_attr) 
    250329 
    251330  SUBROUTINE xios(get_axis_attr_hdl)  & 
    252     ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    253     , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    254      ) 
     331    ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     332    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     333    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     334    , value ) 
    255335 
    256336    IMPLICIT NONE 
    257337      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    258338      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref 
     339      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_type 
    259340      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
    260341      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:) 
     342      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name 
     343      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment 
    261344      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin 
    262345      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:) 
    263346      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n 
     347      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_name 
     348      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula 
     349      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_bounds 
     350      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term 
     351      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_bounds 
    264352      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:) 
    265353      CHARACTER(len=*) , OPTIONAL, INTENT(OUT) :: label(:) 
     
    278366 
    279367      CALL xios(get_axis_attr_hdl_)  & 
    280       ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    281       , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    282        ) 
     368      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     369      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     370      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     371      , value ) 
    283372 
    284373  END SUBROUTINE xios(get_axis_attr_hdl) 
    285374 
    286375  SUBROUTINE xios(get_axis_attr_hdl_)   & 
    287     ( axis_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, index_, label_, long_name_  & 
    288     , mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_, unit_  & 
    289     , value_ ) 
     376    ( axis_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_, data_index_  & 
     377    , data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_, index_  & 
     378    , label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_  & 
     379    , unit_, value_ ) 
    290380 
    291381    IMPLICIT NONE 
    292382      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    293383      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref_ 
     384      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_type_ 
    294385      INTEGER  , OPTIONAL, INTENT(OUT) :: begin_ 
    295386      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_(:,:) 
     387      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name_ 
     388      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment_ 
    296389      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin_ 
    297390      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index_(:) 
    298391      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_ 
     392      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_name_ 
     393      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_ 
     394      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_bounds_ 
     395      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_ 
     396      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_bounds_ 
    299397      INTEGER  , OPTIONAL, INTENT(OUT) :: index_(:) 
    300398      CHARACTER(len=*) , OPTIONAL, INTENT(OUT) :: label_(:) 
     
    317415      ENDIF 
    318416 
     417      IF (PRESENT(axis_type_)) THEN 
     418        CALL cxios_get_axis_axis_type & 
     419      (axis_hdl%daddr, axis_type_, len(axis_type_)) 
     420      ENDIF 
     421 
    319422      IF (PRESENT(begin_)) THEN 
    320423        CALL cxios_get_axis_begin &