Ignore:
Timestamp:
10/16/12 13:04:44 (12 years ago)
Author:
ymipsl
Message:

Major Update

  • redesign Type and attribute manipulation
  • add enumerate type and attribute
  • use blitz class array instead of boost class array

YM

Location:
XIOS/trunk/src/interface/c_attr
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

    r352 r369  
    1111#include "icutil.hpp" 
    1212#include "timer.hpp" 
    13 #include "axis.hpp" 
     13#include "node_type.hpp" 
    1414 
    1515extern "C" 
    … …  
    109109  void cxios_set_axis_value(axis_Ptr axis_hdl, double* value, int extent1) 
    110110  { 
    111      CTimer::get("XIOS").resume(); 
    112     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    113     std::copy(value, &(value[array_tmp->num_elements()]), array_tmp->data()); 
    114     axis_hdl->value.setValue(array_tmp); 
     111    CTimer::get("XIOS").resume(); 
     112    CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ; 
     113    axis_hdl->value.reference(tmp.copy()); 
    115114    axis_hdl->sendAttributToServer(axis_hdl->value); 
    116115  } 
    … …  
    118117  void cxios_get_axis_value(axis_Ptr axis_hdl, double* value, int extent1) 
    119118  { 
    120     if (!array_copy(axis_hdl->value.getValue(), value, extent1)) 
    121      ERROR("void cxios_set_axis_value(axis_Ptr axis_hdl, double* value, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     119    CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ; 
     120    tmp=axis_hdl->value ; 
    122121     CTimer::get("XIOS").suspend(); 
     122  } 
     123   
     124   
     125  void cxios_set_axis_zoom_begin(axis_Ptr axis_hdl, int zoom_begin) 
     126  { 
     127     CTimer::get("XIOS").resume(); 
     128    axis_hdl->zoom_begin.setValue(zoom_begin); 
     129    axis_hdl->sendAttributToServer(axis_hdl->zoom_begin); 
     130     CTimer::get("XIOS").suspend(); 
     131  } 
     132   
     133  void cxios_get_axis_zoom_begin(axis_Ptr axis_hdl, int* zoom_begin) 
     134  { 
     135    *zoom_begin = axis_hdl->zoom_begin.getValue(); 
     136  } 
     137   
     138   
     139  void cxios_set_axis_zoom_end(axis_Ptr axis_hdl, int zoom_end) 
     140  { 
     141     CTimer::get("XIOS").resume(); 
     142    axis_hdl->zoom_end.setValue(zoom_end); 
     143    axis_hdl->sendAttributToServer(axis_hdl->zoom_end); 
     144     CTimer::get("XIOS").suspend(); 
     145  } 
     146   
     147  void cxios_get_axis_zoom_end(axis_Ptr axis_hdl, int* zoom_end) 
     148  { 
     149    *zoom_end = axis_hdl->zoom_end.getValue(); 
     150  } 
     151   
     152   
     153  void cxios_set_axis_zoom_size(axis_Ptr axis_hdl, int zoom_size) 
     154  { 
     155     CTimer::get("XIOS").resume(); 
     156    axis_hdl->zoom_size.setValue(zoom_size); 
     157    axis_hdl->sendAttributToServer(axis_hdl->zoom_size); 
     158     CTimer::get("XIOS").suspend(); 
     159  } 
     160   
     161  void cxios_get_axis_zoom_size(axis_Ptr axis_hdl, int* zoom_size) 
     162  { 
     163    *zoom_size = axis_hdl->zoom_size.getValue(); 
    123164  } 
    124165   

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

    r352 r369  
    1111#include "icutil.hpp" 
    1212#include "timer.hpp" 
    13 #include "axis.hpp" 
     13#include "node_type.hpp" 
    1414 
    1515extern "C" 
    … …  
    128128  void cxios_set_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int extent1) 
    129129  { 
    130      CTimer::get("XIOS").resume(); 
    131     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    132     std::copy(value, &(value[array_tmp->num_elements()]), array_tmp->data()); 
    133     axisgroup_hdl->value.setValue(array_tmp); 
     130    CTimer::get("XIOS").resume(); 
     131    CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ; 
     132    axisgroup_hdl->value.reference(tmp.copy()); 
    134133    axisgroup_hdl->sendAttributToServer(axisgroup_hdl->value); 
    135134  } 
    … …  
    137136  void cxios_get_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int extent1) 
    138137  { 
    139     if (!array_copy(axisgroup_hdl->value.getValue(), value, extent1)) 
    140      ERROR("void cxios_set_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     138    CArray<double,1> tmp(value,shape(extent1),neverDeleteData) ; 
     139    tmp=axisgroup_hdl->value ; 
    141140     CTimer::get("XIOS").suspend(); 
     141  } 
     142   
     143   
     144  void cxios_set_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int zoom_begin) 
     145  { 
     146     CTimer::get("XIOS").resume(); 
     147    axisgroup_hdl->zoom_begin.setValue(zoom_begin); 
     148    axisgroup_hdl->sendAttributToServer(axisgroup_hdl->zoom_begin); 
     149     CTimer::get("XIOS").suspend(); 
     150  } 
     151   
     152  void cxios_get_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int* zoom_begin) 
     153  { 
     154    *zoom_begin = axisgroup_hdl->zoom_begin.getValue(); 
     155  } 
     156   
     157   
     158  void cxios_set_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int zoom_end) 
     159  { 
     160     CTimer::get("XIOS").resume(); 
     161    axisgroup_hdl->zoom_end.setValue(zoom_end); 
     162    axisgroup_hdl->sendAttributToServer(axisgroup_hdl->zoom_end); 
     163     CTimer::get("XIOS").suspend(); 
     164  } 
     165   
     166  void cxios_get_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int* zoom_end) 
     167  { 
     168    *zoom_end = axisgroup_hdl->zoom_end.getValue(); 
     169  } 
     170   
     171   
     172  void cxios_set_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int zoom_size) 
     173  { 
     174     CTimer::get("XIOS").resume(); 
     175    axisgroup_hdl->zoom_size.setValue(zoom_size); 
     176    axisgroup_hdl->sendAttributToServer(axisgroup_hdl->zoom_size); 
     177     CTimer::get("XIOS").suspend(); 
     178  } 
     179   
     180  void cxios_get_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int* zoom_size) 
     181  { 
     182    *zoom_size = axisgroup_hdl->zoom_size.getValue(); 
    142183  } 
    143184   

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

    r352 r369  
    1111#include "icutil.hpp" 
    1212#include "timer.hpp" 
    13 #include "context.hpp" 
     13#include "node_type.hpp" 
    1414 
    1515extern "C" 

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

    r352 r369  
    1111#include "icutil.hpp" 
    1212#include "timer.hpp" 
    13 #include "domain.hpp" 
     13#include "node_type.hpp" 
    1414 
    1515extern "C" 
    … …  
    3333  void cxios_set_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1) 
    3434  { 
    35      CTimer::get("XIOS").resume(); 
    36     ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1])); 
    37     std::copy(data_i_index, &(data_i_index[array_tmp->num_elements()]), array_tmp->data()); 
    38     domain_hdl->data_i_index.setValue(array_tmp); 
     35    CTimer::get("XIOS").resume(); 
     36    CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ; 
     37    domain_hdl->data_i_index.reference(tmp.copy()); 
    3938    domain_hdl->sendAttributToServer(domain_hdl->data_i_index); 
    4039  } 
    … …  
    4241  void cxios_get_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1) 
    4342  { 
    44     if (!array_copy(domain_hdl->data_i_index.getValue(), data_i_index, extent1)) 
    45      ERROR("void cxios_set_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     43    CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ; 
     44    tmp=domain_hdl->data_i_index ; 
    4645     CTimer::get("XIOS").suspend(); 
    4746  } 
    … …  
    6463  void cxios_set_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1) 
    6564  { 
    66      CTimer::get("XIOS").resume(); 
    67     ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1])); 
    68     std::copy(data_j_index, &(data_j_index[array_tmp->num_elements()]), array_tmp->data()); 
    69     domain_hdl->data_j_index.setValue(array_tmp); 
     65    CTimer::get("XIOS").resume(); 
     66    CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ; 
     67    domain_hdl->data_j_index.reference(tmp.copy()); 
    7068    domain_hdl->sendAttributToServer(domain_hdl->data_j_index); 
    7169  } 
    … …  
    7371  void cxios_get_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1) 
    7472  { 
    75     if (!array_copy(domain_hdl->data_j_index.getValue(), data_j_index, extent1)) 
    76      ERROR("void cxios_set_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     73    CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ; 
     74    tmp=domain_hdl->data_j_index ; 
    7775     CTimer::get("XIOS").suspend(); 
    7876  } 
    … …  
    212210  void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1) 
    213211  { 
    214      CTimer::get("XIOS").resume(); 
    215     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    216     std::copy(latvalue, &(latvalue[array_tmp->num_elements()]), array_tmp->data()); 
    217     domain_hdl->latvalue.setValue(array_tmp); 
     212    CTimer::get("XIOS").resume(); 
     213    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ; 
     214    domain_hdl->latvalue.reference(tmp.copy()); 
    218215    domain_hdl->sendAttributToServer(domain_hdl->latvalue); 
    219216  } 
    … …  
    221218  void cxios_get_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1) 
    222219  { 
    223     if (!array_copy(domain_hdl->latvalue.getValue(), latvalue, extent1)) 
    224      ERROR("void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     220    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ; 
     221    tmp=domain_hdl->latvalue ; 
    225222     CTimer::get("XIOS").suspend(); 
    226223  } 
    … …  
    248245  void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1) 
    249246  { 
    250      CTimer::get("XIOS").resume(); 
    251     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    252     std::copy(lonvalue, &(lonvalue[array_tmp->num_elements()]), array_tmp->data()); 
    253     domain_hdl->lonvalue.setValue(array_tmp); 
     247    CTimer::get("XIOS").resume(); 
     248    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ; 
     249    domain_hdl->lonvalue.reference(tmp.copy()); 
    254250    domain_hdl->sendAttributToServer(domain_hdl->lonvalue); 
    255251  } 
    … …  
    257253  void cxios_get_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1) 
    258254  { 
    259     if (!array_copy(domain_hdl->lonvalue.getValue(), lonvalue, extent1)) 
    260      ERROR("void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     255    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ; 
     256    tmp=domain_hdl->lonvalue ; 
    261257     CTimer::get("XIOS").suspend(); 
    262258  } 
    … …  
    265261  void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2) 
    266262  { 
    267      CTimer::get("XIOS").resume(); 
    268     ARRAY(bool,2) array_tmp(new CArray<bool,2>(boost::extents[extent1][extent2])); 
    269     std::copy(mask, &(mask[array_tmp->num_elements()]), array_tmp->data()); 
    270     domain_hdl->mask.setValue(array_tmp); 
     263    CTimer::get("XIOS").resume(); 
     264    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ; 
     265    domain_hdl->mask.reference(tmp.copy()); 
    271266    domain_hdl->sendAttributToServer(domain_hdl->mask); 
    272267  } 
    … …  
    274269  void cxios_get_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2) 
    275270  { 
    276     if (!array_copy(domain_hdl->mask.getValue(), mask, extent1, extent2)) 
    277      ERROR("void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2)",<<"Output array size is not conform to array size attribute") ; 
     271    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ; 
     272    tmp=domain_hdl->mask ; 
    278273     CTimer::get("XIOS").suspend(); 
    279274  } 

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

    r352 r369  
    1111#include "icutil.hpp" 
    1212#include "timer.hpp" 
    13 #include "domain.hpp" 
     13#include "node_type.hpp" 
    1414 
    1515extern "C" 
    … …  
    3333  void cxios_set_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1) 
    3434  { 
    35      CTimer::get("XIOS").resume(); 
    36     ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1])); 
    37     std::copy(data_i_index, &(data_i_index[array_tmp->num_elements()]), array_tmp->data()); 
    38     domaingroup_hdl->data_i_index.setValue(array_tmp); 
     35    CTimer::get("XIOS").resume(); 
     36    CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ; 
     37    domaingroup_hdl->data_i_index.reference(tmp.copy()); 
    3938    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_i_index); 
    4039  } 
    … …  
    4241  void cxios_get_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1) 
    4342  { 
    44     if (!array_copy(domaingroup_hdl->data_i_index.getValue(), data_i_index, extent1)) 
    45      ERROR("void cxios_set_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     43    CArray<int,1> tmp(data_i_index,shape(extent1),neverDeleteData) ; 
     44    tmp=domaingroup_hdl->data_i_index ; 
    4645     CTimer::get("XIOS").suspend(); 
    4746  } 
    … …  
    6463  void cxios_set_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1) 
    6564  { 
    66      CTimer::get("XIOS").resume(); 
    67     ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1])); 
    68     std::copy(data_j_index, &(data_j_index[array_tmp->num_elements()]), array_tmp->data()); 
    69     domaingroup_hdl->data_j_index.setValue(array_tmp); 
     65    CTimer::get("XIOS").resume(); 
     66    CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ; 
     67    domaingroup_hdl->data_j_index.reference(tmp.copy()); 
    7068    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_j_index); 
    7169  } 
    … …  
    7371  void cxios_get_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1) 
    7472  { 
    75     if (!array_copy(domaingroup_hdl->data_j_index.getValue(), data_j_index, extent1)) 
    76      ERROR("void cxios_set_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     73    CArray<int,1> tmp(data_j_index,shape(extent1),neverDeleteData) ; 
     74    tmp=domaingroup_hdl->data_j_index ; 
    7775     CTimer::get("XIOS").suspend(); 
    7876  } 
    … …  
    231229  void cxios_set_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1) 
    232230  { 
    233      CTimer::get("XIOS").resume(); 
    234     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    235     std::copy(latvalue, &(latvalue[array_tmp->num_elements()]), array_tmp->data()); 
    236     domaingroup_hdl->latvalue.setValue(array_tmp); 
     231    CTimer::get("XIOS").resume(); 
     232    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ; 
     233    domaingroup_hdl->latvalue.reference(tmp.copy()); 
    237234    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->latvalue); 
    238235  } 
    … …  
    240237  void cxios_get_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1) 
    241238  { 
    242     if (!array_copy(domaingroup_hdl->latvalue.getValue(), latvalue, extent1)) 
    243      ERROR("void cxios_set_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     239    CArray<double,1> tmp(latvalue,shape(extent1),neverDeleteData) ; 
     240    tmp=domaingroup_hdl->latvalue ; 
    244241     CTimer::get("XIOS").suspend(); 
    245242  } 
    … …  
    267264  void cxios_set_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1) 
    268265  { 
    269      CTimer::get("XIOS").resume(); 
    270     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    271     std::copy(lonvalue, &(lonvalue[array_tmp->num_elements()]), array_tmp->data()); 
    272     domaingroup_hdl->lonvalue.setValue(array_tmp); 
     266    CTimer::get("XIOS").resume(); 
     267    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ; 
     268    domaingroup_hdl->lonvalue.reference(tmp.copy()); 
    273269    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->lonvalue); 
    274270  } 
    … …  
    276272  void cxios_get_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1) 
    277273  { 
    278     if (!array_copy(domaingroup_hdl->lonvalue.getValue(), lonvalue, extent1)) 
    279      ERROR("void cxios_set_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     274    CArray<double,1> tmp(lonvalue,shape(extent1),neverDeleteData) ; 
     275    tmp=domaingroup_hdl->lonvalue ; 
    280276     CTimer::get("XIOS").suspend(); 
    281277  } 
    … …  
    284280  void cxios_set_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2) 
    285281  { 
    286      CTimer::get("XIOS").resume(); 
    287     ARRAY(bool,2) array_tmp(new CArray<bool,2>(boost::extents[extent1][extent2])); 
    288     std::copy(mask, &(mask[array_tmp->num_elements()]), array_tmp->data()); 
    289     domaingroup_hdl->mask.setValue(array_tmp); 
     282    CTimer::get("XIOS").resume(); 
     283    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ; 
     284    domaingroup_hdl->mask.reference(tmp.copy()); 
    290285    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->mask); 
    291286  } 
    … …  
    293288  void cxios_get_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2) 
    294289  { 
    295     if (!array_copy(domaingroup_hdl->mask.getValue(), mask, extent1, extent2)) 
    296      ERROR("void cxios_set_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2)",<<"Output array size is not conform to array size attribute") ; 
     290    CArray<bool,2> tmp(mask,shape(extent1,extent2),neverDeleteData) ; 
     291    tmp=domaingroup_hdl->mask ; 
    297292     CTimer::get("XIOS").suspend(); 
    298293  } 

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

    r352 r369  
    1111#include "icutil.hpp" 
    1212#include "timer.hpp" 
    13 #include "field.hpp" 
     13#include "node_type.hpp" 
    1414 
    1515extern "C" 

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

    r352 r369  
    1111#include "icutil.hpp" 
    1212#include "timer.hpp" 
    13 #include "field.hpp" 
     13#include "node_type.hpp" 
    1414 
    1515extern "C" 

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

    r352 r369  
    1111#include "icutil.hpp" 
    1212#include "timer.hpp" 
    13 #include "file.hpp" 
     13#include "node_type.hpp" 
    1414 
    1515extern "C" 
    … …  
    183183    if(!cstr2string(type, type_size, type_str)) return; 
    184184     CTimer::get("XIOS").resume(); 
    185     file_hdl->type.setValue(type_str); 
     185    file_hdl->type.fromString(type_str); 
    186186    file_hdl->sendAttributToServer(file_hdl->type); 
    187187     CTimer::get("XIOS").suspend(); 
    … …  
    191191  { 
    192192     CTimer::get("XIOS").resume(); 
    193     if(!string_copy(file_hdl->type.getValue(),type , type_size)) 
     193    if(!string_copy(file_hdl->type.getStringValue(),type , type_size)) 
    194194      ERROR("void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size)", <<"Input string is to short"); 
    195195     CTimer::get("XIOS").suspend(); 

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

    r352 r369  
    1111#include "icutil.hpp" 
    1212#include "timer.hpp" 
    13 #include "file.hpp" 
     13#include "node_type.hpp" 
    1414 
    1515extern "C" 
    … …  
    202202    if(!cstr2string(type, type_size, type_str)) return; 
    203203     CTimer::get("XIOS").resume(); 
    204     filegroup_hdl->type.setValue(type_str); 
     204    filegroup_hdl->type.fromString(type_str); 
    205205    filegroup_hdl->sendAttributToServer(filegroup_hdl->type); 
    206206     CTimer::get("XIOS").suspend(); 
    … …  
    210210  { 
    211211     CTimer::get("XIOS").resume(); 
    212     if(!string_copy(filegroup_hdl->type.getValue(),type , type_size)) 
     212    if(!string_copy(filegroup_hdl->type.getStringValue(),type , type_size)) 
    213213      ERROR("void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)", <<"Input string is to short"); 
    214214     CTimer::get("XIOS").suspend(); 

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

    r352 r369  
    1111#include "icutil.hpp" 
    1212#include "timer.hpp" 
    13 #include "grid.hpp" 
     13#include "node_type.hpp" 
    1414 
    1515extern "C" 

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

    r352 r369  
    1111#include "icutil.hpp" 
    1212#include "timer.hpp" 
    13 #include "grid.hpp" 
     13#include "node_type.hpp" 
    1414 
    1515extern "C" 
Note: See TracChangeset for help on using the changeset viewer.