Ignore:
Timestamp:
06/19/13 10:09:36 (11 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/interface
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • 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 
Note: See TracChangeset for help on using the changeset viewer.