Changeset 445


Ignore:
Timestamp:
06/19/13 10:09:36 (8 years ago)
Author:
ymipsl
Message:

Add possibility to make inheritance of attributes and reference before closing the context definition.
New fortran fonction : xios_solve inheritance()
After this call, the value of attribute have the inherited value of their parent.

YM

Location:
XIOS/trunk/src
Files:
34 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/attribute.hpp

    r432 r445  
    6666            virtual void generateFortranInterfaceIsDefinedBody_(ostream& oss,const string& className) ; 
    6767 
    68  
     68            virtual void setInheritedValue(const CAttribute& ) = 0 ; 
     69            virtual bool hasInheritedValue(void) const = 0; 
    6970             
    7071         protected : 
  • XIOS/trunk/src/attribute_array.hpp

    r392 r445  
    3737            void set(const CAttributeArray& attr) ; 
    3838             
     39            void setInheritedValue(const CAttributeArray& attr ); 
     40            void setInheritedValue(const CAttribute& attr ); 
     41            CArray<T_numtype, N_rank> getInheritedValue(void) const ; 
     42            bool hasInheritedValue(void) const;             
     43 
    3944            /// Destructeur /// 
    4045            virtual ~CAttributeArray(void) { } 
     
    6267 
    6368         private : 
     69          CArray<T_numtype, N_rank> inheritedValue ; 
    6470          StdString _toString(void) const; 
    6571          void _fromString(const StdString & str); 
  • XIOS/trunk/src/attribute_array_impl.hpp

    r369 r445  
    6565      this->setValue(attr) ; 
    6666    }  
     67     
     68     
     69    template <typename T_numtype, int N_rank> 
     70    void CAttributeArray<T_numtype,N_rank>::setInheritedValue(const CAttribute& attr) 
     71    { 
     72      this->setInheritedValue(dynamic_cast<const CAttributeArray<T_numtype,N_rank>& >(attr)) ; 
     73    }  
     74 
     75    template <typename T_numtype, int N_rank> 
     76    void CAttributeArray<T_numtype,N_rank>::setInheritedValue(const CAttributeArray& attr) 
     77    { 
     78      if (this->isEmpty() && attr.hasInheritedValue()) inheritedValue=attr ; 
     79     }  
     80 
     81    template <typename T_numtype, int N_rank> 
     82    CArray<T_numtype,N_rank> CAttributeArray<T_numtype,N_rank>::getInheritedValue(void) const 
     83    { 
     84      if (this->isEmpty()) return inheritedValue.copy() ; 
     85      else return getValue() ; 
     86    }  
     87     
     88    template <typename T_numtype, int N_rank> 
     89    bool CAttributeArray<T_numtype,N_rank>::hasInheritedValue(void) const 
     90    { 
     91      return !this->isEmpty() || !inheritedValue.isEmpty() ; 
     92    }  
     93     
    6794 
    6895    template <typename T_numtype, int N_rank> 
  • XIOS/trunk/src/attribute_enum.hpp

    r369 r445  
    4040            void set(const CAttributeEnum& attr) ; 
    4141             
     42            void setInheritedValue(const CAttributeEnum& attr ); 
     43            void setInheritedValue(const CAttribute& attr ); 
     44            T_enum getInheritedValue(void)  const; 
     45            string getInheritedStringValue(void) const; 
     46            bool hasInheritedValue(void) const;           
     47           
    4248            /// Destructeur /// 
    4349            virtual ~CAttributeEnum(void) { } 
     
    7278          bool _toBuffer  (CBufferOut& buffer) const; 
    7379          bool _fromBuffer(CBufferIn& buffer) ; 
     80          CEnum<T> inheritedValue ; 
    7481      }; // class CAttributeEnum     
    7582    
  • XIOS/trunk/src/attribute_enum_impl.hpp

    r380 r445  
    7575    }  
    7676 
     77     
     78    template <class T> 
     79    void CAttributeEnum<T>::setInheritedValue(const CAttribute& attr) 
     80    { 
     81      this->setInheritedValue(dynamic_cast<const CAttributeEnum<T>& >(attr)) ; 
     82    }  
     83 
     84    template <class T> 
     85    void CAttributeEnum<T>::setInheritedValue(const CAttributeEnum& attr) 
     86    { 
     87      if (this->isEmpty() && attr.hasInheritedValue()) inheritedValue.set(attr.getInheritedValue()) ; 
     88    }  
     89 
     90    template <class T> 
     91    typename T::t_enum CAttributeEnum<T>::getInheritedValue(void) const 
     92    { 
     93      if (this->isEmpty()) return inheritedValue.get() ; 
     94      else return getValue() ; 
     95    }  
     96     
     97    template <class T> 
     98    string CAttributeEnum<T>::getInheritedStringValue(void) const 
     99    { 
     100       return CEnum<T>::toString() ; 
     101       if (this->isEmpty()) return inheritedValue.toString() ; 
     102       else return CEnum<T>::toString() ; ; 
     103    } 
     104     
     105    template <class T> 
     106    bool CAttributeEnum<T>::hasInheritedValue(void) const 
     107    { 
     108      return !this->isEmpty() || !inheritedValue.isEmpty() ; 
     109    }  
     110     
    77111      //--------------------------------------------------------------- 
    78112 
  • XIOS/trunk/src/attribute_map.cpp

    r432 r445  
    107107      //--------------------------------------------------------------- 
    108108       
    109       void CAttributeMap::setAttributes(const CAttributeMap * const _parent) 
     109      void CAttributeMap::setAttributes(const CAttributeMap * const _parent, bool apply) 
    110110      { 
    111111         typedef std::pair<StdString, CAttribute*> StdStrAttPair; 
     
    117117            if (this->hasAttribute(el.first)) 
    118118            { 
    119                CAttribute * currAtt = CAttributeMap::operator[](el.first); 
    120                if (currAtt->isEmpty() && !el.second->isEmpty()) 
     119               CAttribute * currentAtt = CAttributeMap::operator[](el.first); 
     120               CAttribute * parentAtt = el.second ; 
     121               if (apply) 
    121122               { 
    122                   this->setAttribute(el.first, el.second); 
     123                 if (currentAtt->isEmpty() && !el.second->isEmpty()) 
     124                 { 
     125                    this->setAttribute(el.first, el.second); 
     126                 } 
    123127               } 
     128               else currentAtt->setInheritedValue(*parentAtt) ; 
    124129            } 
    125130         } 
  • XIOS/trunk/src/attribute_map.hpp

    r432 r445  
    2929 
    3030            void setAttributes(const xml::THashAttributes & attributes); 
    31             void setAttributes(const CAttributeMap * const _parent); 
     31            void setAttributes(const CAttributeMap * const _parent, bool apply=true); 
    3232 
    3333            void clearAllAttributes(void); 
  • XIOS/trunk/src/attribute_template.hpp

    r432 r445  
    4848            void set(const CAttribute& attr) ; 
    4949            void set(const CAttributeTemplate& attr) ; 
     50 
     51            void setInheritedValue(const CAttributeTemplate& attr ); 
     52            void setInheritedValue(const CAttribute& attr ); 
     53            T getInheritedValue(void) const ; 
     54            bool hasInheritedValue(void) const; 
    5055             
    5156            /// Destructeur /// 
     
    8792          bool _toBuffer  (CBufferOut& buffer) const; 
    8893          bool _fromBuffer(CBufferIn& buffer) ; 
     94           
     95          CType<T> inheritedValue ; 
    8996      }; // class CAttribute     
    9097       
  • XIOS/trunk/src/attribute_template_impl.hpp

    r432 r445  
    109109    }  
    110110 
     111    template <class T> 
     112    void CAttributeTemplate<T>::setInheritedValue(const CAttribute& attr) 
     113    { 
     114      this->setInheritedValue(dynamic_cast<const CAttributeTemplate<T>& >(attr)) ; 
     115    }  
     116 
     117    template <class T> 
     118    void CAttributeTemplate<T>::setInheritedValue(const CAttributeTemplate& attr) 
     119    { 
     120      if (this->isEmpty() && attr.hasInheritedValue()) inheritedValue.set(attr.getInheritedValue()) ; 
     121    }  
     122 
     123    template <class T> 
     124    T CAttributeTemplate<T>::getInheritedValue(void) const 
     125    { 
     126      if (this->isEmpty()) return inheritedValue.get() ; 
     127      else return getValue() ; 
     128    }  
     129     
     130    template <class T> 
     131    bool CAttributeTemplate<T>::hasInheritedValue(void) const 
     132    { 
     133      return !this->isEmpty() || !inheritedValue.isEmpty() ; 
     134    }  
     135     
    111136      //--------------------------------------------------------------- 
    112137 
  • XIOS/trunk/src/generate_interface_impl.hpp

    r432 r445  
    4242    oss<<"{"<<iendl ; 
    4343    oss<<"   CTimer::get(\"XIOS\").resume();"<<iendl ; 
    44     oss<<"  return !"<<className<<"_hdl->"<<name<<".isEmpty();"<<iendl ; 
     44    oss<<"  return "<<className<<"_hdl->"<<name<<".hasInheritedValue();"<<iendl ; 
    4545    oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ; 
    4646    oss<<"}"<<iendl ; 
     
    6464    oss<<"void cxios_get_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, "<< typeName<<"* "<<name<<")"<<iendl ; 
    6565    oss<<"{"<<iendl; 
    66     oss<<"  *"<<name<<" = "<<className<<"_hdl->"<<name<<".getValue();"<<iendl ; 
     66    oss<<"  *"<<name<<" = "<<className<<"_hdl->"<<name<<".getInheritedValue();"<<iendl ; 
    6767    oss<<"}"<<iendl ; 
    6868    oss<<iendl ; 
     
    8888    oss<<"{"<<iendl ; 
    8989    oss<<"   CTimer::get(\"XIOS\").resume();"<<iendl ; 
    90     oss<<"  if(!string_copy("<<className<<"_hdl->"<<name<<".getValue(),"<<name<<" , "<<name<<"_size))"<<iendl ; 
     90    oss<<"  if(!string_copy("<<className<<"_hdl->"<<name<<".getInheritedValue(),"<<name<<" , "<<name<<"_size))"<<iendl ; 
    9191    oss<<"    ERROR(\"void cxios_get_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, char * "<<name<<", int " 
    9292       <<name<<"_size)\", <<\"Input string is to short\");"<<iendl ; 
     
    115115    oss<<"{"<<iendl ; 
    116116    oss<<"   CTimer::get(\"XIOS\").resume();"<<iendl ; 
    117     oss<<"  if(!string_copy("<<className<<"_hdl->"<<name<<".getStringValue(),"<<name<<" , "<<name<<"_size))"<<iendl ; 
     117    oss<<"  if(!string_copy("<<className<<"_hdl->"<<name<<".getInheritedStringValue(),"<<name<<" , "<<name<<"_size))"<<iendl ; 
    118118    oss<<"    ERROR(\"void cxios_get_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, char * "<<name<<", int " 
    119119       <<name<<"_size)\", <<\"Input string is to short\");"<<iendl ; 
     
    610610    oss<<"  CTimer::get(\"XIOS\").resume();"<<iendl ; \ 
    611611    oss<<"  CArray<"<<typeName<<",1> tmp("<<name<<",shape(extent1),neverDeleteData) ;"<<iendl ;\ 
    612     oss<<"  tmp="<<className<<"_hdl->"<<name<<" ;"<<iendl ;\ 
     612    oss<<"  tmp="<<className<<"_hdl->"<<name<<".getInheritedValue() ;"<<iendl ;\ 
    613613    oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;\ 
    614614    oss<<"}"<<iendl ;\ 
     
    634634    oss<<"  CTimer::get(\"XIOS\").resume();"<<iendl ; \ 
    635635    oss<<"  CArray<"<<typeName<<",2> tmp("<<name<<",shape(extent1,extent2),neverDeleteData) ;"<<iendl ;\ 
    636     oss<<"  tmp="<<className<<"_hdl->"<<name<<" ;"<<iendl ;\ 
     636    oss<<"  tmp="<<className<<"_hdl->"<<name<<".getInheritedValue() ;"<<iendl ;\ 
    637637    oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;\ 
    638638    oss<<"}"<<iendl ;\ 
     
    658658    oss<<"  CTimer::get(\"XIOS\").resume();"<<iendl ; \ 
    659659    oss<<"  CArray<"<<typeName<<",3> tmp("<<name<<",shape(extent1,extent2,extent3),neverDeleteData) ;"<<iendl ;\ 
    660     oss<<"  tmp="<<className<<"_hdl->"<<name<<" ;"<<iendl ;\ 
     660    oss<<"  tmp="<<className<<"_hdl->"<<name<<".getInheritedValue() ;"<<iendl ;\ 
    661661    oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;\ 
    662662    oss<<"}"<<iendl ;\ 
  • XIOS/trunk/src/group_template.hpp

    r369 r445  
    5959 
    6060         /// Traitements /// 
    61          virtual void solveDescInheritance(const CAttributeMap * const parent = 0); 
     61         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0); 
    6262         void solveRefInheritance(void); 
    6363//         static bool has(const string & id);  
  • XIOS/trunk/src/group_template_impl.hpp

    r369 r445  
    263263    
    264264   template <class U, class V, class W> 
    265       void CGroupTemplate<U, V, W>::solveDescInheritance(const CAttributeMap * const parent) 
     265      void CGroupTemplate<U, V, W>::solveDescInheritance(bool apply, const CAttributeMap * const parent) 
    266266   { 
    267267      if (parent != NULL) 
    268          SuperClassAttribute::setAttributes(parent); 
     268         SuperClassAttribute::setAttributes(parent, apply); 
    269269          
    270270      typename std::vector<U*>::const_iterator  
     
    276276      {  
    277277         U* child = *itc; 
    278          child->solveDescInheritance(this); 
     278         child->solveDescInheritance(apply,this); 
    279279      } 
    280280             
     
    283283         V* group = *itg; 
    284284         group->solveRefInheritance(); 
    285          group->solveDescInheritance(this); 
     285         group->solveDescInheritance(apply,this); 
    286286      } 
    287287   } 
  • XIOS/trunk/src/interface/c/icdata.cpp

    r403 r445  
    102102   } 
    103103 
    104   
     104   void cxios_solve_inheritance() 
     105   { 
     106     CTimer::get("XIOS").resume() ; 
     107     CContext* context = CContext::getCurrent() ; 
     108     context->solveAllInheritance(false) ; 
     109     CTimer::get("XIOS").suspend() ; 
     110   }  
    105111    
    106112   // ---------------------- Ecriture des données ------------------------------ 
  • XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp

    r432 r445  
    3030  { 
    3131     CTimer::get("XIOS").resume(); 
    32     if(!string_copy(axis_hdl->long_name.getValue(),long_name , long_name_size)) 
     32    if(!string_copy(axis_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    3333      ERROR("void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    3434     CTimer::get("XIOS").suspend(); 
     
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return !axis_hdl->long_name.isEmpty(); 
     40    return axis_hdl->long_name.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
    4242  } 
     
    5757  { 
    5858     CTimer::get("XIOS").resume(); 
    59     if(!string_copy(axis_hdl->name.getValue(),name , name_size)) 
     59    if(!string_copy(axis_hdl->name.getInheritedValue(),name , name_size)) 
    6060      ERROR("void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size)", <<"Input string is to short"); 
    6161     CTimer::get("XIOS").suspend(); 
     
    6565  { 
    6666     CTimer::get("XIOS").resume(); 
    67     return !axis_hdl->name.isEmpty(); 
     67    return axis_hdl->name.hasInheritedValue(); 
    6868     CTimer::get("XIOS").suspend(); 
    6969  } 
     
    8484  { 
    8585     CTimer::get("XIOS").resume(); 
    86     if(!string_copy(axis_hdl->positive.getStringValue(),positive , positive_size)) 
     86    if(!string_copy(axis_hdl->positive.getInheritedStringValue(),positive , positive_size)) 
    8787      ERROR("void cxios_get_axis_positive(axis_Ptr axis_hdl, char * positive, int positive_size)", <<"Input string is to short"); 
    8888     CTimer::get("XIOS").suspend(); 
     
    9292  { 
    9393     CTimer::get("XIOS").resume(); 
    94     return !axis_hdl->positive.isEmpty(); 
     94    return axis_hdl->positive.hasInheritedValue(); 
    9595     CTimer::get("XIOS").suspend(); 
    9696  } 
     
    108108  void cxios_get_axis_size(axis_Ptr axis_hdl, int* size) 
    109109  { 
    110     *size = axis_hdl->size.getValue(); 
     110    *size = axis_hdl->size.getInheritedValue(); 
    111111  } 
    112112   
     
    114114  { 
    115115     CTimer::get("XIOS").resume(); 
    116     return !axis_hdl->size.isEmpty(); 
     116    return axis_hdl->size.hasInheritedValue(); 
    117117     CTimer::get("XIOS").suspend(); 
    118118  } 
     
    133133  { 
    134134     CTimer::get("XIOS").resume(); 
    135     if(!string_copy(axis_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
     135    if(!string_copy(axis_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    136136      ERROR("void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    137137     CTimer::get("XIOS").suspend(); 
     
    141141  { 
    142142     CTimer::get("XIOS").resume(); 
    143     return !axis_hdl->standard_name.isEmpty(); 
     143    return axis_hdl->standard_name.hasInheritedValue(); 
    144144     CTimer::get("XIOS").suspend(); 
    145145  } 
     
    160160  { 
    161161     CTimer::get("XIOS").resume(); 
    162     if(!string_copy(axis_hdl->unit.getValue(),unit , unit_size)) 
     162    if(!string_copy(axis_hdl->unit.getInheritedValue(),unit , unit_size)) 
    163163      ERROR("void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
    164164     CTimer::get("XIOS").suspend(); 
     
    168168  { 
    169169     CTimer::get("XIOS").resume(); 
    170     return !axis_hdl->unit.isEmpty(); 
     170    return axis_hdl->unit.hasInheritedValue(); 
    171171     CTimer::get("XIOS").suspend(); 
    172172  } 
     
    187187    CTimer::get("XIOS").resume(); 
    188188    CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ; 
    189     tmp=axis_hdl->value ; 
     189    tmp=axis_hdl->value.getInheritedValue() ; 
    190190     CTimer::get("XIOS").suspend(); 
    191191  } 
     
    194194  { 
    195195     CTimer::get("XIOS").resume(); 
    196     return !axis_hdl->value.isEmpty(); 
     196    return axis_hdl->value.hasInheritedValue(); 
    197197     CTimer::get("XIOS").suspend(); 
    198198  } 
     
    210210  void cxios_get_axis_zoom_begin(axis_Ptr axis_hdl, int* zoom_begin) 
    211211  { 
    212     *zoom_begin = axis_hdl->zoom_begin.getValue(); 
     212    *zoom_begin = axis_hdl->zoom_begin.getInheritedValue(); 
    213213  } 
    214214   
     
    216216  { 
    217217     CTimer::get("XIOS").resume(); 
    218     return !axis_hdl->zoom_begin.isEmpty(); 
     218    return axis_hdl->zoom_begin.hasInheritedValue(); 
    219219     CTimer::get("XIOS").suspend(); 
    220220  } 
     
    232232  void cxios_get_axis_zoom_end(axis_Ptr axis_hdl, int* zoom_end) 
    233233  { 
    234     *zoom_end = axis_hdl->zoom_end.getValue(); 
     234    *zoom_end = axis_hdl->zoom_end.getInheritedValue(); 
    235235  } 
    236236   
     
    238238  { 
    239239     CTimer::get("XIOS").resume(); 
    240     return !axis_hdl->zoom_end.isEmpty(); 
     240    return axis_hdl->zoom_end.hasInheritedValue(); 
    241241     CTimer::get("XIOS").suspend(); 
    242242  } 
     
    254254  void cxios_get_axis_zoom_size(axis_Ptr axis_hdl, int* zoom_size) 
    255255  { 
    256     *zoom_size = axis_hdl->zoom_size.getValue(); 
     256    *zoom_size = axis_hdl->zoom_size.getInheritedValue(); 
    257257  } 
    258258   
     
    260260  { 
    261261     CTimer::get("XIOS").resume(); 
    262     return !axis_hdl->zoom_size.isEmpty(); 
     262    return axis_hdl->zoom_size.hasInheritedValue(); 
    263263     CTimer::get("XIOS").suspend(); 
    264264  } 
  • XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp

    r432 r445  
    3030  { 
    3131     CTimer::get("XIOS").resume(); 
    32     if(!string_copy(axisgroup_hdl->group_ref.getValue(),group_ref , group_ref_size)) 
     32    if(!string_copy(axisgroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size)) 
    3333      ERROR("void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
    3434     CTimer::get("XIOS").suspend(); 
     
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return !axisgroup_hdl->group_ref.isEmpty(); 
     40    return axisgroup_hdl->group_ref.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
    4242  } 
     
    5757  { 
    5858     CTimer::get("XIOS").resume(); 
    59     if(!string_copy(axisgroup_hdl->long_name.getValue(),long_name , long_name_size)) 
     59    if(!string_copy(axisgroup_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    6060      ERROR("void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    6161     CTimer::get("XIOS").suspend(); 
     
    6565  { 
    6666     CTimer::get("XIOS").resume(); 
    67     return !axisgroup_hdl->long_name.isEmpty(); 
     67    return axisgroup_hdl->long_name.hasInheritedValue(); 
    6868     CTimer::get("XIOS").suspend(); 
    6969  } 
     
    8484  { 
    8585     CTimer::get("XIOS").resume(); 
    86     if(!string_copy(axisgroup_hdl->name.getValue(),name , name_size)) 
     86    if(!string_copy(axisgroup_hdl->name.getInheritedValue(),name , name_size)) 
    8787      ERROR("void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
    8888     CTimer::get("XIOS").suspend(); 
     
    9292  { 
    9393     CTimer::get("XIOS").resume(); 
    94     return !axisgroup_hdl->name.isEmpty(); 
     94    return axisgroup_hdl->name.hasInheritedValue(); 
    9595     CTimer::get("XIOS").suspend(); 
    9696  } 
     
    111111  { 
    112112     CTimer::get("XIOS").resume(); 
    113     if(!string_copy(axisgroup_hdl->positive.getStringValue(),positive , positive_size)) 
     113    if(!string_copy(axisgroup_hdl->positive.getInheritedStringValue(),positive , positive_size)) 
    114114      ERROR("void cxios_get_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, char * positive, int positive_size)", <<"Input string is to short"); 
    115115     CTimer::get("XIOS").suspend(); 
     
    119119  { 
    120120     CTimer::get("XIOS").resume(); 
    121     return !axisgroup_hdl->positive.isEmpty(); 
     121    return axisgroup_hdl->positive.hasInheritedValue(); 
    122122     CTimer::get("XIOS").suspend(); 
    123123  } 
     
    135135  void cxios_get_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int* size) 
    136136  { 
    137     *size = axisgroup_hdl->size.getValue(); 
     137    *size = axisgroup_hdl->size.getInheritedValue(); 
    138138  } 
    139139   
     
    141141  { 
    142142     CTimer::get("XIOS").resume(); 
    143     return !axisgroup_hdl->size.isEmpty(); 
     143    return axisgroup_hdl->size.hasInheritedValue(); 
    144144     CTimer::get("XIOS").suspend(); 
    145145  } 
     
    160160  { 
    161161     CTimer::get("XIOS").resume(); 
    162     if(!string_copy(axisgroup_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
     162    if(!string_copy(axisgroup_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    163163      ERROR("void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    164164     CTimer::get("XIOS").suspend(); 
     
    168168  { 
    169169     CTimer::get("XIOS").resume(); 
    170     return !axisgroup_hdl->standard_name.isEmpty(); 
     170    return axisgroup_hdl->standard_name.hasInheritedValue(); 
    171171     CTimer::get("XIOS").suspend(); 
    172172  } 
     
    187187  { 
    188188     CTimer::get("XIOS").resume(); 
    189     if(!string_copy(axisgroup_hdl->unit.getValue(),unit , unit_size)) 
     189    if(!string_copy(axisgroup_hdl->unit.getInheritedValue(),unit , unit_size)) 
    190190      ERROR("void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
    191191     CTimer::get("XIOS").suspend(); 
     
    195195  { 
    196196     CTimer::get("XIOS").resume(); 
    197     return !axisgroup_hdl->unit.isEmpty(); 
     197    return axisgroup_hdl->unit.hasInheritedValue(); 
    198198     CTimer::get("XIOS").suspend(); 
    199199  } 
     
    214214    CTimer::get("XIOS").resume(); 
    215215    CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ; 
    216     tmp=axisgroup_hdl->value ; 
     216    tmp=axisgroup_hdl->value.getInheritedValue() ; 
    217217     CTimer::get("XIOS").suspend(); 
    218218  } 
     
    221221  { 
    222222     CTimer::get("XIOS").resume(); 
    223     return !axisgroup_hdl->value.isEmpty(); 
     223    return axisgroup_hdl->value.hasInheritedValue(); 
    224224     CTimer::get("XIOS").suspend(); 
    225225  } 
     
    237237  void cxios_get_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int* zoom_begin) 
    238238  { 
    239     *zoom_begin = axisgroup_hdl->zoom_begin.getValue(); 
     239    *zoom_begin = axisgroup_hdl->zoom_begin.getInheritedValue(); 
    240240  } 
    241241   
     
    243243  { 
    244244     CTimer::get("XIOS").resume(); 
    245     return !axisgroup_hdl->zoom_begin.isEmpty(); 
     245    return axisgroup_hdl->zoom_begin.hasInheritedValue(); 
    246246     CTimer::get("XIOS").suspend(); 
    247247  } 
     
    259259  void cxios_get_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int* zoom_end) 
    260260  { 
    261     *zoom_end = axisgroup_hdl->zoom_end.getValue(); 
     261    *zoom_end = axisgroup_hdl->zoom_end.getInheritedValue(); 
    262262  } 
    263263   
     
    265265  { 
    266266     CTimer::get("XIOS").resume(); 
    267     return !axisgroup_hdl->zoom_end.isEmpty(); 
     267    return axisgroup_hdl->zoom_end.hasInheritedValue(); 
    268268     CTimer::get("XIOS").suspend(); 
    269269  } 
     
    281281  void cxios_get_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int* zoom_size) 
    282282  { 
    283     *zoom_size = axisgroup_hdl->zoom_size.getValue(); 
     283    *zoom_size = axisgroup_hdl->zoom_size.getInheritedValue(); 
    284284  } 
    285285   
     
    287287  { 
    288288     CTimer::get("XIOS").resume(); 
    289     return !axisgroup_hdl->zoom_size.isEmpty(); 
     289    return axisgroup_hdl->zoom_size.hasInheritedValue(); 
    290290     CTimer::get("XIOS").suspend(); 
    291291  } 
  • XIOS/trunk/src/interface/c_attr/iccontext_attr.cpp

    r432 r445  
    3030  { 
    3131     CTimer::get("XIOS").resume(); 
    32     if(!string_copy(context_hdl->calendar_type.getValue(),calendar_type , calendar_type_size)) 
     32    if(!string_copy(context_hdl->calendar_type.getInheritedValue(),calendar_type , calendar_type_size)) 
    3333      ERROR("void cxios_get_context_calendar_type(context_Ptr context_hdl, char * calendar_type, int calendar_type_size)", <<"Input string is to short"); 
    3434     CTimer::get("XIOS").suspend(); 
     
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return !context_hdl->calendar_type.isEmpty(); 
     40    return context_hdl->calendar_type.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
    4242  } 
     
    5757  { 
    5858     CTimer::get("XIOS").resume(); 
    59     if(!string_copy(context_hdl->output_dir.getValue(),output_dir , output_dir_size)) 
     59    if(!string_copy(context_hdl->output_dir.getInheritedValue(),output_dir , output_dir_size)) 
    6060      ERROR("void cxios_get_context_output_dir(context_Ptr context_hdl, char * output_dir, int output_dir_size)", <<"Input string is to short"); 
    6161     CTimer::get("XIOS").suspend(); 
     
    6565  { 
    6666     CTimer::get("XIOS").resume(); 
    67     return !context_hdl->output_dir.isEmpty(); 
     67    return context_hdl->output_dir.hasInheritedValue(); 
    6868     CTimer::get("XIOS").suspend(); 
    6969  } 
     
    8484  { 
    8585     CTimer::get("XIOS").resume(); 
    86     if(!string_copy(context_hdl->start_date.getValue(),start_date , start_date_size)) 
     86    if(!string_copy(context_hdl->start_date.getInheritedValue(),start_date , start_date_size)) 
    8787      ERROR("void cxios_get_context_start_date(context_Ptr context_hdl, char * start_date, int start_date_size)", <<"Input string is to short"); 
    8888     CTimer::get("XIOS").suspend(); 
     
    9292  { 
    9393     CTimer::get("XIOS").resume(); 
    94     return !context_hdl->start_date.isEmpty(); 
     94    return context_hdl->start_date.hasInheritedValue(); 
    9595     CTimer::get("XIOS").suspend(); 
    9696  } 
     
    111111  { 
    112112     CTimer::get("XIOS").resume(); 
    113     if(!string_copy(context_hdl->time_origin.getValue(),time_origin , time_origin_size)) 
     113    if(!string_copy(context_hdl->time_origin.getInheritedValue(),time_origin , time_origin_size)) 
    114114      ERROR("void cxios_get_context_time_origin(context_Ptr context_hdl, char * time_origin, int time_origin_size)", <<"Input string is to short"); 
    115115     CTimer::get("XIOS").suspend(); 
     
    119119  { 
    120120     CTimer::get("XIOS").resume(); 
    121     return !context_hdl->time_origin.isEmpty(); 
     121    return context_hdl->time_origin.hasInheritedValue(); 
    122122     CTimer::get("XIOS").suspend(); 
    123123  } 
     
    138138  { 
    139139     CTimer::get("XIOS").resume(); 
    140     if(!string_copy(context_hdl->timestep.getValue(),timestep , timestep_size)) 
     140    if(!string_copy(context_hdl->timestep.getInheritedValue(),timestep , timestep_size)) 
    141141      ERROR("void cxios_get_context_timestep(context_Ptr context_hdl, char * timestep, int timestep_size)", <<"Input string is to short"); 
    142142     CTimer::get("XIOS").suspend(); 
     
    146146  { 
    147147     CTimer::get("XIOS").resume(); 
    148     return !context_hdl->timestep.isEmpty(); 
     148    return context_hdl->timestep.hasInheritedValue(); 
    149149     CTimer::get("XIOS").suspend(); 
    150150  } 
  • XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp

    r432 r445  
    2727  void cxios_get_domain_data_dim(domain_Ptr domain_hdl, int* data_dim) 
    2828  { 
    29     *data_dim = domain_hdl->data_dim.getValue(); 
     29    *data_dim = domain_hdl->data_dim.getInheritedValue(); 
    3030  } 
    3131   
     
    3333  { 
    3434     CTimer::get("XIOS").resume(); 
    35     return !domain_hdl->data_dim.isEmpty(); 
     35    return domain_hdl->data_dim.hasInheritedValue(); 
    3636     CTimer::get("XIOS").suspend(); 
    3737  } 
     
    5252    CTimer::get("XIOS").resume(); 
    5353    CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ; 
    54     tmp=domain_hdl->data_i_index ; 
     54    tmp=domain_hdl->data_i_index.getInheritedValue() ; 
    5555     CTimer::get("XIOS").suspend(); 
    5656  } 
     
    5959  { 
    6060     CTimer::get("XIOS").resume(); 
    61     return !domain_hdl->data_i_index.isEmpty(); 
     61    return domain_hdl->data_i_index.hasInheritedValue(); 
    6262     CTimer::get("XIOS").suspend(); 
    6363  } 
     
    7575  void cxios_get_domain_data_ibegin(domain_Ptr domain_hdl, int* data_ibegin) 
    7676  { 
    77     *data_ibegin = domain_hdl->data_ibegin.getValue(); 
     77    *data_ibegin = domain_hdl->data_ibegin.getInheritedValue(); 
    7878  } 
    7979   
     
    8181  { 
    8282     CTimer::get("XIOS").resume(); 
    83     return !domain_hdl->data_ibegin.isEmpty(); 
     83    return domain_hdl->data_ibegin.hasInheritedValue(); 
    8484     CTimer::get("XIOS").suspend(); 
    8585  } 
     
    100100    CTimer::get("XIOS").resume(); 
    101101    CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ; 
    102     tmp=domain_hdl->data_j_index ; 
     102    tmp=domain_hdl->data_j_index.getInheritedValue() ; 
    103103     CTimer::get("XIOS").suspend(); 
    104104  } 
     
    107107  { 
    108108     CTimer::get("XIOS").resume(); 
    109     return !domain_hdl->data_j_index.isEmpty(); 
     109    return domain_hdl->data_j_index.hasInheritedValue(); 
    110110     CTimer::get("XIOS").suspend(); 
    111111  } 
     
    123123  void cxios_get_domain_data_jbegin(domain_Ptr domain_hdl, int* data_jbegin) 
    124124  { 
    125     *data_jbegin = domain_hdl->data_jbegin.getValue(); 
     125    *data_jbegin = domain_hdl->data_jbegin.getInheritedValue(); 
    126126  } 
    127127   
     
    129129  { 
    130130     CTimer::get("XIOS").resume(); 
    131     return !domain_hdl->data_jbegin.isEmpty(); 
     131    return domain_hdl->data_jbegin.hasInheritedValue(); 
    132132     CTimer::get("XIOS").suspend(); 
    133133  } 
     
    145145  void cxios_get_domain_data_n_index(domain_Ptr domain_hdl, int* data_n_index) 
    146146  { 
    147     *data_n_index = domain_hdl->data_n_index.getValue(); 
     147    *data_n_index = domain_hdl->data_n_index.getInheritedValue(); 
    148148  } 
    149149   
     
    151151  { 
    152152     CTimer::get("XIOS").resume(); 
    153     return !domain_hdl->data_n_index.isEmpty(); 
     153    return domain_hdl->data_n_index.hasInheritedValue(); 
    154154     CTimer::get("XIOS").suspend(); 
    155155  } 
     
    167167  void cxios_get_domain_data_ni(domain_Ptr domain_hdl, int* data_ni) 
    168168  { 
    169     *data_ni = domain_hdl->data_ni.getValue(); 
     169    *data_ni = domain_hdl->data_ni.getInheritedValue(); 
    170170  } 
    171171   
     
    173173  { 
    174174     CTimer::get("XIOS").resume(); 
    175     return !domain_hdl->data_ni.isEmpty(); 
     175    return domain_hdl->data_ni.hasInheritedValue(); 
    176176     CTimer::get("XIOS").suspend(); 
    177177  } 
     
    189189  void cxios_get_domain_data_nj(domain_Ptr domain_hdl, int* data_nj) 
    190190  { 
    191     *data_nj = domain_hdl->data_nj.getValue(); 
     191    *data_nj = domain_hdl->data_nj.getInheritedValue(); 
    192192  } 
    193193   
     
    195195  { 
    196196     CTimer::get("XIOS").resume(); 
    197     return !domain_hdl->data_nj.isEmpty(); 
     197    return domain_hdl->data_nj.hasInheritedValue(); 
    198198     CTimer::get("XIOS").suspend(); 
    199199  } 
     
    214214  { 
    215215     CTimer::get("XIOS").resume(); 
    216     if(!string_copy(domain_hdl->domain_group_ref.getValue(),domain_group_ref , domain_group_ref_size)) 
     216    if(!string_copy(domain_hdl->domain_group_ref.getInheritedValue(),domain_group_ref , domain_group_ref_size)) 
    217217      ERROR("void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size)", <<"Input string is to short"); 
    218218     CTimer::get("XIOS").suspend(); 
     
    222222  { 
    223223     CTimer::get("XIOS").resume(); 
    224     return !domain_hdl->domain_group_ref.isEmpty(); 
     224    return domain_hdl->domain_group_ref.hasInheritedValue(); 
    225225     CTimer::get("XIOS").suspend(); 
    226226  } 
     
    238238  void cxios_get_domain_ibegin(domain_Ptr domain_hdl, int* ibegin) 
    239239  { 
    240     *ibegin = domain_hdl->ibegin.getValue(); 
     240    *ibegin = domain_hdl->ibegin.getInheritedValue(); 
    241241  } 
    242242   
     
    244244  { 
    245245     CTimer::get("XIOS").resume(); 
    246     return !domain_hdl->ibegin.isEmpty(); 
     246    return domain_hdl->ibegin.hasInheritedValue(); 
    247247     CTimer::get("XIOS").suspend(); 
    248248  } 
     
    260260  void cxios_get_domain_iend(domain_Ptr domain_hdl, int* iend) 
    261261  { 
    262     *iend = domain_hdl->iend.getValue(); 
     262    *iend = domain_hdl->iend.getInheritedValue(); 
    263263  } 
    264264   
     
    266266  { 
    267267     CTimer::get("XIOS").resume(); 
    268     return !domain_hdl->iend.isEmpty(); 
     268    return domain_hdl->iend.hasInheritedValue(); 
    269269     CTimer::get("XIOS").suspend(); 
    270270  } 
     
    282282  void cxios_get_domain_jbegin(domain_Ptr domain_hdl, int* jbegin) 
    283283  { 
    284     *jbegin = domain_hdl->jbegin.getValue(); 
     284    *jbegin = domain_hdl->jbegin.getInheritedValue(); 
    285285  } 
    286286   
     
    288288  { 
    289289     CTimer::get("XIOS").resume(); 
    290     return !domain_hdl->jbegin.isEmpty(); 
     290    return domain_hdl->jbegin.hasInheritedValue(); 
    291291     CTimer::get("XIOS").suspend(); 
    292292  } 
     
    304304  void cxios_get_domain_jend(domain_Ptr domain_hdl, int* jend) 
    305305  { 
    306     *jend = domain_hdl->jend.getValue(); 
     306    *jend = domain_hdl->jend.getInheritedValue(); 
    307307  } 
    308308   
     
    310310  { 
    311311     CTimer::get("XIOS").resume(); 
    312     return !domain_hdl->jend.isEmpty(); 
     312    return domain_hdl->jend.hasInheritedValue(); 
    313313     CTimer::get("XIOS").suspend(); 
    314314  } 
     
    329329    CTimer::get("XIOS").resume(); 
    330330    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ; 
    331     tmp=domain_hdl->latvalue ; 
     331    tmp=domain_hdl->latvalue.getInheritedValue() ; 
    332332     CTimer::get("XIOS").suspend(); 
    333333  } 
     
    336336  { 
    337337     CTimer::get("XIOS").resume(); 
    338     return !domain_hdl->latvalue.isEmpty(); 
     338    return domain_hdl->latvalue.hasInheritedValue(); 
    339339     CTimer::get("XIOS").suspend(); 
    340340  } 
     
    355355  { 
    356356     CTimer::get("XIOS").resume(); 
    357     if(!string_copy(domain_hdl->long_name.getValue(),long_name , long_name_size)) 
     357    if(!string_copy(domain_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    358358      ERROR("void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    359359     CTimer::get("XIOS").suspend(); 
     
    363363  { 
    364364     CTimer::get("XIOS").resume(); 
    365     return !domain_hdl->long_name.isEmpty(); 
     365    return domain_hdl->long_name.hasInheritedValue(); 
    366366     CTimer::get("XIOS").suspend(); 
    367367  } 
     
    382382    CTimer::get("XIOS").resume(); 
    383383    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ; 
    384     tmp=domain_hdl->lonvalue ; 
     384    tmp=domain_hdl->lonvalue.getInheritedValue() ; 
    385385     CTimer::get("XIOS").suspend(); 
    386386  } 
     
    389389  { 
    390390     CTimer::get("XIOS").resume(); 
    391     return !domain_hdl->lonvalue.isEmpty(); 
     391    return domain_hdl->lonvalue.hasInheritedValue(); 
    392392     CTimer::get("XIOS").suspend(); 
    393393  } 
     
    408408    CTimer::get("XIOS").resume(); 
    409409    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ; 
    410     tmp=domain_hdl->mask ; 
     410    tmp=domain_hdl->mask.getInheritedValue() ; 
    411411     CTimer::get("XIOS").suspend(); 
    412412  } 
     
    415415  { 
    416416     CTimer::get("XIOS").resume(); 
    417     return !domain_hdl->mask.isEmpty(); 
     417    return domain_hdl->mask.hasInheritedValue(); 
    418418     CTimer::get("XIOS").suspend(); 
    419419  } 
     
    434434  { 
    435435     CTimer::get("XIOS").resume(); 
    436     if(!string_copy(domain_hdl->name.getValue(),name , name_size)) 
     436    if(!string_copy(domain_hdl->name.getInheritedValue(),name , name_size)) 
    437437      ERROR("void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)", <<"Input string is to short"); 
    438438     CTimer::get("XIOS").suspend(); 
     
    442442  { 
    443443     CTimer::get("XIOS").resume(); 
    444     return !domain_hdl->name.isEmpty(); 
     444    return domain_hdl->name.hasInheritedValue(); 
    445445     CTimer::get("XIOS").suspend(); 
    446446  } 
     
    458458  void cxios_get_domain_ni(domain_Ptr domain_hdl, int* ni) 
    459459  { 
    460     *ni = domain_hdl->ni.getValue(); 
     460    *ni = domain_hdl->ni.getInheritedValue(); 
    461461  } 
    462462   
     
    464464  { 
    465465     CTimer::get("XIOS").resume(); 
    466     return !domain_hdl->ni.isEmpty(); 
     466    return domain_hdl->ni.hasInheritedValue(); 
    467467     CTimer::get("XIOS").suspend(); 
    468468  } 
     
    480480  void cxios_get_domain_ni_glo(domain_Ptr domain_hdl, int* ni_glo) 
    481481  { 
    482     *ni_glo = domain_hdl->ni_glo.getValue(); 
     482    *ni_glo = domain_hdl->ni_glo.getInheritedValue(); 
    483483  } 
    484484   
     
    486486  { 
    487487     CTimer::get("XIOS").resume(); 
    488     return !domain_hdl->ni_glo.isEmpty(); 
     488    return domain_hdl->ni_glo.hasInheritedValue(); 
    489489     CTimer::get("XIOS").suspend(); 
    490490  } 
     
    502502  void cxios_get_domain_nj(domain_Ptr domain_hdl, int* nj) 
    503503  { 
    504     *nj = domain_hdl->nj.getValue(); 
     504    *nj = domain_hdl->nj.getInheritedValue(); 
    505505  } 
    506506   
     
    508508  { 
    509509     CTimer::get("XIOS").resume(); 
    510     return !domain_hdl->nj.isEmpty(); 
     510    return domain_hdl->nj.hasInheritedValue(); 
    511511     CTimer::get("XIOS").suspend(); 
    512512  } 
     
    524524  void cxios_get_domain_nj_glo(domain_Ptr domain_hdl, int* nj_glo) 
    525525  { 
    526     *nj_glo = domain_hdl->nj_glo.getValue(); 
     526    *nj_glo = domain_hdl->nj_glo.getInheritedValue(); 
    527527  } 
    528528   
     
    530530  { 
    531531     CTimer::get("XIOS").resume(); 
    532     return !domain_hdl->nj_glo.isEmpty(); 
     532    return domain_hdl->nj_glo.hasInheritedValue(); 
    533533     CTimer::get("XIOS").suspend(); 
    534534  } 
     
    549549  { 
    550550     CTimer::get("XIOS").resume(); 
    551     if(!string_copy(domain_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
     551    if(!string_copy(domain_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    552552      ERROR("void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    553553     CTimer::get("XIOS").suspend(); 
     
    557557  { 
    558558     CTimer::get("XIOS").resume(); 
    559     return !domain_hdl->standard_name.isEmpty(); 
     559    return domain_hdl->standard_name.hasInheritedValue(); 
    560560     CTimer::get("XIOS").suspend(); 
    561561  } 
     
    573573  void cxios_get_domain_zoom_ibegin(domain_Ptr domain_hdl, int* zoom_ibegin) 
    574574  { 
    575     *zoom_ibegin = domain_hdl->zoom_ibegin.getValue(); 
     575    *zoom_ibegin = domain_hdl->zoom_ibegin.getInheritedValue(); 
    576576  } 
    577577   
     
    579579  { 
    580580     CTimer::get("XIOS").resume(); 
    581     return !domain_hdl->zoom_ibegin.isEmpty(); 
     581    return domain_hdl->zoom_ibegin.hasInheritedValue(); 
    582582     CTimer::get("XIOS").suspend(); 
    583583  } 
     
    595595  void cxios_get_domain_zoom_ibegin_loc(domain_Ptr domain_hdl, int* zoom_ibegin_loc) 
    596596  { 
    597     *zoom_ibegin_loc = domain_hdl->zoom_ibegin_loc.getValue(); 
     597    *zoom_ibegin_loc = domain_hdl->zoom_ibegin_loc.getInheritedValue(); 
    598598  } 
    599599   
     
    601601  { 
    602602     CTimer::get("XIOS").resume(); 
    603     return !domain_hdl->zoom_ibegin_loc.isEmpty(); 
     603    return domain_hdl->zoom_ibegin_loc.hasInheritedValue(); 
    604604     CTimer::get("XIOS").suspend(); 
    605605  } 
     
    617617  void cxios_get_domain_zoom_jbegin(domain_Ptr domain_hdl, int* zoom_jbegin) 
    618618  { 
    619     *zoom_jbegin = domain_hdl->zoom_jbegin.getValue(); 
     619    *zoom_jbegin = domain_hdl->zoom_jbegin.getInheritedValue(); 
    620620  } 
    621621   
     
    623623  { 
    624624     CTimer::get("XIOS").resume(); 
    625     return !domain_hdl->zoom_jbegin.isEmpty(); 
     625    return domain_hdl->zoom_jbegin.hasInheritedValue(); 
    626626     CTimer::get("XIOS").suspend(); 
    627627  } 
     
    639639  void cxios_get_domain_zoom_jbegin_loc(domain_Ptr domain_hdl, int* zoom_jbegin_loc) 
    640640  { 
    641     *zoom_jbegin_loc = domain_hdl->zoom_jbegin_loc.getValue(); 
     641    *zoom_jbegin_loc = domain_hdl->zoom_jbegin_loc.getInheritedValue(); 
    642642  } 
    643643   
     
    645645  { 
    646646     CTimer::get("XIOS").resume(); 
    647     return !domain_hdl->zoom_jbegin_loc.isEmpty(); 
     647    return domain_hdl->zoom_jbegin_loc.hasInheritedValue(); 
    648648     CTimer::get("XIOS").suspend(); 
    649649  } 
     
    661661  void cxios_get_domain_zoom_ni(domain_Ptr domain_hdl, int* zoom_ni) 
    662662  { 
    663     *zoom_ni = domain_hdl->zoom_ni.getValue(); 
     663    *zoom_ni = domain_hdl->zoom_ni.getInheritedValue(); 
    664664  } 
    665665   
     
    667667  { 
    668668     CTimer::get("XIOS").resume(); 
    669     return !domain_hdl->zoom_ni.isEmpty(); 
     669    return domain_hdl->zoom_ni.hasInheritedValue(); 
    670670     CTimer::get("XIOS").suspend(); 
    671671  } 
     
    683683  void cxios_get_domain_zoom_ni_loc(domain_Ptr domain_hdl, int* zoom_ni_loc) 
    684684  { 
    685     *zoom_ni_loc = domain_hdl->zoom_ni_loc.getValue(); 
     685    *zoom_ni_loc = domain_hdl->zoom_ni_loc.getInheritedValue(); 
    686686  } 
    687687   
     
    689689  { 
    690690     CTimer::get("XIOS").resume(); 
    691     return !domain_hdl->zoom_ni_loc.isEmpty(); 
     691    return domain_hdl->zoom_ni_loc.hasInheritedValue(); 
    692692     CTimer::get("XIOS").suspend(); 
    693693  } 
     
    705705  void cxios_get_domain_zoom_nj(domain_Ptr domain_hdl, int* zoom_nj) 
    706706  { 
    707     *zoom_nj = domain_hdl->zoom_nj.getValue(); 
     707    *zoom_nj = domain_hdl->zoom_nj.getInheritedValue(); 
    708708  } 
    709709   
     
    711711  { 
    712712     CTimer::get("XIOS").resume(); 
    713     return !domain_hdl->zoom_nj.isEmpty(); 
     713    return domain_hdl->zoom_nj.hasInheritedValue(); 
    714714     CTimer::get("XIOS").suspend(); 
    715715  } 
     
    727727  void cxios_get_domain_zoom_nj_loc(domain_Ptr domain_hdl, int* zoom_nj_loc) 
    728728  { 
    729     *zoom_nj_loc = domain_hdl->zoom_nj_loc.getValue(); 
     729    *zoom_nj_loc = domain_hdl->zoom_nj_loc.getInheritedValue(); 
    730730  } 
    731731   
     
    733733  { 
    734734     CTimer::get("XIOS").resume(); 
    735     return !domain_hdl->zoom_nj_loc.isEmpty(); 
     735    return domain_hdl->zoom_nj_loc.hasInheritedValue(); 
    736736     CTimer::get("XIOS").suspend(); 
    737737  } 
  • XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp

    r432 r445  
    2727  void cxios_get_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int* data_dim) 
    2828  { 
    29     *data_dim = domaingroup_hdl->data_dim.getValue(); 
     29    *data_dim = domaingroup_hdl->data_dim.getInheritedValue(); 
    3030  } 
    3131   
     
    3333  { 
    3434     CTimer::get("XIOS").resume(); 
    35     return !domaingroup_hdl->data_dim.isEmpty(); 
     35    return domaingroup_hdl->data_dim.hasInheritedValue(); 
    3636     CTimer::get("XIOS").suspend(); 
    3737  } 
     
    5252    CTimer::get("XIOS").resume(); 
    5353    CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ; 
    54     tmp=domaingroup_hdl->data_i_index ; 
     54    tmp=domaingroup_hdl->data_i_index.getInheritedValue() ; 
    5555     CTimer::get("XIOS").suspend(); 
    5656  } 
     
    5959  { 
    6060     CTimer::get("XIOS").resume(); 
    61     return !domaingroup_hdl->data_i_index.isEmpty(); 
     61    return domaingroup_hdl->data_i_index.hasInheritedValue(); 
    6262     CTimer::get("XIOS").suspend(); 
    6363  } 
     
    7575  void cxios_get_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl, int* data_ibegin) 
    7676  { 
    77     *data_ibegin = domaingroup_hdl->data_ibegin.getValue(); 
     77    *data_ibegin = domaingroup_hdl->data_ibegin.getInheritedValue(); 
    7878  } 
    7979   
     
    8181  { 
    8282     CTimer::get("XIOS").resume(); 
    83     return !domaingroup_hdl->data_ibegin.isEmpty(); 
     83    return domaingroup_hdl->data_ibegin.hasInheritedValue(); 
    8484     CTimer::get("XIOS").suspend(); 
    8585  } 
     
    100100    CTimer::get("XIOS").resume(); 
    101101    CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ; 
    102     tmp=domaingroup_hdl->data_j_index ; 
     102    tmp=domaingroup_hdl->data_j_index.getInheritedValue() ; 
    103103     CTimer::get("XIOS").suspend(); 
    104104  } 
     
    107107  { 
    108108     CTimer::get("XIOS").resume(); 
    109     return !domaingroup_hdl->data_j_index.isEmpty(); 
     109    return domaingroup_hdl->data_j_index.hasInheritedValue(); 
    110110     CTimer::get("XIOS").suspend(); 
    111111  } 
     
    123123  void cxios_get_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl, int* data_jbegin) 
    124124  { 
    125     *data_jbegin = domaingroup_hdl->data_jbegin.getValue(); 
     125    *data_jbegin = domaingroup_hdl->data_jbegin.getInheritedValue(); 
    126126  } 
    127127   
     
    129129  { 
    130130     CTimer::get("XIOS").resume(); 
    131     return !domaingroup_hdl->data_jbegin.isEmpty(); 
     131    return domaingroup_hdl->data_jbegin.hasInheritedValue(); 
    132132     CTimer::get("XIOS").suspend(); 
    133133  } 
     
    145145  void cxios_get_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int* data_n_index) 
    146146  { 
    147     *data_n_index = domaingroup_hdl->data_n_index.getValue(); 
     147    *data_n_index = domaingroup_hdl->data_n_index.getInheritedValue(); 
    148148  } 
    149149   
     
    151151  { 
    152152     CTimer::get("XIOS").resume(); 
    153     return !domaingroup_hdl->data_n_index.isEmpty(); 
     153    return domaingroup_hdl->data_n_index.hasInheritedValue(); 
    154154     CTimer::get("XIOS").suspend(); 
    155155  } 
     
    167167  void cxios_get_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int* data_ni) 
    168168  { 
    169     *data_ni = domaingroup_hdl->data_ni.getValue(); 
     169    *data_ni = domaingroup_hdl->data_ni.getInheritedValue(); 
    170170  } 
    171171   
     
    173173  { 
    174174     CTimer::get("XIOS").resume(); 
    175     return !domaingroup_hdl->data_ni.isEmpty(); 
     175    return domaingroup_hdl->data_ni.hasInheritedValue(); 
    176176     CTimer::get("XIOS").suspend(); 
    177177  } 
     
    189189  void cxios_get_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl, int* data_nj) 
    190190  { 
    191     *data_nj = domaingroup_hdl->data_nj.getValue(); 
     191    *data_nj = domaingroup_hdl->data_nj.getInheritedValue(); 
    192192  } 
    193193   
     
    195195  { 
    196196     CTimer::get("XIOS").resume(); 
    197     return !domaingroup_hdl->data_nj.isEmpty(); 
     197    return domaingroup_hdl->data_nj.hasInheritedValue(); 
    198198     CTimer::get("XIOS").suspend(); 
    199199  } 
     
    214214  { 
    215215     CTimer::get("XIOS").resume(); 
    216     if(!string_copy(domaingroup_hdl->domain_group_ref.getValue(),domain_group_ref , domain_group_ref_size)) 
     216    if(!string_copy(domaingroup_hdl->domain_group_ref.getInheritedValue(),domain_group_ref , domain_group_ref_size)) 
    217217      ERROR("void cxios_get_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, char * domain_group_ref, int domain_group_ref_size)", <<"Input string is to short"); 
    218218     CTimer::get("XIOS").suspend(); 
     
    222222  { 
    223223     CTimer::get("XIOS").resume(); 
    224     return !domaingroup_hdl->domain_group_ref.isEmpty(); 
     224    return domaingroup_hdl->domain_group_ref.hasInheritedValue(); 
    225225     CTimer::get("XIOS").suspend(); 
    226226  } 
     
    241241  { 
    242242     CTimer::get("XIOS").resume(); 
    243     if(!string_copy(domaingroup_hdl->group_ref.getValue(),group_ref , group_ref_size)) 
     243    if(!string_copy(domaingroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size)) 
    244244      ERROR("void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
    245245     CTimer::get("XIOS").suspend(); 
     
    249249  { 
    250250     CTimer::get("XIOS").resume(); 
    251     return !domaingroup_hdl->group_ref.isEmpty(); 
     251    return domaingroup_hdl->group_ref.hasInheritedValue(); 
    252252     CTimer::get("XIOS").suspend(); 
    253253  } 
     
    265265  void cxios_get_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl, int* ibegin) 
    266266  { 
    267     *ibegin = domaingroup_hdl->ibegin.getValue(); 
     267    *ibegin = domaingroup_hdl->ibegin.getInheritedValue(); 
    268268  } 
    269269   
     
    271271  { 
    272272     CTimer::get("XIOS").resume(); 
    273     return !domaingroup_hdl->ibegin.isEmpty(); 
     273    return domaingroup_hdl->ibegin.hasInheritedValue(); 
    274274     CTimer::get("XIOS").suspend(); 
    275275  } 
     
    287287  void cxios_get_domaingroup_iend(domaingroup_Ptr domaingroup_hdl, int* iend) 
    288288  { 
    289     *iend = domaingroup_hdl->iend.getValue(); 
     289    *iend = domaingroup_hdl->iend.getInheritedValue(); 
    290290  } 
    291291   
     
    293293  { 
    294294     CTimer::get("XIOS").resume(); 
    295     return !domaingroup_hdl->iend.isEmpty(); 
     295    return domaingroup_hdl->iend.hasInheritedValue(); 
    296296     CTimer::get("XIOS").suspend(); 
    297297  } 
     
    309309  void cxios_get_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl, int* jbegin) 
    310310  { 
    311     *jbegin = domaingroup_hdl->jbegin.getValue(); 
     311    *jbegin = domaingroup_hdl->jbegin.getInheritedValue(); 
    312312  } 
    313313   
     
    315315  { 
    316316     CTimer::get("XIOS").resume(); 
    317     return !domaingroup_hdl->jbegin.isEmpty(); 
     317    return domaingroup_hdl->jbegin.hasInheritedValue(); 
    318318     CTimer::get("XIOS").suspend(); 
    319319  } 
     
    331331  void cxios_get_domaingroup_jend(domaingroup_Ptr domaingroup_hdl, int* jend) 
    332332  { 
    333     *jend = domaingroup_hdl->jend.getValue(); 
     333    *jend = domaingroup_hdl->jend.getInheritedValue(); 
    334334  } 
    335335   
     
    337337  { 
    338338     CTimer::get("XIOS").resume(); 
    339     return !domaingroup_hdl->jend.isEmpty(); 
     339    return domaingroup_hdl->jend.hasInheritedValue(); 
    340340     CTimer::get("XIOS").suspend(); 
    341341  } 
     
    356356    CTimer::get("XIOS").resume(); 
    357357    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ; 
    358     tmp=domaingroup_hdl->latvalue ; 
     358    tmp=domaingroup_hdl->latvalue.getInheritedValue() ; 
    359359     CTimer::get("XIOS").suspend(); 
    360360  } 
     
    363363  { 
    364364     CTimer::get("XIOS").resume(); 
    365     return !domaingroup_hdl->latvalue.isEmpty(); 
     365    return domaingroup_hdl->latvalue.hasInheritedValue(); 
    366366     CTimer::get("XIOS").suspend(); 
    367367  } 
     
    382382  { 
    383383     CTimer::get("XIOS").resume(); 
    384     if(!string_copy(domaingroup_hdl->long_name.getValue(),long_name , long_name_size)) 
     384    if(!string_copy(domaingroup_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    385385      ERROR("void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    386386     CTimer::get("XIOS").suspend(); 
     
    390390  { 
    391391     CTimer::get("XIOS").resume(); 
    392     return !domaingroup_hdl->long_name.isEmpty(); 
     392    return domaingroup_hdl->long_name.hasInheritedValue(); 
    393393     CTimer::get("XIOS").suspend(); 
    394394  } 
     
    409409    CTimer::get("XIOS").resume(); 
    410410    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ; 
    411     tmp=domaingroup_hdl->lonvalue ; 
     411    tmp=domaingroup_hdl->lonvalue.getInheritedValue() ; 
    412412     CTimer::get("XIOS").suspend(); 
    413413  } 
     
    416416  { 
    417417     CTimer::get("XIOS").resume(); 
    418     return !domaingroup_hdl->lonvalue.isEmpty(); 
     418    return domaingroup_hdl->lonvalue.hasInheritedValue(); 
    419419     CTimer::get("XIOS").suspend(); 
    420420  } 
     
    435435    CTimer::get("XIOS").resume(); 
    436436    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ; 
    437     tmp=domaingroup_hdl->mask ; 
     437    tmp=domaingroup_hdl->mask.getInheritedValue() ; 
    438438     CTimer::get("XIOS").suspend(); 
    439439  } 
     
    442442  { 
    443443     CTimer::get("XIOS").resume(); 
    444     return !domaingroup_hdl->mask.isEmpty(); 
     444    return domaingroup_hdl->mask.hasInheritedValue(); 
    445445     CTimer::get("XIOS").suspend(); 
    446446  } 
     
    461461  { 
    462462     CTimer::get("XIOS").resume(); 
    463     if(!string_copy(domaingroup_hdl->name.getValue(),name , name_size)) 
     463    if(!string_copy(domaingroup_hdl->name.getInheritedValue(),name , name_size)) 
    464464      ERROR("void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
    465465     CTimer::get("XIOS").suspend(); 
     
    469469  { 
    470470     CTimer::get("XIOS").resume(); 
    471     return !domaingroup_hdl->name.isEmpty(); 
     471    return domaingroup_hdl->name.hasInheritedValue(); 
    472472     CTimer::get("XIOS").suspend(); 
    473473  } 
     
    485485  void cxios_get_domaingroup_ni(domaingroup_Ptr domaingroup_hdl, int* ni) 
    486486  { 
    487     *ni = domaingroup_hdl->ni.getValue(); 
     487    *ni = domaingroup_hdl->ni.getInheritedValue(); 
    488488  } 
    489489   
     
    491491  { 
    492492     CTimer::get("XIOS").resume(); 
    493     return !domaingroup_hdl->ni.isEmpty(); 
     493    return domaingroup_hdl->ni.hasInheritedValue(); 
    494494     CTimer::get("XIOS").suspend(); 
    495495  } 
     
    507507  void cxios_get_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl, int* ni_glo) 
    508508  { 
    509     *ni_glo = domaingroup_hdl->ni_glo.getValue(); 
     509    *ni_glo = domaingroup_hdl->ni_glo.getInheritedValue(); 
    510510  } 
    511511   
     
    513513  { 
    514514     CTimer::get("XIOS").resume(); 
    515     return !domaingroup_hdl->ni_glo.isEmpty(); 
     515    return domaingroup_hdl->ni_glo.hasInheritedValue(); 
    516516     CTimer::get("XIOS").suspend(); 
    517517  } 
     
    529529  void cxios_get_domaingroup_nj(domaingroup_Ptr domaingroup_hdl, int* nj) 
    530530  { 
    531     *nj = domaingroup_hdl->nj.getValue(); 
     531    *nj = domaingroup_hdl->nj.getInheritedValue(); 
    532532  } 
    533533   
     
    535535  { 
    536536     CTimer::get("XIOS").resume(); 
    537     return !domaingroup_hdl->nj.isEmpty(); 
     537    return domaingroup_hdl->nj.hasInheritedValue(); 
    538538     CTimer::get("XIOS").suspend(); 
    539539  } 
     
    551551  void cxios_get_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl, int* nj_glo) 
    552552  { 
    553     *nj_glo = domaingroup_hdl->nj_glo.getValue(); 
     553    *nj_glo = domaingroup_hdl->nj_glo.getInheritedValue(); 
    554554  } 
    555555   
     
    557557  { 
    558558     CTimer::get("XIOS").resume(); 
    559     return !domaingroup_hdl->nj_glo.isEmpty(); 
     559    return domaingroup_hdl->nj_glo.hasInheritedValue(); 
    560560     CTimer::get("XIOS").suspend(); 
    561561  } 
     
    576576  { 
    577577     CTimer::get("XIOS").resume(); 
    578     if(!string_copy(domaingroup_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
     578    if(!string_copy(domaingroup_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    579579      ERROR("void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    580580     CTimer::get("XIOS").suspend(); 
     
    584584  { 
    585585     CTimer::get("XIOS").resume(); 
    586     return !domaingroup_hdl->standard_name.isEmpty(); 
     586    return domaingroup_hdl->standard_name.hasInheritedValue(); 
    587587     CTimer::get("XIOS").suspend(); 
    588588  } 
     
    600600  void cxios_get_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl, int* zoom_ibegin) 
    601601  { 
    602     *zoom_ibegin = domaingroup_hdl->zoom_ibegin.getValue(); 
     602    *zoom_ibegin = domaingroup_hdl->zoom_ibegin.getInheritedValue(); 
    603603  } 
    604604   
     
    606606  { 
    607607     CTimer::get("XIOS").resume(); 
    608     return !domaingroup_hdl->zoom_ibegin.isEmpty(); 
     608    return domaingroup_hdl->zoom_ibegin.hasInheritedValue(); 
    609609     CTimer::get("XIOS").suspend(); 
    610610  } 
     
    622622  void cxios_get_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_ibegin_loc) 
    623623  { 
    624     *zoom_ibegin_loc = domaingroup_hdl->zoom_ibegin_loc.getValue(); 
     624    *zoom_ibegin_loc = domaingroup_hdl->zoom_ibegin_loc.getInheritedValue(); 
    625625  } 
    626626   
     
    628628  { 
    629629     CTimer::get("XIOS").resume(); 
    630     return !domaingroup_hdl->zoom_ibegin_loc.isEmpty(); 
     630    return domaingroup_hdl->zoom_ibegin_loc.hasInheritedValue(); 
    631631     CTimer::get("XIOS").suspend(); 
    632632  } 
     
    644644  void cxios_get_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl, int* zoom_jbegin) 
    645645  { 
    646     *zoom_jbegin = domaingroup_hdl->zoom_jbegin.getValue(); 
     646    *zoom_jbegin = domaingroup_hdl->zoom_jbegin.getInheritedValue(); 
    647647  } 
    648648   
     
    650650  { 
    651651     CTimer::get("XIOS").resume(); 
    652     return !domaingroup_hdl->zoom_jbegin.isEmpty(); 
     652    return domaingroup_hdl->zoom_jbegin.hasInheritedValue(); 
    653653     CTimer::get("XIOS").suspend(); 
    654654  } 
     
    666666  void cxios_get_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_jbegin_loc) 
    667667  { 
    668     *zoom_jbegin_loc = domaingroup_hdl->zoom_jbegin_loc.getValue(); 
     668    *zoom_jbegin_loc = domaingroup_hdl->zoom_jbegin_loc.getInheritedValue(); 
    669669  } 
    670670   
     
    672672  { 
    673673     CTimer::get("XIOS").resume(); 
    674     return !domaingroup_hdl->zoom_jbegin_loc.isEmpty(); 
     674    return domaingroup_hdl->zoom_jbegin_loc.hasInheritedValue(); 
    675675     CTimer::get("XIOS").suspend(); 
    676676  } 
     
    688688  void cxios_get_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl, int* zoom_ni) 
    689689  { 
    690     *zoom_ni = domaingroup_hdl->zoom_ni.getValue(); 
     690    *zoom_ni = domaingroup_hdl->zoom_ni.getInheritedValue(); 
    691691  } 
    692692   
     
    694694  { 
    695695     CTimer::get("XIOS").resume(); 
    696     return !domaingroup_hdl->zoom_ni.isEmpty(); 
     696    return domaingroup_hdl->zoom_ni.hasInheritedValue(); 
    697697     CTimer::get("XIOS").suspend(); 
    698698  } 
     
    710710  void cxios_get_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_ni_loc) 
    711711  { 
    712     *zoom_ni_loc = domaingroup_hdl->zoom_ni_loc.getValue(); 
     712    *zoom_ni_loc = domaingroup_hdl->zoom_ni_loc.getInheritedValue(); 
    713713  } 
    714714   
     
    716716  { 
    717717     CTimer::get("XIOS").resume(); 
    718     return !domaingroup_hdl->zoom_ni_loc.isEmpty(); 
     718    return domaingroup_hdl->zoom_ni_loc.hasInheritedValue(); 
    719719     CTimer::get("XIOS").suspend(); 
    720720  } 
     
    732732  void cxios_get_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl, int* zoom_nj) 
    733733  { 
    734     *zoom_nj = domaingroup_hdl->zoom_nj.getValue(); 
     734    *zoom_nj = domaingroup_hdl->zoom_nj.getInheritedValue(); 
    735735  } 
    736736   
     
    738738  { 
    739739     CTimer::get("XIOS").resume(); 
    740     return !domaingroup_hdl->zoom_nj.isEmpty(); 
     740    return domaingroup_hdl->zoom_nj.hasInheritedValue(); 
    741741     CTimer::get("XIOS").suspend(); 
    742742  } 
     
    754754  void cxios_get_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl, int* zoom_nj_loc) 
    755755  { 
    756     *zoom_nj_loc = domaingroup_hdl->zoom_nj_loc.getValue(); 
     756    *zoom_nj_loc = domaingroup_hdl->zoom_nj_loc.getInheritedValue(); 
    757757  } 
    758758   
     
    760760  { 
    761761     CTimer::get("XIOS").resume(); 
    762     return !domaingroup_hdl->zoom_nj_loc.isEmpty(); 
     762    return domaingroup_hdl->zoom_nj_loc.hasInheritedValue(); 
    763763     CTimer::get("XIOS").suspend(); 
    764764  } 
  • XIOS/trunk/src/interface/c_attr/icfield_attr.cpp

    r432 r445  
    3030  { 
    3131     CTimer::get("XIOS").resume(); 
    32     if(!string_copy(field_hdl->axis_ref.getValue(),axis_ref , axis_ref_size)) 
     32    if(!string_copy(field_hdl->axis_ref.getInheritedValue(),axis_ref , axis_ref_size)) 
    3333      ERROR("void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short"); 
    3434     CTimer::get("XIOS").suspend(); 
     
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return !field_hdl->axis_ref.isEmpty(); 
     40    return field_hdl->axis_ref.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
    4242  } 
     
    5454  void cxios_get_field_default_value(field_Ptr field_hdl, double* default_value) 
    5555  { 
    56     *default_value = field_hdl->default_value.getValue(); 
     56    *default_value = field_hdl->default_value.getInheritedValue(); 
    5757  } 
    5858   
     
    6060  { 
    6161     CTimer::get("XIOS").resume(); 
    62     return !field_hdl->default_value.isEmpty(); 
     62    return field_hdl->default_value.hasInheritedValue(); 
    6363     CTimer::get("XIOS").suspend(); 
    6464  } 
     
    7979  { 
    8080     CTimer::get("XIOS").resume(); 
    81     if(!string_copy(field_hdl->domain_ref.getValue(),domain_ref , domain_ref_size)) 
     81    if(!string_copy(field_hdl->domain_ref.getInheritedValue(),domain_ref , domain_ref_size)) 
    8282      ERROR("void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short"); 
    8383     CTimer::get("XIOS").suspend(); 
     
    8787  { 
    8888     CTimer::get("XIOS").resume(); 
    89     return !field_hdl->domain_ref.isEmpty(); 
     89    return field_hdl->domain_ref.hasInheritedValue(); 
    9090     CTimer::get("XIOS").suspend(); 
    9191  } 
     
    103103  void cxios_get_field_enabled(field_Ptr field_hdl, bool* enabled) 
    104104  { 
    105     *enabled = field_hdl->enabled.getValue(); 
     105    *enabled = field_hdl->enabled.getInheritedValue(); 
    106106  } 
    107107   
     
    109109  { 
    110110     CTimer::get("XIOS").resume(); 
    111     return !field_hdl->enabled.isEmpty(); 
     111    return field_hdl->enabled.hasInheritedValue(); 
    112112     CTimer::get("XIOS").suspend(); 
    113113  } 
     
    128128  { 
    129129     CTimer::get("XIOS").resume(); 
    130     if(!string_copy(field_hdl->field_ref.getValue(),field_ref , field_ref_size)) 
     130    if(!string_copy(field_hdl->field_ref.getInheritedValue(),field_ref , field_ref_size)) 
    131131      ERROR("void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)", <<"Input string is to short"); 
    132132     CTimer::get("XIOS").suspend(); 
     
    136136  { 
    137137     CTimer::get("XIOS").resume(); 
    138     return !field_hdl->field_ref.isEmpty(); 
     138    return field_hdl->field_ref.hasInheritedValue(); 
    139139     CTimer::get("XIOS").suspend(); 
    140140  } 
     
    155155  { 
    156156     CTimer::get("XIOS").resume(); 
    157     if(!string_copy(field_hdl->freq_offset.getValue(),freq_offset , freq_offset_size)) 
     157    if(!string_copy(field_hdl->freq_offset.getInheritedValue(),freq_offset , freq_offset_size)) 
    158158      ERROR("void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size)", <<"Input string is to short"); 
    159159     CTimer::get("XIOS").suspend(); 
     
    163163  { 
    164164     CTimer::get("XIOS").resume(); 
    165     return !field_hdl->freq_offset.isEmpty(); 
     165    return field_hdl->freq_offset.hasInheritedValue(); 
    166166     CTimer::get("XIOS").suspend(); 
    167167  } 
     
    182182  { 
    183183     CTimer::get("XIOS").resume(); 
    184     if(!string_copy(field_hdl->freq_op.getValue(),freq_op , freq_op_size)) 
     184    if(!string_copy(field_hdl->freq_op.getInheritedValue(),freq_op , freq_op_size)) 
    185185      ERROR("void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size)", <<"Input string is to short"); 
    186186     CTimer::get("XIOS").suspend(); 
     
    190190  { 
    191191     CTimer::get("XIOS").resume(); 
    192     return !field_hdl->freq_op.isEmpty(); 
     192    return field_hdl->freq_op.hasInheritedValue(); 
    193193     CTimer::get("XIOS").suspend(); 
    194194  } 
     
    209209  { 
    210210     CTimer::get("XIOS").resume(); 
    211     if(!string_copy(field_hdl->grid_ref.getValue(),grid_ref , grid_ref_size)) 
     211    if(!string_copy(field_hdl->grid_ref.getInheritedValue(),grid_ref , grid_ref_size)) 
    212212      ERROR("void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)", <<"Input string is to short"); 
    213213     CTimer::get("XIOS").suspend(); 
     
    217217  { 
    218218     CTimer::get("XIOS").resume(); 
    219     return !field_hdl->grid_ref.isEmpty(); 
     219    return field_hdl->grid_ref.hasInheritedValue(); 
    220220     CTimer::get("XIOS").suspend(); 
    221221  } 
     
    233233  void cxios_get_field_level(field_Ptr field_hdl, int* level) 
    234234  { 
    235     *level = field_hdl->level.getValue(); 
     235    *level = field_hdl->level.getInheritedValue(); 
    236236  } 
    237237   
     
    239239  { 
    240240     CTimer::get("XIOS").resume(); 
    241     return !field_hdl->level.isEmpty(); 
     241    return field_hdl->level.hasInheritedValue(); 
    242242     CTimer::get("XIOS").suspend(); 
    243243  } 
     
    258258  { 
    259259     CTimer::get("XIOS").resume(); 
    260     if(!string_copy(field_hdl->long_name.getValue(),long_name , long_name_size)) 
     260    if(!string_copy(field_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    261261      ERROR("void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    262262     CTimer::get("XIOS").suspend(); 
     
    266266  { 
    267267     CTimer::get("XIOS").resume(); 
    268     return !field_hdl->long_name.isEmpty(); 
     268    return field_hdl->long_name.hasInheritedValue(); 
    269269     CTimer::get("XIOS").suspend(); 
    270270  } 
     
    285285  { 
    286286     CTimer::get("XIOS").resume(); 
    287     if(!string_copy(field_hdl->name.getValue(),name , name_size)) 
     287    if(!string_copy(field_hdl->name.getInheritedValue(),name , name_size)) 
    288288      ERROR("void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)", <<"Input string is to short"); 
    289289     CTimer::get("XIOS").suspend(); 
     
    293293  { 
    294294     CTimer::get("XIOS").resume(); 
    295     return !field_hdl->name.isEmpty(); 
     295    return field_hdl->name.hasInheritedValue(); 
    296296     CTimer::get("XIOS").suspend(); 
    297297  } 
     
    312312  { 
    313313     CTimer::get("XIOS").resume(); 
    314     if(!string_copy(field_hdl->operation.getValue(),operation , operation_size)) 
     314    if(!string_copy(field_hdl->operation.getInheritedValue(),operation , operation_size)) 
    315315      ERROR("void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)", <<"Input string is to short"); 
    316316     CTimer::get("XIOS").suspend(); 
     
    320320  { 
    321321     CTimer::get("XIOS").resume(); 
    322     return !field_hdl->operation.isEmpty(); 
     322    return field_hdl->operation.hasInheritedValue(); 
    323323     CTimer::get("XIOS").suspend(); 
    324324  } 
     
    336336  void cxios_get_field_prec(field_Ptr field_hdl, int* prec) 
    337337  { 
    338     *prec = field_hdl->prec.getValue(); 
     338    *prec = field_hdl->prec.getInheritedValue(); 
    339339  } 
    340340   
     
    342342  { 
    343343     CTimer::get("XIOS").resume(); 
    344     return !field_hdl->prec.isEmpty(); 
     344    return field_hdl->prec.hasInheritedValue(); 
    345345     CTimer::get("XIOS").suspend(); 
    346346  } 
     
    361361  { 
    362362     CTimer::get("XIOS").resume(); 
    363     if(!string_copy(field_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
     363    if(!string_copy(field_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    364364      ERROR("void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    365365     CTimer::get("XIOS").suspend(); 
     
    369369  { 
    370370     CTimer::get("XIOS").resume(); 
    371     return !field_hdl->standard_name.isEmpty(); 
     371    return field_hdl->standard_name.hasInheritedValue(); 
    372372     CTimer::get("XIOS").suspend(); 
    373373  } 
     
    388388  { 
    389389     CTimer::get("XIOS").resume(); 
    390     if(!string_copy(field_hdl->unit.getValue(),unit , unit_size)) 
     390    if(!string_copy(field_hdl->unit.getInheritedValue(),unit , unit_size)) 
    391391      ERROR("void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
    392392     CTimer::get("XIOS").suspend(); 
     
    396396  { 
    397397     CTimer::get("XIOS").resume(); 
    398     return !field_hdl->unit.isEmpty(); 
     398    return field_hdl->unit.hasInheritedValue(); 
    399399     CTimer::get("XIOS").suspend(); 
    400400  } 
  • XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp

    r432 r445  
    3030  { 
    3131     CTimer::get("XIOS").resume(); 
    32     if(!string_copy(fieldgroup_hdl->axis_ref.getValue(),axis_ref , axis_ref_size)) 
     32    if(!string_copy(fieldgroup_hdl->axis_ref.getInheritedValue(),axis_ref , axis_ref_size)) 
    3333      ERROR("void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short"); 
    3434     CTimer::get("XIOS").suspend(); 
     
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return !fieldgroup_hdl->axis_ref.isEmpty(); 
     40    return fieldgroup_hdl->axis_ref.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
    4242  } 
     
    5454  void cxios_get_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double* default_value) 
    5555  { 
    56     *default_value = fieldgroup_hdl->default_value.getValue(); 
     56    *default_value = fieldgroup_hdl->default_value.getInheritedValue(); 
    5757  } 
    5858   
     
    6060  { 
    6161     CTimer::get("XIOS").resume(); 
    62     return !fieldgroup_hdl->default_value.isEmpty(); 
     62    return fieldgroup_hdl->default_value.hasInheritedValue(); 
    6363     CTimer::get("XIOS").suspend(); 
    6464  } 
     
    7979  { 
    8080     CTimer::get("XIOS").resume(); 
    81     if(!string_copy(fieldgroup_hdl->domain_ref.getValue(),domain_ref , domain_ref_size)) 
     81    if(!string_copy(fieldgroup_hdl->domain_ref.getInheritedValue(),domain_ref , domain_ref_size)) 
    8282      ERROR("void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short"); 
    8383     CTimer::get("XIOS").suspend(); 
     
    8787  { 
    8888     CTimer::get("XIOS").resume(); 
    89     return !fieldgroup_hdl->domain_ref.isEmpty(); 
     89    return fieldgroup_hdl->domain_ref.hasInheritedValue(); 
    9090     CTimer::get("XIOS").suspend(); 
    9191  } 
     
    103103  void cxios_get_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool* enabled) 
    104104  { 
    105     *enabled = fieldgroup_hdl->enabled.getValue(); 
     105    *enabled = fieldgroup_hdl->enabled.getInheritedValue(); 
    106106  } 
    107107   
     
    109109  { 
    110110     CTimer::get("XIOS").resume(); 
    111     return !fieldgroup_hdl->enabled.isEmpty(); 
     111    return fieldgroup_hdl->enabled.hasInheritedValue(); 
    112112     CTimer::get("XIOS").suspend(); 
    113113  } 
     
    128128  { 
    129129     CTimer::get("XIOS").resume(); 
    130     if(!string_copy(fieldgroup_hdl->field_ref.getValue(),field_ref , field_ref_size)) 
     130    if(!string_copy(fieldgroup_hdl->field_ref.getInheritedValue(),field_ref , field_ref_size)) 
    131131      ERROR("void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)", <<"Input string is to short"); 
    132132     CTimer::get("XIOS").suspend(); 
     
    136136  { 
    137137     CTimer::get("XIOS").resume(); 
    138     return !fieldgroup_hdl->field_ref.isEmpty(); 
     138    return fieldgroup_hdl->field_ref.hasInheritedValue(); 
    139139     CTimer::get("XIOS").suspend(); 
    140140  } 
     
    155155  { 
    156156     CTimer::get("XIOS").resume(); 
    157     if(!string_copy(fieldgroup_hdl->freq_offset.getValue(),freq_offset , freq_offset_size)) 
     157    if(!string_copy(fieldgroup_hdl->freq_offset.getInheritedValue(),freq_offset , freq_offset_size)) 
    158158      ERROR("void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, char * freq_offset, int freq_offset_size)", <<"Input string is to short"); 
    159159     CTimer::get("XIOS").suspend(); 
     
    163163  { 
    164164     CTimer::get("XIOS").resume(); 
    165     return !fieldgroup_hdl->freq_offset.isEmpty(); 
     165    return fieldgroup_hdl->freq_offset.hasInheritedValue(); 
    166166     CTimer::get("XIOS").suspend(); 
    167167  } 
     
    182182  { 
    183183     CTimer::get("XIOS").resume(); 
    184     if(!string_copy(fieldgroup_hdl->freq_op.getValue(),freq_op , freq_op_size)) 
     184    if(!string_copy(fieldgroup_hdl->freq_op.getInheritedValue(),freq_op , freq_op_size)) 
    185185      ERROR("void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, char * freq_op, int freq_op_size)", <<"Input string is to short"); 
    186186     CTimer::get("XIOS").suspend(); 
     
    190190  { 
    191191     CTimer::get("XIOS").resume(); 
    192     return !fieldgroup_hdl->freq_op.isEmpty(); 
     192    return fieldgroup_hdl->freq_op.hasInheritedValue(); 
    193193     CTimer::get("XIOS").suspend(); 
    194194  } 
     
    209209  { 
    210210     CTimer::get("XIOS").resume(); 
    211     if(!string_copy(fieldgroup_hdl->grid_ref.getValue(),grid_ref , grid_ref_size)) 
     211    if(!string_copy(fieldgroup_hdl->grid_ref.getInheritedValue(),grid_ref , grid_ref_size)) 
    212212      ERROR("void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)", <<"Input string is to short"); 
    213213     CTimer::get("XIOS").suspend(); 
     
    217217  { 
    218218     CTimer::get("XIOS").resume(); 
    219     return !fieldgroup_hdl->grid_ref.isEmpty(); 
     219    return fieldgroup_hdl->grid_ref.hasInheritedValue(); 
    220220     CTimer::get("XIOS").suspend(); 
    221221  } 
     
    236236  { 
    237237     CTimer::get("XIOS").resume(); 
    238     if(!string_copy(fieldgroup_hdl->group_ref.getValue(),group_ref , group_ref_size)) 
     238    if(!string_copy(fieldgroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size)) 
    239239      ERROR("void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
    240240     CTimer::get("XIOS").suspend(); 
     
    244244  { 
    245245     CTimer::get("XIOS").resume(); 
    246     return !fieldgroup_hdl->group_ref.isEmpty(); 
     246    return fieldgroup_hdl->group_ref.hasInheritedValue(); 
    247247     CTimer::get("XIOS").suspend(); 
    248248  } 
     
    260260  void cxios_get_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int* level) 
    261261  { 
    262     *level = fieldgroup_hdl->level.getValue(); 
     262    *level = fieldgroup_hdl->level.getInheritedValue(); 
    263263  } 
    264264   
     
    266266  { 
    267267     CTimer::get("XIOS").resume(); 
    268     return !fieldgroup_hdl->level.isEmpty(); 
     268    return fieldgroup_hdl->level.hasInheritedValue(); 
    269269     CTimer::get("XIOS").suspend(); 
    270270  } 
     
    285285  { 
    286286     CTimer::get("XIOS").resume(); 
    287     if(!string_copy(fieldgroup_hdl->long_name.getValue(),long_name , long_name_size)) 
     287    if(!string_copy(fieldgroup_hdl->long_name.getInheritedValue(),long_name , long_name_size)) 
    288288      ERROR("void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
    289289     CTimer::get("XIOS").suspend(); 
     
    293293  { 
    294294     CTimer::get("XIOS").resume(); 
    295     return !fieldgroup_hdl->long_name.isEmpty(); 
     295    return fieldgroup_hdl->long_name.hasInheritedValue(); 
    296296     CTimer::get("XIOS").suspend(); 
    297297  } 
     
    312312  { 
    313313     CTimer::get("XIOS").resume(); 
    314     if(!string_copy(fieldgroup_hdl->name.getValue(),name , name_size)) 
     314    if(!string_copy(fieldgroup_hdl->name.getInheritedValue(),name , name_size)) 
    315315      ERROR("void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
    316316     CTimer::get("XIOS").suspend(); 
     
    320320  { 
    321321     CTimer::get("XIOS").resume(); 
    322     return !fieldgroup_hdl->name.isEmpty(); 
     322    return fieldgroup_hdl->name.hasInheritedValue(); 
    323323     CTimer::get("XIOS").suspend(); 
    324324  } 
     
    339339  { 
    340340     CTimer::get("XIOS").resume(); 
    341     if(!string_copy(fieldgroup_hdl->operation.getValue(),operation , operation_size)) 
     341    if(!string_copy(fieldgroup_hdl->operation.getInheritedValue(),operation , operation_size)) 
    342342      ERROR("void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)", <<"Input string is to short"); 
    343343     CTimer::get("XIOS").suspend(); 
     
    347347  { 
    348348     CTimer::get("XIOS").resume(); 
    349     return !fieldgroup_hdl->operation.isEmpty(); 
     349    return fieldgroup_hdl->operation.hasInheritedValue(); 
    350350     CTimer::get("XIOS").suspend(); 
    351351  } 
     
    363363  void cxios_get_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int* prec) 
    364364  { 
    365     *prec = fieldgroup_hdl->prec.getValue(); 
     365    *prec = fieldgroup_hdl->prec.getInheritedValue(); 
    366366  } 
    367367   
     
    369369  { 
    370370     CTimer::get("XIOS").resume(); 
    371     return !fieldgroup_hdl->prec.isEmpty(); 
     371    return fieldgroup_hdl->prec.hasInheritedValue(); 
    372372     CTimer::get("XIOS").suspend(); 
    373373  } 
     
    388388  { 
    389389     CTimer::get("XIOS").resume(); 
    390     if(!string_copy(fieldgroup_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
     390    if(!string_copy(fieldgroup_hdl->standard_name.getInheritedValue(),standard_name , standard_name_size)) 
    391391      ERROR("void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
    392392     CTimer::get("XIOS").suspend(); 
     
    396396  { 
    397397     CTimer::get("XIOS").resume(); 
    398     return !fieldgroup_hdl->standard_name.isEmpty(); 
     398    return fieldgroup_hdl->standard_name.hasInheritedValue(); 
    399399     CTimer::get("XIOS").suspend(); 
    400400  } 
     
    415415  { 
    416416     CTimer::get("XIOS").resume(); 
    417     if(!string_copy(fieldgroup_hdl->unit.getValue(),unit , unit_size)) 
     417    if(!string_copy(fieldgroup_hdl->unit.getInheritedValue(),unit , unit_size)) 
    418418      ERROR("void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
    419419     CTimer::get("XIOS").suspend(); 
     
    423423  { 
    424424     CTimer::get("XIOS").resume(); 
    425     return !fieldgroup_hdl->unit.isEmpty(); 
     425    return fieldgroup_hdl->unit.hasInheritedValue(); 
    426426     CTimer::get("XIOS").suspend(); 
    427427  } 
  • XIOS/trunk/src/interface/c_attr/icfile_attr.cpp

    r432 r445  
    3030  { 
    3131     CTimer::get("XIOS").resume(); 
    32     if(!string_copy(file_hdl->description.getValue(),description , description_size)) 
     32    if(!string_copy(file_hdl->description.getInheritedValue(),description , description_size)) 
    3333      ERROR("void cxios_get_file_description(file_Ptr file_hdl, char * description, int description_size)", <<"Input string is to short"); 
    3434     CTimer::get("XIOS").suspend(); 
     
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return !file_hdl->description.isEmpty(); 
     40    return file_hdl->description.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
    4242  } 
     
    5454  void cxios_get_file_enabled(file_Ptr file_hdl, bool* enabled) 
    5555  { 
    56     *enabled = file_hdl->enabled.getValue(); 
     56    *enabled = file_hdl->enabled.getInheritedValue(); 
    5757  } 
    5858   
     
    6060  { 
    6161     CTimer::get("XIOS").resume(); 
    62     return !file_hdl->enabled.isEmpty(); 
     62    return file_hdl->enabled.hasInheritedValue(); 
    6363     CTimer::get("XIOS").suspend(); 
    6464  } 
     
    7676  void cxios_get_file_min_digits(file_Ptr file_hdl, int* min_digits) 
    7777  { 
    78     *min_digits = file_hdl->min_digits.getValue(); 
     78    *min_digits = file_hdl->min_digits.getInheritedValue(); 
    7979  } 
    8080   
     
    8282  { 
    8383     CTimer::get("XIOS").resume(); 
    84     return !file_hdl->min_digits.isEmpty(); 
     84    return file_hdl->min_digits.hasInheritedValue(); 
    8585     CTimer::get("XIOS").suspend(); 
    8686  } 
     
    101101  { 
    102102     CTimer::get("XIOS").resume(); 
    103     if(!string_copy(file_hdl->name.getValue(),name , name_size)) 
     103    if(!string_copy(file_hdl->name.getInheritedValue(),name , name_size)) 
    104104      ERROR("void cxios_get_file_name(file_Ptr file_hdl, char * name, int name_size)", <<"Input string is to short"); 
    105105     CTimer::get("XIOS").suspend(); 
     
    109109  { 
    110110     CTimer::get("XIOS").resume(); 
    111     return !file_hdl->name.isEmpty(); 
     111    return file_hdl->name.hasInheritedValue(); 
    112112     CTimer::get("XIOS").suspend(); 
    113113  } 
     
    128128  { 
    129129     CTimer::get("XIOS").resume(); 
    130     if(!string_copy(file_hdl->name_suffix.getValue(),name_suffix , name_suffix_size)) 
     130    if(!string_copy(file_hdl->name_suffix.getInheritedValue(),name_suffix , name_suffix_size)) 
    131131      ERROR("void cxios_get_file_name_suffix(file_Ptr file_hdl, char * name_suffix, int name_suffix_size)", <<"Input string is to short"); 
    132132     CTimer::get("XIOS").suspend(); 
     
    136136  { 
    137137     CTimer::get("XIOS").resume(); 
    138     return !file_hdl->name_suffix.isEmpty(); 
     138    return file_hdl->name_suffix.hasInheritedValue(); 
    139139     CTimer::get("XIOS").suspend(); 
    140140  } 
     
    155155  { 
    156156     CTimer::get("XIOS").resume(); 
    157     if(!string_copy(file_hdl->output_freq.getValue(),output_freq , output_freq_size)) 
     157    if(!string_copy(file_hdl->output_freq.getInheritedValue(),output_freq , output_freq_size)) 
    158158      ERROR("void cxios_get_file_output_freq(file_Ptr file_hdl, char * output_freq, int output_freq_size)", <<"Input string is to short"); 
    159159     CTimer::get("XIOS").suspend(); 
     
    163163  { 
    164164     CTimer::get("XIOS").resume(); 
    165     return !file_hdl->output_freq.isEmpty(); 
     165    return file_hdl->output_freq.hasInheritedValue(); 
    166166     CTimer::get("XIOS").suspend(); 
    167167  } 
     
    179179  void cxios_get_file_output_level(file_Ptr file_hdl, int* output_level) 
    180180  { 
    181     *output_level = file_hdl->output_level.getValue(); 
     181    *output_level = file_hdl->output_level.getInheritedValue(); 
    182182  } 
    183183   
     
    185185  { 
    186186     CTimer::get("XIOS").resume(); 
    187     return !file_hdl->output_level.isEmpty(); 
     187    return file_hdl->output_level.hasInheritedValue(); 
    188188     CTimer::get("XIOS").suspend(); 
    189189  } 
     
    204204  { 
    205205     CTimer::get("XIOS").resume(); 
    206     if(!string_copy(file_hdl->par_access.getValue(),par_access , par_access_size)) 
     206    if(!string_copy(file_hdl->par_access.getInheritedValue(),par_access , par_access_size)) 
    207207      ERROR("void cxios_get_file_par_access(file_Ptr file_hdl, char * par_access, int par_access_size)", <<"Input string is to short"); 
    208208     CTimer::get("XIOS").suspend(); 
     
    212212  { 
    213213     CTimer::get("XIOS").resume(); 
    214     return !file_hdl->par_access.isEmpty(); 
     214    return file_hdl->par_access.hasInheritedValue(); 
    215215     CTimer::get("XIOS").suspend(); 
    216216  } 
     
    231231  { 
    232232     CTimer::get("XIOS").resume(); 
    233     if(!string_copy(file_hdl->split_freq.getValue(),split_freq , split_freq_size)) 
     233    if(!string_copy(file_hdl->split_freq.getInheritedValue(),split_freq , split_freq_size)) 
    234234      ERROR("void cxios_get_file_split_freq(file_Ptr file_hdl, char * split_freq, int split_freq_size)", <<"Input string is to short"); 
    235235     CTimer::get("XIOS").suspend(); 
     
    239239  { 
    240240     CTimer::get("XIOS").resume(); 
    241     return !file_hdl->split_freq.isEmpty(); 
     241    return file_hdl->split_freq.hasInheritedValue(); 
    242242     CTimer::get("XIOS").suspend(); 
    243243  } 
     
    258258  { 
    259259     CTimer::get("XIOS").resume(); 
    260     if(!string_copy(file_hdl->split_freq_format.getValue(),split_freq_format , split_freq_format_size)) 
     260    if(!string_copy(file_hdl->split_freq_format.getInheritedValue(),split_freq_format , split_freq_format_size)) 
    261261      ERROR("void cxios_get_file_split_freq_format(file_Ptr file_hdl, char * split_freq_format, int split_freq_format_size)", <<"Input string is to short"); 
    262262     CTimer::get("XIOS").suspend(); 
     
    266266  { 
    267267     CTimer::get("XIOS").resume(); 
    268     return !file_hdl->split_freq_format.isEmpty(); 
     268    return file_hdl->split_freq_format.hasInheritedValue(); 
    269269     CTimer::get("XIOS").suspend(); 
    270270  } 
     
    285285  { 
    286286     CTimer::get("XIOS").resume(); 
    287     if(!string_copy(file_hdl->sync_freq.getValue(),sync_freq , sync_freq_size)) 
     287    if(!string_copy(file_hdl->sync_freq.getInheritedValue(),sync_freq , sync_freq_size)) 
    288288      ERROR("void cxios_get_file_sync_freq(file_Ptr file_hdl, char * sync_freq, int sync_freq_size)", <<"Input string is to short"); 
    289289     CTimer::get("XIOS").suspend(); 
     
    293293  { 
    294294     CTimer::get("XIOS").resume(); 
    295     return !file_hdl->sync_freq.isEmpty(); 
     295    return file_hdl->sync_freq.hasInheritedValue(); 
    296296     CTimer::get("XIOS").suspend(); 
    297297  } 
     
    312312  { 
    313313     CTimer::get("XIOS").resume(); 
    314     if(!string_copy(file_hdl->type.getStringValue(),type , type_size)) 
     314    if(!string_copy(file_hdl->type.getInheritedStringValue(),type , type_size)) 
    315315      ERROR("void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size)", <<"Input string is to short"); 
    316316     CTimer::get("XIOS").suspend(); 
     
    320320  { 
    321321     CTimer::get("XIOS").resume(); 
    322     return !file_hdl->type.isEmpty(); 
     322    return file_hdl->type.hasInheritedValue(); 
    323323     CTimer::get("XIOS").suspend(); 
    324324  } 
  • XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp

    r432 r445  
    3030  { 
    3131     CTimer::get("XIOS").resume(); 
    32     if(!string_copy(filegroup_hdl->description.getValue(),description , description_size)) 
     32    if(!string_copy(filegroup_hdl->description.getInheritedValue(),description , description_size)) 
    3333      ERROR("void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)", <<"Input string is to short"); 
    3434     CTimer::get("XIOS").suspend(); 
     
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return !filegroup_hdl->description.isEmpty(); 
     40    return filegroup_hdl->description.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
    4242  } 
     
    5454  void cxios_get_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool* enabled) 
    5555  { 
    56     *enabled = filegroup_hdl->enabled.getValue(); 
     56    *enabled = filegroup_hdl->enabled.getInheritedValue(); 
    5757  } 
    5858   
     
    6060  { 
    6161     CTimer::get("XIOS").resume(); 
    62     return !filegroup_hdl->enabled.isEmpty(); 
     62    return filegroup_hdl->enabled.hasInheritedValue(); 
    6363     CTimer::get("XIOS").suspend(); 
    6464  } 
     
    7979  { 
    8080     CTimer::get("XIOS").resume(); 
    81     if(!string_copy(filegroup_hdl->group_ref.getValue(),group_ref , group_ref_size)) 
     81    if(!string_copy(filegroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size)) 
    8282      ERROR("void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
    8383     CTimer::get("XIOS").suspend(); 
     
    8787  { 
    8888     CTimer::get("XIOS").resume(); 
    89     return !filegroup_hdl->group_ref.isEmpty(); 
     89    return filegroup_hdl->group_ref.hasInheritedValue(); 
    9090     CTimer::get("XIOS").suspend(); 
    9191  } 
     
    103103  void cxios_get_filegroup_min_digits(filegroup_Ptr filegroup_hdl, int* min_digits) 
    104104  { 
    105     *min_digits = filegroup_hdl->min_digits.getValue(); 
     105    *min_digits = filegroup_hdl->min_digits.getInheritedValue(); 
    106106  } 
    107107   
     
    109109  { 
    110110     CTimer::get("XIOS").resume(); 
    111     return !filegroup_hdl->min_digits.isEmpty(); 
     111    return filegroup_hdl->min_digits.hasInheritedValue(); 
    112112     CTimer::get("XIOS").suspend(); 
    113113  } 
     
    128128  { 
    129129     CTimer::get("XIOS").resume(); 
    130     if(!string_copy(filegroup_hdl->name.getValue(),name , name_size)) 
     130    if(!string_copy(filegroup_hdl->name.getInheritedValue(),name , name_size)) 
    131131      ERROR("void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
    132132     CTimer::get("XIOS").suspend(); 
     
    136136  { 
    137137     CTimer::get("XIOS").resume(); 
    138     return !filegroup_hdl->name.isEmpty(); 
     138    return filegroup_hdl->name.hasInheritedValue(); 
    139139     CTimer::get("XIOS").suspend(); 
    140140  } 
     
    155155  { 
    156156     CTimer::get("XIOS").resume(); 
    157     if(!string_copy(filegroup_hdl->name_suffix.getValue(),name_suffix , name_suffix_size)) 
     157    if(!string_copy(filegroup_hdl->name_suffix.getInheritedValue(),name_suffix , name_suffix_size)) 
    158158      ERROR("void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)", <<"Input string is to short"); 
    159159     CTimer::get("XIOS").suspend(); 
     
    163163  { 
    164164     CTimer::get("XIOS").resume(); 
    165     return !filegroup_hdl->name_suffix.isEmpty(); 
     165    return filegroup_hdl->name_suffix.hasInheritedValue(); 
    166166     CTimer::get("XIOS").suspend(); 
    167167  } 
     
    182182  { 
    183183     CTimer::get("XIOS").resume(); 
    184     if(!string_copy(filegroup_hdl->output_freq.getValue(),output_freq , output_freq_size)) 
     184    if(!string_copy(filegroup_hdl->output_freq.getInheritedValue(),output_freq , output_freq_size)) 
    185185      ERROR("void cxios_get_filegroup_output_freq(filegroup_Ptr filegroup_hdl, char * output_freq, int output_freq_size)", <<"Input string is to short"); 
    186186     CTimer::get("XIOS").suspend(); 
     
    190190  { 
    191191     CTimer::get("XIOS").resume(); 
    192     return !filegroup_hdl->output_freq.isEmpty(); 
     192    return filegroup_hdl->output_freq.hasInheritedValue(); 
    193193     CTimer::get("XIOS").suspend(); 
    194194  } 
     
    206206  void cxios_get_filegroup_output_level(filegroup_Ptr filegroup_hdl, int* output_level) 
    207207  { 
    208     *output_level = filegroup_hdl->output_level.getValue(); 
     208    *output_level = filegroup_hdl->output_level.getInheritedValue(); 
    209209  } 
    210210   
     
    212212  { 
    213213     CTimer::get("XIOS").resume(); 
    214     return !filegroup_hdl->output_level.isEmpty(); 
     214    return filegroup_hdl->output_level.hasInheritedValue(); 
    215215     CTimer::get("XIOS").suspend(); 
    216216  } 
     
    231231  { 
    232232     CTimer::get("XIOS").resume(); 
    233     if(!string_copy(filegroup_hdl->par_access.getValue(),par_access , par_access_size)) 
     233    if(!string_copy(filegroup_hdl->par_access.getInheritedValue(),par_access , par_access_size)) 
    234234      ERROR("void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)", <<"Input string is to short"); 
    235235     CTimer::get("XIOS").suspend(); 
     
    239239  { 
    240240     CTimer::get("XIOS").resume(); 
    241     return !filegroup_hdl->par_access.isEmpty(); 
     241    return filegroup_hdl->par_access.hasInheritedValue(); 
    242242     CTimer::get("XIOS").suspend(); 
    243243  } 
     
    258258  { 
    259259     CTimer::get("XIOS").resume(); 
    260     if(!string_copy(filegroup_hdl->split_freq.getValue(),split_freq , split_freq_size)) 
     260    if(!string_copy(filegroup_hdl->split_freq.getInheritedValue(),split_freq , split_freq_size)) 
    261261      ERROR("void cxios_get_filegroup_split_freq(filegroup_Ptr filegroup_hdl, char * split_freq, int split_freq_size)", <<"Input string is to short"); 
    262262     CTimer::get("XIOS").suspend(); 
     
    266266  { 
    267267     CTimer::get("XIOS").resume(); 
    268     return !filegroup_hdl->split_freq.isEmpty(); 
     268    return filegroup_hdl->split_freq.hasInheritedValue(); 
    269269     CTimer::get("XIOS").suspend(); 
    270270  } 
     
    285285  { 
    286286     CTimer::get("XIOS").resume(); 
    287     if(!string_copy(filegroup_hdl->split_freq_format.getValue(),split_freq_format , split_freq_format_size)) 
     287    if(!string_copy(filegroup_hdl->split_freq_format.getInheritedValue(),split_freq_format , split_freq_format_size)) 
    288288      ERROR("void cxios_get_filegroup_split_freq_format(filegroup_Ptr filegroup_hdl, char * split_freq_format, int split_freq_format_size)", <<"Input string is to short"); 
    289289     CTimer::get("XIOS").suspend(); 
     
    293293  { 
    294294     CTimer::get("XIOS").resume(); 
    295     return !filegroup_hdl->split_freq_format.isEmpty(); 
     295    return filegroup_hdl->split_freq_format.hasInheritedValue(); 
    296296     CTimer::get("XIOS").suspend(); 
    297297  } 
     
    312312  { 
    313313     CTimer::get("XIOS").resume(); 
    314     if(!string_copy(filegroup_hdl->sync_freq.getValue(),sync_freq , sync_freq_size)) 
     314    if(!string_copy(filegroup_hdl->sync_freq.getInheritedValue(),sync_freq , sync_freq_size)) 
    315315      ERROR("void cxios_get_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, char * sync_freq, int sync_freq_size)", <<"Input string is to short"); 
    316316     CTimer::get("XIOS").suspend(); 
     
    320320  { 
    321321     CTimer::get("XIOS").resume(); 
    322     return !filegroup_hdl->sync_freq.isEmpty(); 
     322    return filegroup_hdl->sync_freq.hasInheritedValue(); 
    323323     CTimer::get("XIOS").suspend(); 
    324324  } 
     
    339339  { 
    340340     CTimer::get("XIOS").resume(); 
    341     if(!string_copy(filegroup_hdl->type.getStringValue(),type , type_size)) 
     341    if(!string_copy(filegroup_hdl->type.getInheritedStringValue(),type , type_size)) 
    342342      ERROR("void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)", <<"Input string is to short"); 
    343343     CTimer::get("XIOS").suspend(); 
     
    347347  { 
    348348     CTimer::get("XIOS").resume(); 
    349     return !filegroup_hdl->type.isEmpty(); 
     349    return filegroup_hdl->type.hasInheritedValue(); 
    350350     CTimer::get("XIOS").suspend(); 
    351351  } 
  • XIOS/trunk/src/interface/c_attr/icgrid_attr.cpp

    r432 r445  
    3030  { 
    3131     CTimer::get("XIOS").resume(); 
    32     if(!string_copy(grid_hdl->axis_ref.getValue(),axis_ref , axis_ref_size)) 
     32    if(!string_copy(grid_hdl->axis_ref.getInheritedValue(),axis_ref , axis_ref_size)) 
    3333      ERROR("void cxios_get_grid_axis_ref(grid_Ptr grid_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short"); 
    3434     CTimer::get("XIOS").suspend(); 
     
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return !grid_hdl->axis_ref.isEmpty(); 
     40    return grid_hdl->axis_ref.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
    4242  } 
     
    5757  { 
    5858     CTimer::get("XIOS").resume(); 
    59     if(!string_copy(grid_hdl->description.getValue(),description , description_size)) 
     59    if(!string_copy(grid_hdl->description.getInheritedValue(),description , description_size)) 
    6060      ERROR("void cxios_get_grid_description(grid_Ptr grid_hdl, char * description, int description_size)", <<"Input string is to short"); 
    6161     CTimer::get("XIOS").suspend(); 
     
    6565  { 
    6666     CTimer::get("XIOS").resume(); 
    67     return !grid_hdl->description.isEmpty(); 
     67    return grid_hdl->description.hasInheritedValue(); 
    6868     CTimer::get("XIOS").suspend(); 
    6969  } 
     
    8484  { 
    8585     CTimer::get("XIOS").resume(); 
    86     if(!string_copy(grid_hdl->domain_ref.getValue(),domain_ref , domain_ref_size)) 
     86    if(!string_copy(grid_hdl->domain_ref.getInheritedValue(),domain_ref , domain_ref_size)) 
    8787      ERROR("void cxios_get_grid_domain_ref(grid_Ptr grid_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short"); 
    8888     CTimer::get("XIOS").suspend(); 
     
    9292  { 
    9393     CTimer::get("XIOS").resume(); 
    94     return !grid_hdl->domain_ref.isEmpty(); 
     94    return grid_hdl->domain_ref.hasInheritedValue(); 
    9595     CTimer::get("XIOS").suspend(); 
    9696  } 
     
    111111    CTimer::get("XIOS").resume(); 
    112112    CArray<bool,3> tmp(mask,shape(extent1,extent2,extent3),neverDeleteData) ; 
    113     tmp=grid_hdl->mask ; 
     113    tmp=grid_hdl->mask.getInheritedValue() ; 
    114114     CTimer::get("XIOS").suspend(); 
    115115  } 
     
    118118  { 
    119119     CTimer::get("XIOS").resume(); 
    120     return !grid_hdl->mask.isEmpty(); 
     120    return grid_hdl->mask.hasInheritedValue(); 
    121121     CTimer::get("XIOS").suspend(); 
    122122  } 
     
    137137  { 
    138138     CTimer::get("XIOS").resume(); 
    139     if(!string_copy(grid_hdl->name.getValue(),name , name_size)) 
     139    if(!string_copy(grid_hdl->name.getInheritedValue(),name , name_size)) 
    140140      ERROR("void cxios_get_grid_name(grid_Ptr grid_hdl, char * name, int name_size)", <<"Input string is to short"); 
    141141     CTimer::get("XIOS").suspend(); 
     
    145145  { 
    146146     CTimer::get("XIOS").resume(); 
    147     return !grid_hdl->name.isEmpty(); 
     147    return grid_hdl->name.hasInheritedValue(); 
    148148     CTimer::get("XIOS").suspend(); 
    149149  } 
  • XIOS/trunk/src/interface/c_attr/icgridgroup_attr.cpp

    r432 r445  
    3030  { 
    3131     CTimer::get("XIOS").resume(); 
    32     if(!string_copy(gridgroup_hdl->axis_ref.getValue(),axis_ref , axis_ref_size)) 
     32    if(!string_copy(gridgroup_hdl->axis_ref.getInheritedValue(),axis_ref , axis_ref_size)) 
    3333      ERROR("void cxios_get_gridgroup_axis_ref(gridgroup_Ptr gridgroup_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short"); 
    3434     CTimer::get("XIOS").suspend(); 
     
    3838  { 
    3939     CTimer::get("XIOS").resume(); 
    40     return !gridgroup_hdl->axis_ref.isEmpty(); 
     40    return gridgroup_hdl->axis_ref.hasInheritedValue(); 
    4141     CTimer::get("XIOS").suspend(); 
    4242  } 
     
    5757  { 
    5858     CTimer::get("XIOS").resume(); 
    59     if(!string_copy(gridgroup_hdl->description.getValue(),description , description_size)) 
     59    if(!string_copy(gridgroup_hdl->description.getInheritedValue(),description , description_size)) 
    6060      ERROR("void cxios_get_gridgroup_description(gridgroup_Ptr gridgroup_hdl, char * description, int description_size)", <<"Input string is to short"); 
    6161     CTimer::get("XIOS").suspend(); 
     
    6565  { 
    6666     CTimer::get("XIOS").resume(); 
    67     return !gridgroup_hdl->description.isEmpty(); 
     67    return gridgroup_hdl->description.hasInheritedValue(); 
    6868     CTimer::get("XIOS").suspend(); 
    6969  } 
     
    8484  { 
    8585     CTimer::get("XIOS").resume(); 
    86     if(!string_copy(gridgroup_hdl->domain_ref.getValue(),domain_ref , domain_ref_size)) 
     86    if(!string_copy(gridgroup_hdl->domain_ref.getInheritedValue(),domain_ref , domain_ref_size)) 
    8787      ERROR("void cxios_get_gridgroup_domain_ref(gridgroup_Ptr gridgroup_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short"); 
    8888     CTimer::get("XIOS").suspend(); 
     
    9292  { 
    9393     CTimer::get("XIOS").resume(); 
    94     return !gridgroup_hdl->domain_ref.isEmpty(); 
     94    return gridgroup_hdl->domain_ref.hasInheritedValue(); 
    9595     CTimer::get("XIOS").suspend(); 
    9696  } 
     
    111111  { 
    112112     CTimer::get("XIOS").resume(); 
    113     if(!string_copy(gridgroup_hdl->group_ref.getValue(),group_ref , group_ref_size)) 
     113    if(!string_copy(gridgroup_hdl->group_ref.getInheritedValue(),group_ref , group_ref_size)) 
    114114      ERROR("void cxios_get_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
    115115     CTimer::get("XIOS").suspend(); 
     
    119119  { 
    120120     CTimer::get("XIOS").resume(); 
    121     return !gridgroup_hdl->group_ref.isEmpty(); 
     121    return gridgroup_hdl->group_ref.hasInheritedValue(); 
    122122     CTimer::get("XIOS").suspend(); 
    123123  } 
     
    138138    CTimer::get("XIOS").resume(); 
    139139    CArray<bool,3> tmp(mask,shape(extent1,extent2,extent3),neverDeleteData) ; 
    140     tmp=gridgroup_hdl->mask ; 
     140    tmp=gridgroup_hdl->mask.getInheritedValue() ; 
    141141     CTimer::get("XIOS").suspend(); 
    142142  } 
     
    145145  { 
    146146     CTimer::get("XIOS").resume(); 
    147     return !gridgroup_hdl->mask.isEmpty(); 
     147    return gridgroup_hdl->mask.hasInheritedValue(); 
    148148     CTimer::get("XIOS").suspend(); 
    149149  } 
     
    164164  { 
    165165     CTimer::get("XIOS").resume(); 
    166     if(!string_copy(gridgroup_hdl->name.getValue(),name , name_size)) 
     166    if(!string_copy(gridgroup_hdl->name.getInheritedValue(),name , name_size)) 
    167167      ERROR("void cxios_get_gridgroup_name(gridgroup_Ptr gridgroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
    168168     CTimer::get("XIOS").suspend(); 
     
    172172  { 
    173173     CTimer::get("XIOS").resume(); 
    174     return !gridgroup_hdl->name.isEmpty(); 
     174    return gridgroup_hdl->name.hasInheritedValue(); 
    175175     CTimer::get("XIOS").suspend(); 
    176176  } 
  • XIOS/trunk/src/interface/fortran/idata.F90

    r325 r445  
    3737      SUBROUTINE  cxios_finalize() BIND(C) 
    3838      END SUBROUTINE cxios_finalize 
     39 
     40      SUBROUTINE  cxios_solve_inheritance() BIND(C) 
     41      END SUBROUTINE cxios_solve_inheritance 
    3942 
    4043  
     
    148151   END SUBROUTINE xios(context_finalize) 
    149152    
    150  
     153   SUBROUTINE xios(solve_inheritance)() 
     154   IMPLICIT NONE 
     155      CALL cxios_solve_inheritance() 
     156   END SUBROUTINE xios(solve_inheritance) 
     157   
    151158    
    152159   SUBROUTINE xios(send_field_r8_1d)(fieldid, data1d_k8) 
  • XIOS/trunk/src/interface/fortran/ixios.F90

    r432 r445  
    1212                                                
    1313USE idata, ONLY : xios(initialize),xios(init_server), xios(finalize), xios(context_initialize),  & 
    14                   xios(close_context_definition),       & 
     14                  xios(close_context_definition),xios(solve_inheritance),       & 
    1515                  xios(context_finalize), xios(send_field_r8_1d), xios(send_field_r8_2d), & 
    1616                  xios(send_field_r8_3d), xios(send_field_r4_1d), xios(send_field_r4_2d), & 
     
    155155 PUBLIC :: xios(set_current_context)   
    156156 PUBLIC :: xios(set_timestep),xios(update_calendar) 
    157  PUBLIC :: xios(initialize), xios(init_server), xios(finalize), xios(context_initialize),                      & 
     157 PUBLIC :: xios(initialize), xios(init_server), xios(finalize), xios(context_initialize),xios(solve_inheritance), & 
    158158           xios(close_context_definition), xios(context_finalize), xios(send_field),xios(field_is_active) 
    159159 
  • XIOS/trunk/src/node/context.cpp

    r430 r445  
    245245   //---------------------------------------------------------------- 
    246246 
    247    void CContext::solveDescInheritance(const CAttributeMap * const UNUSED(parent)) 
     247   void CContext::solveDescInheritance(bool apply, const CAttributeMap * const UNUSED(parent)) 
    248248   { 
    249249#define DECLARE_NODE(Name_, name_)    \ 
    250250   if (C##Name_##Definition::has(C##Name_##Definition::GetDefName())) \ 
    251      C##Name_##Definition::get(C##Name_##Definition::GetDefName())->solveDescInheritance(); 
     251     C##Name_##Definition::get(C##Name_##Definition::GetDefName())->solveDescInheritance(apply); 
    252252#define DECLARE_NODE_PAR(Name_, name_) 
    253253#include "node_type.conf" 
     
    268268   //---------------------------------------------------------------- 
    269269 
    270    void CContext::solveFieldRefInheritance(void) 
     270   void CContext::solveFieldRefInheritance(bool apply) 
    271271   { 
    272272      if (!this->hasId()) return; 
     
    279279      { 
    280280         CField* field = *it; 
    281          field->solveRefInheritance(); 
     281         field->solveRefInheritance(apply); 
    282282      } 
    283283   } 
     
    370370   } 
    371371 
    372    void CContext::solveAllInheritance(void) 
     372   void CContext::solveAllInheritance(bool apply) 
    373373   { 
    374374     // Résolution des héritages descendants (càd des héritages de groupes) 
    375375     // pour chacun des contextes. 
    376       solveDescInheritance(); 
     376      solveDescInheritance(apply); 
    377377 
    378378     // Résolution des héritages par référence au niveau des fichiers. 
     
    380380 
    381381      for (unsigned int i = 0; i < allFiles.size(); i++) 
    382          allFiles[i]->solveFieldRefInheritance(); 
     382         allFiles[i]->solveFieldRefInheritance(apply); 
    383383   } 
    384384 
  • XIOS/trunk/src/node/context.hpp

    r382 r445  
    8787 
    8888         /// Traitements /// 
    89          virtual void solveDescInheritance(const CAttributeMap * const parent = 0); 
    90          void solveFieldRefInheritance(void); 
     89         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0); 
     90         void solveFieldRefInheritance(bool apply); 
    9191         void solveCalendar(void); 
    9292 
     
    112112         void solveAllGridRef(void); 
    113113         void solveAllOperation(void); 
    114          void solveAllInheritance(void) ; 
     114         void solveAllInheritance(bool apply=true) ; 
    115115         void findEnabledFiles(void); 
    116116         void closeAllFile(void) ; 
  • XIOS/trunk/src/node/field.cpp

    r439 r445  
    327327   //---------------------------------------------------------------- 
    328328 
    329    void CField::solveRefInheritance(void) 
     329   void CField::solveRefInheritance(bool apply) 
    330330   { 
    331331      std::set<CField *> sset; 
     
    347347         } 
    348348 
    349          SuperClassAttribute::setAttributes(refer_ptr); 
     349         SuperClassAttribute::setAttributes(refer_ptr, apply); 
    350350         sset.insert(refer_ptr); 
    351351         baseRefObject = refer_sptr; 
  • XIOS/trunk/src/node/field.hpp

    r436 r445  
    104104 
    105105         /// Traitements /// 
    106          void solveRefInheritance(void); 
     106         void solveRefInheritance(bool apply); 
    107107         void solveGridReference(void); 
    108108         void solveOperation(void); 
  • XIOS/trunk/src/node/file.cpp

    r431 r445  
    358358   //---------------------------------------------------------------- 
    359359    
    360    void CFile::solveDescInheritance(const CAttributeMap * const parent) 
    361    { 
    362       SuperClassAttribute::setAttributes(parent); 
    363       this->getVirtualFieldGroup()->solveDescInheritance(NULL); 
    364    } 
    365  
    366    //---------------------------------------------------------------- 
    367  
    368    void CFile::solveFieldRefInheritance(void) 
     360   void CFile::solveDescInheritance(bool apply, const CAttributeMap * const parent) 
     361   { 
     362      SuperClassAttribute::setAttributes(parent,apply); 
     363      this->getVirtualFieldGroup()->solveDescInheritance(apply, NULL); 
     364   } 
     365 
     366   //---------------------------------------------------------------- 
     367 
     368   void CFile::solveFieldRefInheritance(bool apply) 
    369369   { 
    370370      // Résolution des héritages par référence de chacun des champs contenus dans le fichier. 
    371371      std::vector<CField*> allF = this->getAllFields(); 
    372372      for (unsigned int i = 0; i < allF.size(); i++) 
    373          allF[i]->solveRefInheritance(); 
     373         allF[i]->solveRefInheritance(apply); 
    374374   } 
    375375 
  • XIOS/trunk/src/node/file.hpp

    r382 r445  
    7373          
    7474         /// Traitements /// 
    75          virtual void solveDescInheritance(const CAttributeMap * const parent = 0); 
    76          void solveFieldRefInheritance(void); 
     75         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0); 
     76         void solveFieldRefInheritance(bool apply); 
    7777         void solveEFGridRef(void); 
    7878         void solveEFOperation(void); 
  • XIOS/trunk/src/object_template.hpp

    r369 r445  
    5050 
    5151         /// Traitements /// 
    52          virtual void solveDescInheritance(const CAttributeMap * const parent = 0); 
     52         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0); 
    5353 
    5454         /// Traitement statique /// 
  • XIOS/trunk/src/object_template_impl.hpp

    r432 r445  
    139139 
    140140   template <class T> 
    141       void CObjectTemplate<T>::solveDescInheritance(const CAttributeMap * const parent) 
     141      void CObjectTemplate<T>::solveDescInheritance(bool apply, const CAttributeMap * const parent) 
    142142   {  
    143       SuperClassMap::setAttributes(parent);  
     143      SuperClassMap::setAttributes(parent, apply);  
    144144   } 
    145145 
Note: See TracChangeset for help on using the changeset viewer.