Changeset 1545 for XIOS/dev/branch_openmp/src/interface/c_attr

Timestamp:

06/18/18 20:32:55 (6 years ago)

Author:

yushan

Message:

branch_openmp merged with trunk r1544

Location:

XIOS/dev/branch_openmp/src/interface/c_attr

Files:

• icaxis_attr.cpp (modified) (4 diffs)
• icaxisgroup_attr.cpp (modified) (4 diffs)
• iccalendar_wrapper_attr.cpp (modified) (2 diffs)
• iccompute_connectivity_domain_attr.cpp (modified) (1 diff)
• iccontext_attr.cpp (modified) (1 diff)
• icdomain_attr.cpp (modified) (6 diffs)
• icdomaingroup_attr.cpp (modified) (6 diffs)
• icduplicate_scalar_to_axis_attr.cpp (added)
• icexpand_domain_attr.cpp (modified) (1 diff)
• icextract_axis_to_scalar_attr.cpp (modified) (1 diff)
• icextract_domain_to_axis_attr.cpp (modified) (1 diff)
• icfield_attr.cpp (modified) (2 diffs)
• icfieldgroup_attr.cpp (modified) (2 diffs)
• icfile_attr.cpp (modified) (5 diffs)
• icfilegroup_attr.cpp (modified) (5 diffs)
• icgenerate_rectilinear_domain_attr.cpp (modified) (1 diff)
• icgrid_attr.cpp (modified) (3 diffs)
• icgridgroup_attr.cpp (modified) (3 diffs)
• icinterpolate_axis_attr.cpp (modified) (1 diff)
• icinterpolate_domain_attr.cpp (modified) (3 diffs)
• icinverse_axis_attr.cpp (modified) (1 diff)
• icreduce_axis_to_axis_attr.cpp (added)
• icreduce_axis_to_scalar_attr.cpp (modified) (1 diff)
• icreduce_domain_to_axis_attr.cpp (modified) (2 diffs)
• icreduce_domain_to_scalar_attr.cpp (modified) (2 diffs)
• icreduce_scalar_to_scalar_attr.cpp (added)
• icreorder_domain_attr.cpp (added)
• icscalar_attr.cpp (modified) (3 diffs)
• icscalargroup_attr.cpp (modified) (4 diffs)
• ictemporal_splitting_attr.cpp (added)
• icvariable_attr.cpp (modified) (1 diff)
• icvariablegroup_attr.cpp (modified) (1 diff)
• iczoom_axis_attr.cpp (modified) (1 diff)
• iczoom_domain_attr.cpp (modified) (1 diff)

XIOS/dev/branch_openmp/src/interface/c_attr/icaxis_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -44 +44 @@
 
 
+  void cxios_set_axis_axis_type(axis_Ptr axis_hdl, const char * axis_type, int axis_type_size)
+  {
+    std::string axis_type_str;
+    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return;
+    CTimer::get("XIOS").resume();
+    axis_hdl->axis_type.fromString(axis_type_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_axis_type(axis_Ptr axis_hdl, char * axis_type, int axis_type_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axis_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size))
+      ERROR("void cxios_get_axis_axis_type(axis_Ptr axis_hdl, char * axis_type, int axis_type_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_axis_type(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->axis_type.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_axis_begin(axis_Ptr axis_hdl, int begin)
   {
@@ -92 +118 @@
 
 
+  void cxios_set_axis_bounds_name(axis_Ptr axis_hdl, const char * bounds_name, int bounds_name_size)
+  {
+    std::string bounds_name_str;
+    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return;
+    CTimer::get("XIOS").resume();
+    axis_hdl->bounds_name.setValue(bounds_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_bounds_name(axis_Ptr axis_hdl, char * bounds_name, int bounds_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axis_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size))
+      ERROR("void cxios_get_axis_bounds_name(axis_Ptr axis_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_bounds_name(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->bounds_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axis_comment(axis_Ptr axis_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    axis_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_comment(axis_Ptr axis_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axis_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_axis_comment(axis_Ptr axis_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_comment(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->comment.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_axis_data_begin(axis_Ptr axis_hdl, int data_begin)
   {
@@ -158 +236 @@
      CTimer::get("XIOS").resume();
      bool isDefined = axis_hdl->data_n.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axis_dim_name(axis_Ptr axis_hdl, const char * dim_name, int dim_name_size)
+  {
+    std::string dim_name_str;
+    if (!cstr2string(dim_name, dim_name_size, dim_name_str)) return;
+    CTimer::get("XIOS").resume();
+    axis_hdl->dim_name.setValue(dim_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_dim_name(axis_Ptr axis_hdl, char * dim_name, int dim_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axis_hdl->dim_name.getInheritedValue(), dim_name, dim_name_size))
+      ERROR("void cxios_get_axis_dim_name(axis_Ptr axis_hdl, char * dim_name, int dim_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_dim_name(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->dim_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axis_formula(axis_Ptr axis_hdl, const char * formula, int formula_size)
+  {
+    std::string formula_str;
+    if (!cstr2string(formula, formula_size, formula_str)) return;
+    CTimer::get("XIOS").resume();
+    axis_hdl->formula.setValue(formula_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_formula(axis_Ptr axis_hdl, char * formula, int formula_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axis_hdl->formula.getInheritedValue(), formula, formula_size))
+      ERROR("void cxios_get_axis_formula(axis_Ptr axis_hdl, char * formula, int formula_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_formula(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->formula.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axis_formula_bounds(axis_Ptr axis_hdl, const char * formula_bounds, int formula_bounds_size)
+  {
+    std::string formula_bounds_str;
+    if (!cstr2string(formula_bounds, formula_bounds_size, formula_bounds_str)) return;
+    CTimer::get("XIOS").resume();
+    axis_hdl->formula_bounds.setValue(formula_bounds_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_formula_bounds(axis_Ptr axis_hdl, char * formula_bounds, int formula_bounds_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axis_hdl->formula_bounds.getInheritedValue(), formula_bounds, formula_bounds_size))
+      ERROR("void cxios_get_axis_formula_bounds(axis_Ptr axis_hdl, char * formula_bounds, int formula_bounds_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_formula_bounds(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->formula_bounds.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axis_formula_term(axis_Ptr axis_hdl, const char * formula_term, int formula_term_size)
+  {
+    std::string formula_term_str;
+    if (!cstr2string(formula_term, formula_term_size, formula_term_str)) return;
+    CTimer::get("XIOS").resume();
+    axis_hdl->formula_term.setValue(formula_term_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_formula_term(axis_Ptr axis_hdl, char * formula_term, int formula_term_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axis_hdl->formula_term.getInheritedValue(), formula_term, formula_term_size))
+      ERROR("void cxios_get_axis_formula_term(axis_Ptr axis_hdl, char * formula_term, int formula_term_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_formula_term(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->formula_term.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axis_formula_term_bounds(axis_Ptr axis_hdl, const char * formula_term_bounds, int formula_term_bounds_size)
+  {
+    std::string formula_term_bounds_str;
+    if (!cstr2string(formula_term_bounds, formula_term_bounds_size, formula_term_bounds_str)) return;
+    CTimer::get("XIOS").resume();
+    axis_hdl->formula_term_bounds.setValue(formula_term_bounds_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_formula_term_bounds(axis_Ptr axis_hdl, char * formula_term_bounds, int formula_term_bounds_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axis_hdl->formula_term_bounds.getInheritedValue(), formula_term_bounds, formula_term_bounds_size))
+      ERROR("void cxios_get_axis_formula_term_bounds(axis_Ptr axis_hdl, char * formula_term_bounds, int formula_term_bounds_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_formula_term_bounds(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->formula_term_bounds.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;

XIOS/dev/branch_openmp/src/interface/c_attr/icaxisgroup_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -44 +44 @@
 
 
+  void cxios_set_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl, const char * axis_type, int axis_type_size)
+  {
+    std::string axis_type_str;
+    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return;
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->axis_type.fromString(axis_type_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl, char * axis_type, int axis_type_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axisgroup_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size))
+      ERROR("void cxios_get_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl, char * axis_type, int axis_type_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->axis_type.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_axisgroup_begin(axisgroup_Ptr axisgroup_hdl, int begin)
   {
@@ -92 +118 @@
 
 
+  void cxios_set_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl, const char * bounds_name, int bounds_name_size)
+  {
+    std::string bounds_name_str;
+    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return;
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->bounds_name.setValue(bounds_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl, char * bounds_name, int bounds_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axisgroup_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size))
+      ERROR("void cxios_get_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->bounds_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axisgroup_comment(axisgroup_Ptr axisgroup_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_comment(axisgroup_Ptr axisgroup_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axisgroup_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_axisgroup_comment(axisgroup_Ptr axisgroup_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_comment(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->comment.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl, int data_begin)
   {
@@ -158 +236 @@
      CTimer::get("XIOS").resume();
      bool isDefined = axisgroup_hdl->data_n.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl, const char * dim_name, int dim_name_size)
+  {
+    std::string dim_name_str;
+    if (!cstr2string(dim_name, dim_name_size, dim_name_str)) return;
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->dim_name.setValue(dim_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl, char * dim_name, int dim_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axisgroup_hdl->dim_name.getInheritedValue(), dim_name, dim_name_size))
+      ERROR("void cxios_get_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl, char * dim_name, int dim_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->dim_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axisgroup_formula(axisgroup_Ptr axisgroup_hdl, const char * formula, int formula_size)
+  {
+    std::string formula_str;
+    if (!cstr2string(formula, formula_size, formula_str)) return;
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->formula.setValue(formula_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_formula(axisgroup_Ptr axisgroup_hdl, char * formula, int formula_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axisgroup_hdl->formula.getInheritedValue(), formula, formula_size))
+      ERROR("void cxios_get_axisgroup_formula(axisgroup_Ptr axisgroup_hdl, char * formula, int formula_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_formula(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->formula.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl, const char * formula_bounds, int formula_bounds_size)
+  {
+    std::string formula_bounds_str;
+    if (!cstr2string(formula_bounds, formula_bounds_size, formula_bounds_str)) return;
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->formula_bounds.setValue(formula_bounds_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_bounds, int formula_bounds_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axisgroup_hdl->formula_bounds.getInheritedValue(), formula_bounds, formula_bounds_size))
+      ERROR("void cxios_get_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_bounds, int formula_bounds_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->formula_bounds.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl, const char * formula_term, int formula_term_size)
+  {
+    std::string formula_term_str;
+    if (!cstr2string(formula_term, formula_term_size, formula_term_str)) return;
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->formula_term.setValue(formula_term_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl, char * formula_term, int formula_term_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axisgroup_hdl->formula_term.getInheritedValue(), formula_term, formula_term_size))
+      ERROR("void cxios_get_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl, char * formula_term, int formula_term_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->formula_term.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl, const char * formula_term_bounds, int formula_term_bounds_size)
+  {
+    std::string formula_term_bounds_str;
+    if (!cstr2string(formula_term_bounds, formula_term_bounds_size, formula_term_bounds_str)) return;
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->formula_term_bounds.setValue(formula_term_bounds_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_term_bounds, int formula_term_bounds_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(axisgroup_hdl->formula_term_bounds.getInheritedValue(), formula_term_bounds, formula_term_bounds_size))
+      ERROR("void cxios_get_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_term_bounds, int formula_term_bounds_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->formula_term_bounds.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;

XIOS/dev/branch_openmp/src/interface/c_attr/iccalendar_wrapper_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -17 +17 @@
 {
   typedef xios::CCalendarWrapper* calendar_wrapper_Ptr;
+
+  void cxios_set_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    calendar_wrapper_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(calendar_wrapper_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = calendar_wrapper_hdl->comment.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
 
   void cxios_set_calendar_wrapper_day_length(calendar_wrapper_Ptr calendar_wrapper_hdl, int day_length)

XIOS/dev/branch_openmp/src/interface/c_attr/iccompute_connectivity_domain_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/iccontext_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/icdomain_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -93 +93 @@
 
 
+  void cxios_set_domain_bounds_lat_name(domain_Ptr domain_hdl, const char * bounds_lat_name, int bounds_lat_name_size)
+  {
+    std::string bounds_lat_name_str;
+    if (!cstr2string(bounds_lat_name, bounds_lat_name_size, bounds_lat_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domain_hdl->bounds_lat_name.setValue(bounds_lat_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_bounds_lat_name(domain_Ptr domain_hdl, char * bounds_lat_name, int bounds_lat_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domain_hdl->bounds_lat_name.getInheritedValue(), bounds_lat_name, bounds_lat_name_size))
+      ERROR("void cxios_get_domain_bounds_lat_name(domain_Ptr domain_hdl, char * bounds_lat_name, int bounds_lat_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_bounds_lat_name(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->bounds_lat_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domain_bounds_lon_1d(domain_Ptr domain_hdl, double* bounds_lon_1d, int* extent)
   {
@@ -143 +169 @@
 
 
+  void cxios_set_domain_bounds_lon_name(domain_Ptr domain_hdl, const char * bounds_lon_name, int bounds_lon_name_size)
+  {
+    std::string bounds_lon_name_str;
+    if (!cstr2string(bounds_lon_name, bounds_lon_name_size, bounds_lon_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domain_hdl->bounds_lon_name.setValue(bounds_lon_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_bounds_lon_name(domain_Ptr domain_hdl, char * bounds_lon_name, int bounds_lon_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domain_hdl->bounds_lon_name.getInheritedValue(), bounds_lon_name, bounds_lon_name_size))
+      ERROR("void cxios_get_domain_bounds_lon_name(domain_Ptr domain_hdl, char * bounds_lon_name, int bounds_lon_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_bounds_lon_name(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->bounds_lon_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_comment(domain_Ptr domain_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    domain_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_comment(domain_Ptr domain_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domain_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_domain_comment(domain_Ptr domain_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_comment(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->comment.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domain_data_dim(domain_Ptr domain_hdl, int data_dim)
   {
@@ -308 +386 @@
 
 
+  void cxios_set_domain_dim_i_name(domain_Ptr domain_hdl, const char * dim_i_name, int dim_i_name_size)
+  {
+    std::string dim_i_name_str;
+    if (!cstr2string(dim_i_name, dim_i_name_size, dim_i_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domain_hdl->dim_i_name.setValue(dim_i_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_dim_i_name(domain_Ptr domain_hdl, char * dim_i_name, int dim_i_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domain_hdl->dim_i_name.getInheritedValue(), dim_i_name, dim_i_name_size))
+      ERROR("void cxios_get_domain_dim_i_name(domain_Ptr domain_hdl, char * dim_i_name, int dim_i_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_dim_i_name(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->dim_i_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_dim_j_name(domain_Ptr domain_hdl, const char * dim_j_name, int dim_j_name_size)
+  {
+    std::string dim_j_name_str;
+    if (!cstr2string(dim_j_name, dim_j_name_size, dim_j_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domain_hdl->dim_j_name.setValue(dim_j_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_dim_j_name(domain_Ptr domain_hdl, char * dim_j_name, int dim_j_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domain_hdl->dim_j_name.getInheritedValue(), dim_j_name, dim_j_name_size))
+      ERROR("void cxios_get_domain_dim_j_name(domain_Ptr domain_hdl, char * dim_j_name, int dim_j_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_dim_j_name(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->dim_j_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domain_domain_ref(domain_Ptr domain_hdl, const char * domain_ref, int domain_ref_size)
   {
@@ -430 +560 @@
 
 
+  void cxios_set_domain_lat_name(domain_Ptr domain_hdl, const char * lat_name, int lat_name_size)
+  {
+    std::string lat_name_str;
+    if (!cstr2string(lat_name, lat_name_size, lat_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domain_hdl->lat_name.setValue(lat_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_lat_name(domain_Ptr domain_hdl, char * lat_name, int lat_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domain_hdl->lat_name.getInheritedValue(), lat_name, lat_name_size))
+      ERROR("void cxios_get_domain_lat_name(domain_Ptr domain_hdl, char * lat_name, int lat_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_lat_name(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->lat_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int* extent)
   {
@@ -480 +636 @@
 
 
+  void cxios_set_domain_lon_name(domain_Ptr domain_hdl, const char * lon_name, int lon_name_size)
+  {
+    std::string lon_name_str;
+    if (!cstr2string(lon_name, lon_name_size, lon_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domain_hdl->lon_name.setValue(lon_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_lon_name(domain_Ptr domain_hdl, char * lon_name, int lon_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domain_hdl->lon_name.getInheritedValue(), lon_name, lon_name_size))
+      ERROR("void cxios_get_domain_lon_name(domain_Ptr domain_hdl, char * lon_name, int lon_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_lon_name(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->lon_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domain_long_name(domain_Ptr domain_hdl, const char * long_name, int long_name_size)
   {

XIOS/dev/branch_openmp/src/interface/c_attr/icdomaingroup_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -93 +93 @@
 
 
+  void cxios_set_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl, const char * bounds_lat_name, int bounds_lat_name_size)
+  {
+    std::string bounds_lat_name_str;
+    if (!cstr2string(bounds_lat_name, bounds_lat_name_size, bounds_lat_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domaingroup_hdl->bounds_lat_name.setValue(bounds_lat_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lat_name, int bounds_lat_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domaingroup_hdl->bounds_lat_name.getInheritedValue(), bounds_lat_name, bounds_lat_name_size))
+      ERROR("void cxios_get_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lat_name, int bounds_lat_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->bounds_lat_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domaingroup_bounds_lon_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lon_1d, int* extent)
   {
@@ -143 +169 @@
 
 
+  void cxios_set_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl, const char * bounds_lon_name, int bounds_lon_name_size)
+  {
+    std::string bounds_lon_name_str;
+    if (!cstr2string(bounds_lon_name, bounds_lon_name_size, bounds_lon_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domaingroup_hdl->bounds_lon_name.setValue(bounds_lon_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lon_name, int bounds_lon_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domaingroup_hdl->bounds_lon_name.getInheritedValue(), bounds_lon_name, bounds_lon_name_size))
+      ERROR("void cxios_get_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lon_name, int bounds_lon_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->bounds_lon_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_comment(domaingroup_Ptr domaingroup_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    domaingroup_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_comment(domaingroup_Ptr domaingroup_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domaingroup_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_domaingroup_comment(domaingroup_Ptr domaingroup_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_comment(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->comment.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int data_dim)
   {
@@ -308 +386 @@
 
 
+  void cxios_set_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl, const char * dim_i_name, int dim_i_name_size)
+  {
+    std::string dim_i_name_str;
+    if (!cstr2string(dim_i_name, dim_i_name_size, dim_i_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domaingroup_hdl->dim_i_name.setValue(dim_i_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl, char * dim_i_name, int dim_i_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domaingroup_hdl->dim_i_name.getInheritedValue(), dim_i_name, dim_i_name_size))
+      ERROR("void cxios_get_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl, char * dim_i_name, int dim_i_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->dim_i_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl, const char * dim_j_name, int dim_j_name_size)
+  {
+    std::string dim_j_name_str;
+    if (!cstr2string(dim_j_name, dim_j_name_size, dim_j_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domaingroup_hdl->dim_j_name.setValue(dim_j_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl, char * dim_j_name, int dim_j_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domaingroup_hdl->dim_j_name.getInheritedValue(), dim_j_name, dim_j_name_size))
+      ERROR("void cxios_get_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl, char * dim_j_name, int dim_j_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->dim_j_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domaingroup_domain_ref(domaingroup_Ptr domaingroup_hdl, const char * domain_ref, int domain_ref_size)
   {
@@ -456 +586 @@
 
 
+  void cxios_set_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl, const char * lat_name, int lat_name_size)
+  {
+    std::string lat_name_str;
+    if (!cstr2string(lat_name, lat_name_size, lat_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domaingroup_hdl->lat_name.setValue(lat_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl, char * lat_name, int lat_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domaingroup_hdl->lat_name.getInheritedValue(), lat_name, lat_name_size))
+      ERROR("void cxios_get_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl, char * lat_name, int lat_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->lat_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domaingroup_latvalue_1d(domaingroup_Ptr domaingroup_hdl, double* latvalue_1d, int* extent)
   {
@@ -506 +662 @@
 
 
+  void cxios_set_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl, const char * lon_name, int lon_name_size)
+  {
+    std::string lon_name_str;
+    if (!cstr2string(lon_name, lon_name_size, lon_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domaingroup_hdl->lon_name.setValue(lon_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl, char * lon_name, int lon_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domaingroup_hdl->lon_name.getInheritedValue(), lon_name, lon_name_size))
+      ERROR("void cxios_get_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl, char * lon_name, int lon_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->lon_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, const char * long_name, int long_name_size)
   {

XIOS/dev/branch_openmp/src/interface/c_attr/icexpand_domain_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/icextract_axis_to_scalar_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/icextract_domain_to_axis_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/icfield_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -137 +137 @@
      CTimer::get("XIOS").resume();
      bool isDefined = field_hdl->check_if_active.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_field_comment(field_Ptr field_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    field_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_field_comment(field_Ptr field_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(field_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_field_comment(field_Ptr field_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_field_comment(field_Ptr field_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = field_hdl->comment.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;

XIOS/dev/branch_openmp/src/interface/c_attr/icfieldgroup_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -137 +137 @@
      CTimer::get("XIOS").resume();
      bool isDefined = fieldgroup_hdl->check_if_active.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    fieldgroup_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(fieldgroup_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = fieldgroup_hdl->comment.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;

XIOS/dev/branch_openmp/src/interface/c_attr/icfile_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -36 +36 @@
      CTimer::get("XIOS").resume();
      bool isDefined = file_hdl->append.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_file_comment(file_Ptr file_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    file_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_comment(file_Ptr file_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(file_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_file_comment(file_Ptr file_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_comment(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->comment.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
@@ -402 +428 @@
 
 
+  void cxios_set_file_read_metadata_par(file_Ptr file_hdl, bool read_metadata_par)
+  {
+    CTimer::get("XIOS").resume();
+    file_hdl->read_metadata_par.setValue(read_metadata_par);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_read_metadata_par(file_Ptr file_hdl, bool* read_metadata_par)
+  {
+    CTimer::get("XIOS").resume();
+    *read_metadata_par = file_hdl->read_metadata_par.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_read_metadata_par(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->read_metadata_par.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_file_record_offset(file_Ptr file_hdl, int record_offset)
   {
@@ -420 +469 @@
      CTimer::get("XIOS").resume();
      bool isDefined = file_hdl->record_offset.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_file_split_end_offset(file_Ptr file_hdl, cxios_duration split_end_offset_c)
+  {
+    CTimer::get("XIOS").resume();
+    file_hdl->split_end_offset.allocate();
+    CDuration& split_end_offset = file_hdl->split_end_offset.get();
+    split_end_offset.year = split_end_offset_c.year;
+    split_end_offset.month = split_end_offset_c.month;
+    split_end_offset.day = split_end_offset_c.day;
+    split_end_offset.hour = split_end_offset_c.hour;
+    split_end_offset.minute = split_end_offset_c.minute;
+    split_end_offset.second = split_end_offset_c.second;
+    split_end_offset.timestep = split_end_offset_c.timestep;
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_split_end_offset(file_Ptr file_hdl, cxios_duration* split_end_offset_c)
+  {
+    CTimer::get("XIOS").resume();
+    CDuration split_end_offset = file_hdl->split_end_offset.getInheritedValue();
+    split_end_offset_c->year = split_end_offset.year;
+    split_end_offset_c->month = split_end_offset.month;
+    split_end_offset_c->day = split_end_offset.day;
+    split_end_offset_c->hour = split_end_offset.hour;
+    split_end_offset_c->minute = split_end_offset.minute;
+    split_end_offset_c->second = split_end_offset.second;
+    split_end_offset_c->timestep = split_end_offset.timestep;
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_split_end_offset(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->split_end_offset.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
@@ -489 +576 @@
 
 
+  void cxios_set_file_split_last_date(file_Ptr file_hdl, const char * split_last_date, int split_last_date_size)
+  {
+    std::string split_last_date_str;
+    if (!cstr2string(split_last_date, split_last_date_size, split_last_date_str)) return;
+    CTimer::get("XIOS").resume();
+    file_hdl->split_last_date.setValue(split_last_date_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_split_last_date(file_Ptr file_hdl, char * split_last_date, int split_last_date_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(file_hdl->split_last_date.getInheritedValue(), split_last_date, split_last_date_size))
+      ERROR("void cxios_get_file_split_last_date(file_Ptr file_hdl, char * split_last_date, int split_last_date_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_split_last_date(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->split_last_date.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_file_split_start_offset(file_Ptr file_hdl, cxios_duration split_start_offset_c)
+  {
+    CTimer::get("XIOS").resume();
+    file_hdl->split_start_offset.allocate();
+    CDuration& split_start_offset = file_hdl->split_start_offset.get();
+    split_start_offset.year = split_start_offset_c.year;
+    split_start_offset.month = split_start_offset_c.month;
+    split_start_offset.day = split_start_offset_c.day;
+    split_start_offset.hour = split_start_offset_c.hour;
+    split_start_offset.minute = split_start_offset_c.minute;
+    split_start_offset.second = split_start_offset_c.second;
+    split_start_offset.timestep = split_start_offset_c.timestep;
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_split_start_offset(file_Ptr file_hdl, cxios_duration* split_start_offset_c)
+  {
+    CTimer::get("XIOS").resume();
+    CDuration split_start_offset = file_hdl->split_start_offset.getInheritedValue();
+    split_start_offset_c->year = split_start_offset.year;
+    split_start_offset_c->month = split_start_offset.month;
+    split_start_offset_c->day = split_start_offset.day;
+    split_start_offset_c->hour = split_start_offset.hour;
+    split_start_offset_c->minute = split_start_offset.minute;
+    split_start_offset_c->second = split_start_offset.second;
+    split_start_offset_c->timestep = split_start_offset.timestep;
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_split_start_offset(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->split_start_offset.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_file_sync_freq(file_Ptr file_hdl, cxios_duration sync_freq_c)
   {

XIOS/dev/branch_openmp/src/interface/c_attr/icfilegroup_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -36 +36 @@
      CTimer::get("XIOS").resume();
      bool isDefined = filegroup_hdl->append.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_filegroup_comment(filegroup_Ptr filegroup_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_comment(filegroup_Ptr filegroup_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(filegroup_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_filegroup_comment(filegroup_Ptr filegroup_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_comment(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->comment.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
@@ -428 +454 @@
 
 
+  void cxios_set_filegroup_read_metadata_par(filegroup_Ptr filegroup_hdl, bool read_metadata_par)
+  {
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->read_metadata_par.setValue(read_metadata_par);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_read_metadata_par(filegroup_Ptr filegroup_hdl, bool* read_metadata_par)
+  {
+    CTimer::get("XIOS").resume();
+    *read_metadata_par = filegroup_hdl->read_metadata_par.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_read_metadata_par(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->read_metadata_par.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_filegroup_record_offset(filegroup_Ptr filegroup_hdl, int record_offset)
   {
@@ -446 +495 @@
      CTimer::get("XIOS").resume();
      bool isDefined = filegroup_hdl->record_offset.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_filegroup_split_end_offset(filegroup_Ptr filegroup_hdl, cxios_duration split_end_offset_c)
+  {
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->split_end_offset.allocate();
+    CDuration& split_end_offset = filegroup_hdl->split_end_offset.get();
+    split_end_offset.year = split_end_offset_c.year;
+    split_end_offset.month = split_end_offset_c.month;
+    split_end_offset.day = split_end_offset_c.day;
+    split_end_offset.hour = split_end_offset_c.hour;
+    split_end_offset.minute = split_end_offset_c.minute;
+    split_end_offset.second = split_end_offset_c.second;
+    split_end_offset.timestep = split_end_offset_c.timestep;
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_split_end_offset(filegroup_Ptr filegroup_hdl, cxios_duration* split_end_offset_c)
+  {
+    CTimer::get("XIOS").resume();
+    CDuration split_end_offset = filegroup_hdl->split_end_offset.getInheritedValue();
+    split_end_offset_c->year = split_end_offset.year;
+    split_end_offset_c->month = split_end_offset.month;
+    split_end_offset_c->day = split_end_offset.day;
+    split_end_offset_c->hour = split_end_offset.hour;
+    split_end_offset_c->minute = split_end_offset.minute;
+    split_end_offset_c->second = split_end_offset.second;
+    split_end_offset_c->timestep = split_end_offset.timestep;
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_split_end_offset(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->split_end_offset.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
@@ -515 +602 @@
 
 
+  void cxios_set_filegroup_split_last_date(filegroup_Ptr filegroup_hdl, const char * split_last_date, int split_last_date_size)
+  {
+    std::string split_last_date_str;
+    if (!cstr2string(split_last_date, split_last_date_size, split_last_date_str)) return;
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->split_last_date.setValue(split_last_date_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_split_last_date(filegroup_Ptr filegroup_hdl, char * split_last_date, int split_last_date_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(filegroup_hdl->split_last_date.getInheritedValue(), split_last_date, split_last_date_size))
+      ERROR("void cxios_get_filegroup_split_last_date(filegroup_Ptr filegroup_hdl, char * split_last_date, int split_last_date_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_split_last_date(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->split_last_date.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_filegroup_split_start_offset(filegroup_Ptr filegroup_hdl, cxios_duration split_start_offset_c)
+  {
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->split_start_offset.allocate();
+    CDuration& split_start_offset = filegroup_hdl->split_start_offset.get();
+    split_start_offset.year = split_start_offset_c.year;
+    split_start_offset.month = split_start_offset_c.month;
+    split_start_offset.day = split_start_offset_c.day;
+    split_start_offset.hour = split_start_offset_c.hour;
+    split_start_offset.minute = split_start_offset_c.minute;
+    split_start_offset.second = split_start_offset_c.second;
+    split_start_offset.timestep = split_start_offset_c.timestep;
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_split_start_offset(filegroup_Ptr filegroup_hdl, cxios_duration* split_start_offset_c)
+  {
+    CTimer::get("XIOS").resume();
+    CDuration split_start_offset = filegroup_hdl->split_start_offset.getInheritedValue();
+    split_start_offset_c->year = split_start_offset.year;
+    split_start_offset_c->month = split_start_offset.month;
+    split_start_offset_c->day = split_start_offset.day;
+    split_start_offset_c->hour = split_start_offset.hour;
+    split_start_offset_c->minute = split_start_offset.minute;
+    split_start_offset_c->second = split_start_offset.second;
+    split_start_offset_c->timestep = split_start_offset.timestep;
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_split_start_offset(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->split_start_offset.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, cxios_duration sync_freq_c)
   {

XIOS/dev/branch_openmp/src/interface/c_attr/icgenerate_rectilinear_domain_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/icgrid_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -18 +18 @@
   typedef xios::CGrid* grid_Ptr;
 
+  void cxios_set_grid_comment(grid_Ptr grid_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    grid_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_grid_comment(grid_Ptr grid_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(grid_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_grid_comment(grid_Ptr grid_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_grid_comment(grid_Ptr grid_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = grid_hdl->comment.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_grid_description(grid_Ptr grid_hdl, const char * description, int description_size)
   {
@@ -44 +70 @@
 
 
+  void cxios_set_grid_mask_0d(grid_Ptr grid_hdl, bool* mask_0d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData);
+    grid_hdl->mask_0d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_grid_mask_0d(grid_Ptr grid_hdl, bool* mask_0d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData);
+    tmp=grid_hdl->mask_0d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_grid_mask_0d(grid_Ptr grid_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = grid_hdl->mask_0d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_grid_mask_1d(grid_Ptr grid_hdl, bool* mask_1d, int* extent)
   {

XIOS/dev/branch_openmp/src/interface/c_attr/icgridgroup_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -18 +18 @@
   typedef xios::CGridGroup* gridgroup_Ptr;
 
+  void cxios_set_gridgroup_comment(gridgroup_Ptr gridgroup_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    gridgroup_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_gridgroup_comment(gridgroup_Ptr gridgroup_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(gridgroup_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_gridgroup_comment(gridgroup_Ptr gridgroup_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_gridgroup_comment(gridgroup_Ptr gridgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = gridgroup_hdl->comment.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_gridgroup_description(gridgroup_Ptr gridgroup_hdl, const char * description, int description_size)
   {
@@ -70 +96 @@
 
 
+  void cxios_set_gridgroup_mask_0d(gridgroup_Ptr gridgroup_hdl, bool* mask_0d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData);
+    gridgroup_hdl->mask_0d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_gridgroup_mask_0d(gridgroup_Ptr gridgroup_hdl, bool* mask_0d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData);
+    tmp=gridgroup_hdl->mask_0d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_gridgroup_mask_0d(gridgroup_Ptr gridgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = gridgroup_hdl->mask_0d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_gridgroup_mask_1d(gridgroup_Ptr gridgroup_hdl, bool* mask_1d, int* extent)
   {

XIOS/dev/branch_openmp/src/interface/c_attr/icinterpolate_axis_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/icinterpolate_domain_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -18 +18 @@
   typedef xios::CInterpolateDomain* interpolate_domain_Ptr;
 
+  void cxios_set_interpolate_domain_detect_missing_value(interpolate_domain_Ptr interpolate_domain_hdl, bool detect_missing_value)
+  {
+    CTimer::get("XIOS").resume();
+    interpolate_domain_hdl->detect_missing_value.setValue(detect_missing_value);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_interpolate_domain_detect_missing_value(interpolate_domain_Ptr interpolate_domain_hdl, bool* detect_missing_value)
+  {
+    CTimer::get("XIOS").resume();
+    *detect_missing_value = interpolate_domain_hdl->detect_missing_value.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_interpolate_domain_detect_missing_value(interpolate_domain_Ptr interpolate_domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = interpolate_domain_hdl->detect_missing_value.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_interpolate_domain_mode(interpolate_domain_Ptr interpolate_domain_hdl, const char * mode, int mode_size)
   {
@@ -90 +113 @@
 
 
+  void cxios_set_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl, const char * read_write_convention, int read_write_convention_size)
+  {
+    std::string read_write_convention_str;
+    if (!cstr2string(read_write_convention, read_write_convention_size, read_write_convention_str)) return;
+    CTimer::get("XIOS").resume();
+    interpolate_domain_hdl->read_write_convention.fromString(read_write_convention_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl, char * read_write_convention, int read_write_convention_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(interpolate_domain_hdl->read_write_convention.getInheritedStringValue(), read_write_convention, read_write_convention_size))
+      ERROR("void cxios_get_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl, char * read_write_convention, int read_write_convention_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = interpolate_domain_hdl->read_write_convention.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_interpolate_domain_renormalize(interpolate_domain_Ptr interpolate_domain_hdl, bool renormalize)
   {

XIOS/dev/branch_openmp/src/interface/c_attr/icinverse_axis_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/icreduce_axis_to_scalar_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/icreduce_domain_to_axis_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -44 +44 @@
 
 
+  void cxios_set_reduce_domain_to_axis_local(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl, bool local)
+  {
+    CTimer::get("XIOS").resume();
+    reduce_domain_to_axis_hdl->local.setValue(local);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_reduce_domain_to_axis_local(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl, bool* local)
+  {
+    CTimer::get("XIOS").resume();
+    *local = reduce_domain_to_axis_hdl->local.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_reduce_domain_to_axis_local(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = reduce_domain_to_axis_hdl->local.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_reduce_domain_to_axis_operation(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl, const char * operation, int operation_size)
   {

XIOS/dev/branch_openmp/src/interface/c_attr/icreduce_domain_to_scalar_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -17 +17 @@
 {
   typedef xios::CReduceDomainToScalar* reduce_domain_to_scalar_Ptr;
+
+  void cxios_set_reduce_domain_to_scalar_local(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl, bool local)
+  {
+    CTimer::get("XIOS").resume();
+    reduce_domain_to_scalar_hdl->local.setValue(local);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_reduce_domain_to_scalar_local(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl, bool* local)
+  {
+    CTimer::get("XIOS").resume();
+    *local = reduce_domain_to_scalar_hdl->local.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_reduce_domain_to_scalar_local(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = reduce_domain_to_scalar_hdl->local.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
 
   void cxios_set_reduce_domain_to_scalar_operation(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl, const char * operation, int operation_size)

XIOS/dev/branch_openmp/src/interface/c_attr/icscalar_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -18 +18 @@
   typedef xios::CScalar* scalar_Ptr;
 
+  void cxios_set_scalar_axis_type(scalar_Ptr scalar_hdl, const char * axis_type, int axis_type_size)
+  {
+    std::string axis_type_str;
+    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return;
+    CTimer::get("XIOS").resume();
+    scalar_hdl->axis_type.fromString(axis_type_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_axis_type(scalar_Ptr scalar_hdl, char * axis_type, int axis_type_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalar_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size))
+      ERROR("void cxios_get_scalar_axis_type(scalar_Ptr scalar_hdl, char * axis_type, int axis_type_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_axis_type(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->axis_type.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalar_bounds(scalar_Ptr scalar_hdl, double* bounds, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData);
+    scalar_hdl->bounds.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_bounds(scalar_Ptr scalar_hdl, double* bounds, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData);
+    tmp=scalar_hdl->bounds.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_bounds(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->bounds.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalar_bounds_name(scalar_Ptr scalar_hdl, const char * bounds_name, int bounds_name_size)
+  {
+    std::string bounds_name_str;
+    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return;
+    CTimer::get("XIOS").resume();
+    scalar_hdl->bounds_name.setValue(bounds_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_bounds_name(scalar_Ptr scalar_hdl, char * bounds_name, int bounds_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalar_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size))
+      ERROR("void cxios_get_scalar_bounds_name(scalar_Ptr scalar_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_bounds_name(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->bounds_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalar_comment(scalar_Ptr scalar_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    scalar_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_comment(scalar_Ptr scalar_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalar_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_scalar_comment(scalar_Ptr scalar_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_comment(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->comment.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalar_label(scalar_Ptr scalar_hdl, const char * label, int label_size)
+  {
+    std::string label_str;
+    if (!cstr2string(label, label_size, label_str)) return;
+    CTimer::get("XIOS").resume();
+    scalar_hdl->label.setValue(label_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_label(scalar_Ptr scalar_hdl, char * label, int label_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalar_hdl->label.getInheritedValue(), label, label_size))
+      ERROR("void cxios_get_scalar_label(scalar_Ptr scalar_hdl, char * label, int label_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_label(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->label.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_scalar_long_name(scalar_Ptr scalar_hdl, const char * long_name, int long_name_size)
   {
@@ -70 +199 @@
 
 
+  void cxios_set_scalar_positive(scalar_Ptr scalar_hdl, const char * positive, int positive_size)
+  {
+    std::string positive_str;
+    if (!cstr2string(positive, positive_size, positive_str)) return;
+    CTimer::get("XIOS").resume();
+    scalar_hdl->positive.fromString(positive_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_positive(scalar_Ptr scalar_hdl, char * positive, int positive_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalar_hdl->positive.getInheritedStringValue(), positive, positive_size))
+      ERROR("void cxios_get_scalar_positive(scalar_Ptr scalar_hdl, char * positive, int positive_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_positive(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->positive.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_scalar_prec(scalar_Ptr scalar_hdl, int prec)
   {

XIOS/dev/branch_openmp/src/interface/c_attr/icscalargroup_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"
@@ -18 +18 @@
   typedef xios::CScalarGroup* scalargroup_Ptr;
 
+  void cxios_set_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl, const char * axis_type, int axis_type_size)
+  {
+    std::string axis_type_str;
+    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return;
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->axis_type.fromString(axis_type_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl, char * axis_type, int axis_type_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalargroup_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size))
+      ERROR("void cxios_get_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl, char * axis_type, int axis_type_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->axis_type.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalargroup_bounds(scalargroup_Ptr scalargroup_hdl, double* bounds, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData);
+    scalargroup_hdl->bounds.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_bounds(scalargroup_Ptr scalargroup_hdl, double* bounds, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData);
+    tmp=scalargroup_hdl->bounds.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_bounds(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->bounds.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl, const char * bounds_name, int bounds_name_size)
+  {
+    std::string bounds_name_str;
+    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return;
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->bounds_name.setValue(bounds_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl, char * bounds_name, int bounds_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalargroup_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size))
+      ERROR("void cxios_get_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->bounds_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalargroup_comment(scalargroup_Ptr scalargroup_hdl, const char * comment, int comment_size)
+  {
+    std::string comment_str;
+    if (!cstr2string(comment, comment_size, comment_str)) return;
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->comment.setValue(comment_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_comment(scalargroup_Ptr scalargroup_hdl, char * comment, int comment_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalargroup_hdl->comment.getInheritedValue(), comment, comment_size))
+      ERROR("void cxios_get_scalargroup_comment(scalargroup_Ptr scalargroup_hdl, char * comment, int comment_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_comment(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->comment.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_scalargroup_group_ref(scalargroup_Ptr scalargroup_hdl, const char * group_ref, int group_ref_size)
   {
@@ -44 +147 @@
 
 
+  void cxios_set_scalargroup_label(scalargroup_Ptr scalargroup_hdl, const char * label, int label_size)
+  {
+    std::string label_str;
+    if (!cstr2string(label, label_size, label_str)) return;
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->label.setValue(label_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_label(scalargroup_Ptr scalargroup_hdl, char * label, int label_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalargroup_hdl->label.getInheritedValue(), label, label_size))
+      ERROR("void cxios_get_scalargroup_label(scalargroup_Ptr scalargroup_hdl, char * label, int label_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_label(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->label.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_scalargroup_long_name(scalargroup_Ptr scalargroup_hdl, const char * long_name, int long_name_size)
   {
@@ -96 +225 @@
 
 
+  void cxios_set_scalargroup_positive(scalargroup_Ptr scalargroup_hdl, const char * positive, int positive_size)
+  {
+    std::string positive_str;
+    if (!cstr2string(positive, positive_size, positive_str)) return;
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->positive.fromString(positive_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_positive(scalargroup_Ptr scalargroup_hdl, char * positive, int positive_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalargroup_hdl->positive.getInheritedStringValue(), positive, positive_size))
+      ERROR("void cxios_get_scalargroup_positive(scalargroup_Ptr scalargroup_hdl, char * positive, int positive_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_positive(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->positive.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_scalargroup_prec(scalargroup_Ptr scalargroup_hdl, int prec)
   {

XIOS/dev/branch_openmp/src/interface/c_attr/icvariable_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/icvariablegroup_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/iczoom_axis_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"

XIOS/dev/branch_openmp/src/interface/c_attr/iczoom_domain_attr.cpp

@@ -4 +4 @@
 
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"
 #include "attribute_template.hpp"