Changeset 126

Timestamp:

10/07/10 10:29:38 (14 years ago)

Author:

hozdoba

Message:

Amélioration de quelques portions de code.
Ajout de contructeurs par copie.

Location:

XMLIO_V2/dev/dev_rv/src/XMLIO

Files:

• NetCDF4_data_output.hpp (modified) (12 diffs)
• NetCDF4_data_treatment.hpp (deleted)
• abstract_calendar.hpp (modified) (1 diff)
• abstract_data_output.hpp (modified) (2 diffs)
• abstract_data_treatment.hpp (deleted)
• abstract_object.hpp (modified) (2 diffs)
• attribut.hpp (modified) (8 diffs)
• attribut_registrar.hpp (modified) (2 diffs)
• axis_attribut.hpp (modified) (2 diffs)
• base_attribut.hpp (modified) (3 diffs)
• c_interface.cpp (modified) (5 diffs)
• container.hpp (modified) (1 diff)
• context.hpp (modified) (2 diffs)
• data_treatment.hpp (added)
• declare_attribut.hpp (modified) (1 diff)
• declare_group.hpp (modified) (1 diff)
• domain_attribut.hpp (modified) (2 diffs)
• field_attribut.hpp (modified) (3 diffs)
• file_attribut.hpp (modified) (1 diff)
• grid_attribut.hpp (modified) (1 diff)
• group_template.hpp (modified) (5 diffs)
• object_template.hpp (modified) (8 diffs)
• xml_node.hpp (modified) (4 diffs)
• xmlio.hpp (modified) (2 diffs)

XMLIO_V2/dev/dev_rv/src/XMLIO/NetCDF4_data_output.hpp

@@ -10 +10 @@
       public :
 
-         NetCDF4DataOutput(CFile* const _file) : AbstractDataOutput(_file), dataFile(NULL)
+         NetCDF4DataOutput(CFile* const _file)
+            : AbstractDataOutput(_file), dataFile(NULL)
          { /* Ne rien faire de plus */ }
 
          const NcFile* getDataFile(void) const { return (dataFile); }
+
+         void writeVarData(const string& id, const Array<float, 1>& vdata)
+         {
+            //if (!latVar->put(lats, NLAT))
+            //   return NC_ERR;
+         }
 
          virtual ~NetCDF4DataOutput()
@@ -26 +33 @@
             const std::set<const CAxis*>  saxis = this->getRelFile()->getEnabledAxis();
 
-            // std::cout << "Nombre de domaines disponibles pour le fichier : " << sdom.size() << std::endl;
-            // std::cout << "Nombre d'axes disponibles pour le fichier : " << saxis.size() << std::endl;
+            // std::cout << "Nombre de domaines disponibles pour le fichier : " << sdom.size()  << std::endl;
+            // std::cout << "Nombre d'axes disponibles pour le fichier : "      << saxis.size() << std::endl;
 
             std::set<const CDomain*>::const_iterator itt;
+            std::set<const CAxis*>::const_iterator it;
+
             for ( itt = sdom.begin() ; itt != sdom.end(); itt++ )
             {
@@ -39 +48 @@
             }
 
-            std::set<const CAxis*>::const_iterator it;
             for ( it = saxis.begin() ; it != saxis.end(); it++ )
             {
@@ -54 +62 @@
          std::string getTimeStamp(void)
          {
-              time_t rawtime;
-              struct tm * timeinfo = NULL;
-              char buffer [100];
-
-              time ( &rawtime );
-              timeinfo = localtime ( &rawtime );
-
-              strftime (buffer, 100, "%Y-%b-%d %H:%M:%S %Z", timeinfo);
-
-              return (string(buffer));
-         }
+            const int buffer_size = 100;
+            time_t rawtime;
+            struct tm * timeinfo = NULL;
+            char buffer [buffer_size];
+
+            time ( &rawtime );
+            timeinfo = localtime ( &rawtime );
+            strftime (buffer, buffer_size, "%Y-%b-%d %H:%M:%S %Z", timeinfo);
+
+            return (string(buffer));
+         }
+
+         void writeCoords(const string& id, const Array<float, 1>& cdata)
+         {
+            NcVar *cVar = dataFile->get_var(id.c_str());
+
+            if (!cVar->put(cdata.dataFirst(), cdata.size()))
+               throw XMLIOUndefinedValueException("Impossible d'écrire les valeurs de coordonnées "+ id +" !");
+         }
+
+      protected : /* virtual */
 
          virtual void initFile(void)
          {
-            string filename = getFileName();
+            string filename = this->getFileName();
 
             // Création du fichier ou remplacement si celui-ci existe déjà .
@@ -150 +168 @@
 
                hm["axis"] = "Z" ;
-               if ((*it)->name.hasValue())        hm["standard_name"] = (*it)->name ;
-               if ((*it)->unit.hasValue())        hm["units"]         = (*it)->unit;
-               if ((*it)->description.hasValue()) hm["long_name"]     = (*it)->description ;
+               if ((*it)->standard_name.hasValue())hm["standard_name"] = (*it)->standard_name ;
+               if ((*it)->long_name.hasValue())    hm["long_name"]     = (*it)->long_name ;
+               if ((*it)->unit.hasValue())         hm["units"]         = (*it)->unit;
                addStringAttributesToVar(othvar, hm);
                hm.clear();
@@ -160 +178 @@
          virtual void setVars(void)
          {
-            NcType tvar;
+            NcType tvar = ncFloat;
             NcVar *var  = NULL;
             Poco::HashMap<string, string> hm;
@@ -167 +185 @@
 
             std::vector<CField*>::const_iterator it;
+
             for ( it = enabledFields.begin() ; it != enabledFields.end(); it++ )
             {
@@ -209 +228 @@
                   {
                      if (!(var = dataFile->add_var(fieldid.c_str(), tvar,
-                        dataFile->get_dim("time"), dataFile->get_dim(lonid.c_str()), dataFile->get_dim(latid.c_str()))))
+                        dataFile->get_dim("time"), dataFile->get_dim(latid.c_str()), dataFile->get_dim(lonid.c_str()))))
                         throw XMLIOUndefinedValueException("Impossible d'ajouter le champ "+ field->getId() +" !");
                   }
@@ -215 +234 @@
                   {
                      if (!(var = dataFile->add_var(fieldid.c_str(), tvar,
-                        dataFile->get_dim("time"), dataFile->get_dim(lonid.c_str()), dataFile->get_dim(latid.c_str()),
-                        dataFile->get_dim(axisid.c_str()))))
+                        dataFile->get_dim("time"), dataFile->get_dim(axisid.c_str()),
+                        dataFile->get_dim(latid.c_str()), dataFile->get_dim(lonid.c_str()))))
                         throw XMLIOUndefinedValueException("Impossible d'ajouter le champ "+ field->getId() +" !");
                   }
@@ -225 +244 @@
                   {
                      if (!(var = dataFile->add_var(fieldid.c_str(), tvar,
-                        dataFile->get_dim(lonid.c_str()), dataFile->get_dim(latid.c_str()))))
+                        dataFile->get_dim(latid.c_str()), dataFile->get_dim(lonid.c_str()))))
                         throw XMLIOUndefinedValueException("Impossible d'ajouter le champ "+ field->getId() +" !");
                   }
                   else // 3D spatio sans temps
                   {
-                     if (!(var = dataFile->add_var(fieldid.c_str(), tvar,
-                        dataFile->get_dim(lonid.c_str()), dataFile->get_dim(latid.c_str()),
-                        dataFile->get_dim(axisid.c_str()))))
-                        throw XMLIOUndefinedValueException("Impossible d'ajouter le champ "+ field->getId() +" !");
-                  }
-               }
-
-               if (field->name.hasValue())        hm["standard_name"] = field->name ;
-               if (field->unit.hasValue())        hm["units"]         = field->unit;
-               if (field->description.hasValue()) hm["long_name"]     = field->description ;
+                     if (!(var = dataFile->add_var(fieldid.c_str(), tvar, dataFile->get_dim(axisid.c_str()),
+                        dataFile->get_dim(latid.c_str()), dataFile->get_dim(lonid.c_str()))))
+                        throw XMLIOUndefinedValueException("Impossible d'ajouter le champ "+ field->getId() +" !");
+                  }
+               }
+
+               if (field->standard_name.hasValue())hm["standard_name"] = field->standard_name ;
+               if (field->long_name.hasValue())    hm["long_name"]     = field->long_name ;
+               if (field->unit.hasValue())         hm["units"]         = field->unit;
                addStringAttributesToVar(var, hm);
                hm.clear();
@@ -245 +263 @@
          }
 
-         virtual void writeCoords(const string& id, const Array<float, 1>& cdata)
-         {
-            //if (!latVar->put(lats, NLAT))
-            //   return NC_ERR;
-         }
-
-         virtual void writeVarData(const string& id, const Array<float, 1>& vdata)
-         {
-            //if (!latVar->put(lats, NLAT))
-            //   return NC_ERR;
-         }
-
       private :
 
@@ -262 +268 @@
          {
             Poco::HashMap<string, string>::ConstIterator it;
+
             for ( it = attr.begin() ; it != attr.end(); it++ )
                if (!var->add_att((*it).first.c_str(), (*it).second.c_str()))

XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_calendar.hpp

@@ -57 +57 @@
          { string value = getMonthName(_mi); value.resize(3); return (value); }
 
-         virtual ~AbstractCalendar()
-         {/* Ne rien faire de plus */}
+         virtual ~AbstractCalendar(void)
+         { /* Ne rien faire de plus */ }
 
       protected :
 
-         AbstractCalendar()
+         AbstractCalendar(void)
             : AbstractObject(), initDate(*this), currentDate(initDate), tempo(Hour)
-         {/* Ne rien faire de plus */}
+         { /* Ne rien faire de plus */ }
 
-         AbstractCalendar(const string& _id, int yr = 0, int mth = 1, int d = 1, int hr = 0, int min = 0 , int sec = 0)
+         AbstractCalendar(const string& _id,
+                          int yr = 0, int mth = 1, int d = 1, int hr = 0, int min = 0 , int sec = 0)
             : AbstractObject(_id), initDate(*this, yr, mth, d, hr, min, sec), currentDate(initDate), tempo(Hour)
-         {/* Ne rien faire de plus */}
+         { /* Ne rien faire de plus */ }
 
          AbstractCalendar(const string& _id, const string& dateStr)
             : AbstractObject(_id), initDate(Date::FromString(dateStr, *this)), currentDate(initDate), tempo(Hour)
-         {/* Ne rien faire de plus */}
+         { /* Ne rien faire de plus */ }
 
       private :

XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_data_output.hpp

@@ -16 +16 @@
          {
             // Création du fichier de sortie.
-            initFile();
+            this->initFile();
             // Définition des dimensions.
-            setDims();
+            this->setDims();
             // Définition des coordonnées.
-            setCoords();
+            this->setCoords();
             // Définitions des variables.
-            setVars();
+            this->setVars();
          }
 
@@ -32 +32 @@
          AbstractDataOutput(CFile* const _file): file(_file)
          { /* Ne rien faire de plus */ }
-
 
          virtual void initFile (void) = 0;

XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_object.hpp

@@ -15 +15 @@
          }
 
-         bool hasId(void) const { return(IdDefined); }
+         bool hasId(void) const { return (IdDefined); }
+
          void resetId(void) { IdDefined = false ;}
-         void setId(const std::string& _id) { id = _id ; IdDefined = true ;}
+
+         void setId(const std::string& _id)
+         { id = _id ; IdDefined = true ; }
 
          bool operator==(const AbstractObject& other) const
@@ -26 +29 @@
          }
 
+         bool operator!=(const AbstractObject& other) const
+         { return (!(*this == other)); }
+
          std::string printId(void) const
-         { if(hasId()) return (" id=\""+getId()+"\""); return (""); }
+         {
+            if(this->hasId())
+               return (string(" id=\""+getId()+"\""));
+            return (string(""));
+         }
 
          virtual ~AbstractObject(void)
-         {/* Ne rien faire de plus */}
+         { /* Ne rien faire de plus */ }
 
       protected :
 
-         AbstractObject(void) : IdDefined(false)
-         {/* Ne rien faire de plus */}
+         AbstractObject(void)
+            : IdDefined(false) // Sans identifiant.
+         { /* Ne rien faire de plus */ }
 
-         AbstractObject(const std::string& _id) : id(_id), IdDefined(true)
-         {/* Ne rien faire de plus */}
+         AbstractObject(const std::string& _id)
+            : id(_id), IdDefined(true)
+         { /* Ne rien faire de plus */ }
+
+         AbstractObject(const AbstractObject& _ao)
+            : id(_ao.id), IdDefined(_ao.IdDefined)
+         { /* Ne rien faire de plus */ }
 
       private :

XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp

@@ -15 +15 @@
    {
       public :
+
+         Attribut(void)
+            : BaseAttribut(), _hasValue(false)
+         { /* Ne rien faire de plus */ }
+
+         Attribut(const Ctype& value_)
+            : BaseAttribut(), _hasValue(true), value(value_)
+         { /* Ne rien faire de plus */ }
+
+         Attribut(const Attribut& attr)
+            : BaseAttribut(attr), _hasValue(attr._hasValue)
+         { if (_hasValue) value = attr.value ; }
+
+         Attribut& operator = (const Attribut & attr)
+         {
+            _hasValue = attr._hasValue ;
+            if (_hasValue) this->setValue(attr.value) ;
+            return (*this) ;
+         }
+
          operator Ctype() const
          {
@@ -21 +41 @@
          }
 
-         Ctype* operator ->() { return (&value) ; }
-         Ctype& operator *() { return (value) ; }
+         Ctype* operator ->(void) { return (&value); }
+         Ctype& operator * (void) { return (value) ; }
 
-         virtual bool hasValue() const { return (_hasValue); }
+      public : /* virtual */
+
+         virtual bool hasValue(void) const { return (_hasValue); }
          virtual const char * getType(void) const = 0;
-
-         Attribut(void) : _hasValue(false) {} ;
-         Attribut(const Ctype& value_) : _hasValue(true), value(value_) {} ;
-
-         Attribut(const Attribut& attr) : _hasValue(attr._hasValue)
-         {  if (_hasValue) value = attr.value ; }
-
-         Attribut& operator = (const Attribut & attr)
-         {
-            _hasValue = attr._hasValue ;
-            if (_hasValue) setValue(attr.value) ;
-            return (*this) ;
-         }
 
          virtual void setFromString(const std::string& str)
@@ -50 +59 @@
          { value = ((Attribut*)_ba) -> value; _hasValue = true; }
 
-         virtual ostream& print(ostream & o) const
-         { if (_hasValue) o << " " << getName() << "=\"" << boolalpha << value << "\"" ; return o ; }
+         virtual ostream& print(std::ostream & _out) const
+         { if (_hasValue) _out << " " << getName() << "=\"" << boolalpha << value << "\"" ; return (_out) ; }
 
          virtual void setValue(const Ctype & value_)
@@ -62 +71 @@
          }
 
+         virtual ~Attribut()
+         { /* Ne rien faire de plus */ }
+
       private :
 
@@ -69 +81 @@
    }; // class Attribut
 
-#define SET_ARRAY_DIM(type,dim)                                              \
+#define SET_ARRAY_DIM(type, dim)                                             \
    template<>                                                                \
       void Attribut<Array<type,dim> >::setValue (const Array<type,dim>& val) \
@@ -88 +100 @@
    {
       if (_hasValue) o << " " << getName() << "=\"" << value(0);
-      for (int i = 1; i < value.size(); i++) { o << "," << value(i); }
+      /*for (int i = 1; i < value.size(); i++)
+      { o << "," << value(i); }*/
+      o << value(0) << "..." << value(value.size()-1);
       o << "\"" ;
       return (o) ;
@@ -94 +108 @@
 
    template <>
-      void Attribut<Array<double,1> >::setFromString(const std::string& str)
+      void Attribut<Array<double,1> >::setFromString(const std::string& _str)
    {
-      istringstream iss(str) ;
-      char c = '\0'; double d = 0.;
-      vector<double> vect;
-      Array<double, 1> arr;
+      istringstream iss(_str) ;
+      char c = '\0'; int size = 0;
+      double d = 0.,valsup = 0., valinf = 0.;
+      std::vector<double> vect; Array<double, 1> arr;
 
       iss >> d; vect.push_back(d);
-      while(!iss.eof ()) { iss >> c >> d; vect.push_back(d); }
+      if (!iss.eof ())
+      {
+         iss >> c;
+         switch (c)
+         {
+            case ',' : // Le tableau est généré valeur par valeur.
+               iss.unget();
+               while(!iss.eof ())
+               { // On récupÚre chacune des valeurs une par une jusqu'à ce que le buffer soit vide.
+                  iss >> c >> d;
+                  if (c != ',')
+                     throw XMLIOUndefinedValueException("Le tableau de valeur est mal défini !");
+                  vect.push_back(d);
+               }
+               size = vect.size();
+               break;
+            case '(' : // Le tableau est généré automatiquement.
+               if (!iss.eof ())
+               { // on récupÚre la borne supérieure
+                  valinf = d;
+                  iss >> size >> c >> d;
+                  if ((c != ')') || (size <= 0))
+                     throw XMLIOUndefinedValueException("Le tableau de valeur est mal défini !");
+                  valsup = d;
+               }
+               d = (valsup - valinf) / (double)(size - 1);
+               for (int j = 1; j <= size; j++)
+                  vect.push_back(valinf + j * d);
+               break;
+            default :
+               throw XMLIOUndefinedValueException("Le tableau de valeur est mal défini !");
+         }
+      }
 
-      arr.resize(vect.size());
-      for (unsigned int i = 0; i < vect.size(); i++) arr(i) = vect[i];
+      arr.resize(size);
+      for (int i = 0; i < size; i++)
+         arr(i) = vect[i];
 
       this->setValue(arr);
@@ -114 +161 @@
    {
       istringstream iss(str) ;
-      bool val = (! iss.str().compare(string(".TRUE."))) ? true : false;
+      const bool val = (! iss.str().compare(string(".TRUE."))) ? true : false;
       this->setValue(val);
    }

XMLIO_V2/dev/dev_rv/src/XMLIO/attribut_registrar.hpp

@@ -12 +12 @@
       protected :
 
-         AttributRegistrar():attrList()
-         {/* Ne rien faire de plus */}
+         AttributRegistrar(void)
+            : attrList()
+         { /* Ne rien faire de plus */ }
 
-         void RegisterAttribut(BaseAttribut* attribut){ attrList.addObject(attribut); }
+         AttributRegistrar(const AttributRegistrar& _ar)
+            : attrList(_ar.attrList)
+         { /* Ne rien faire de plus */ }
+
+         void RegisterAttribut(BaseAttribut* const attribut){ attrList.addObject(attribut); }
+
          const StrHashMap<BaseAttribut>& getAttributList(void) const { return (attrList); }
-         size_t getNbAttributes() const {return (attrList.getSize()); }
+
+         size_t getNbAttributes(void) const { return (attrList.getSize()); }
+
          bool hasAttribut(const string& _id) const { return (attrList.hasMappedValue(_id)); }
+
+         const StrHashMap<BaseAttribut>& getAttrList(void) const { return (attrList); }
 
          BaseAttribut* getAttribut(const string& _id) throw (XMLIOUndefinedValueException) { return (attrList[_id]); }
@@ -55 +65 @@
          {
             if (hasAttribut(att_name)) getAttribut(att_name)->setFromString(value);
-            else throw XMLIOUndefinedValueException("Impossible de trouver l'attribut nommé \"" + att_name +"\" dans la liste des attributs enregistrés !");
+            else throw XMLIOUndefinedValueException("Impossible de trouver l'attribut nommé \""
+               + att_name +"\" dans la liste des attributs enregistrés !");
          }
 

XMLIO_V2/dev/dev_rv/src/XMLIO/axis_attribut.hpp

@@ -10 +10 @@
       public :
 
-         DECLARE_ATTR(name, string) ;
-         DECLARE_ATTR(description, string) ;
-         DECLARE_ATTR(unit, string) ;
-         DECLARE_ATTR(size, int) ;
-         DECLARE_ATTR(value, Array(double,1)) ;
+         DECLARE_ATTR(name          , string) ;
+         DECLARE_ATTR(standard_name , string) ;
+         DECLARE_ATTR(long_name     , string) ;
+
+         DECLARE_ATTR(unit          , string) ;
+         DECLARE_ATTR(size          , int) ;
+         DECLARE_ATTR(value         , Array(double, 1)) ;
 
          AxisAttribut(void) : AttributRegistrar()
-         { registerAllAttributes(); }
+         { this->registerAllAttributes(); }
 
       private :
@@ -24 +26 @@
          {
             RegisterAttribut(&name) ;
-            RegisterAttribut(&description) ;
+            RegisterAttribut(&standard_name) ;
+            RegisterAttribut(&long_name) ;
             RegisterAttribut(&unit) ;
             RegisterAttribut(&size) ;

XMLIO_V2/dev/dev_rv/src/XMLIO/base_attribut.hpp

@@ -4 +4 @@
 using std::ostream;
 using namespace blitz ;
-
 
 using XMLIOSERVER::XMLIOIncompatibleTypeException;
@@ -12 +11 @@
    class BaseAttribut
    {
-      public:
+      protected :
 
-         virtual string getName(void) const = 0  ;
-         virtual ostream & print(ostream& o) const = 0  ;
+         BaseAttribut(void)
+         { /* Ne rien faire de plus */ }
 
-         friend ostream& operator <<(ostream& o,const BaseAttribut& attr) { return (attr.print(o)) ; }
+         BaseAttribut(const BaseAttribut& _ba)
+         { /* Ne rien faire de plus */ }
+
+      public :
+
+         friend ostream& operator <<(ostream& _out,const BaseAttribut& _attr)
+         { return (_attr.print(_out)) ; }
 
          bool hasId(void) const { return (true); }
 
+      public : /* virtual */
+
          virtual string getId(void) const { return (getName()); } ;
 
-         virtual void assignValue(const BaseAttribut*) = 0;
-         virtual void setFromString(const std::string&) = 0;
-         virtual bool hasValue() const = 0;
+         virtual bool      hasValue     (void)          const = 0;
+         virtual string    getName      (void)          const = 0;
+         virtual ostream & print        (ostream& o)    const = 0;
+         virtual void      assignValue  (const BaseAttribut*) = 0;
+         virtual void      setFromString(const std::string&)  = 0;
 
-#define  SETTER_AND_GETTER(TYPE) \
-         virtual void setValue(const TYPE & value)          { error_set() ; }\
-         virtual void setValue(const Array<TYPE,1>& value)  { error_set() ; }\
-         virtual void setValue(const Array<TYPE,2>& value)  { error_set() ; }\
-         virtual void setValue(const Array<TYPE,3>& value)  { error_set() ; }\
-         virtual void setValue(const Array<TYPE,4>& value)  { error_set() ; }\
-         virtual void getValue(TYPE & value)         const  { error_get() ; }\
-         virtual void getValue(Array<TYPE,1>& value) const  { error_get() ; }\
-         virtual void getValue(Array<TYPE,2>& value) const  { error_get() ; }\
-         virtual void getValue(Array<TYPE,3>& value) const  { error_get() ; }\
-         virtual void getValue(Array<TYPE,4>& value) const  { error_get() ; }
+#define  SETTER_AND_GETTER(TYPE)                                                     \
+         virtual void setValue(const TYPE&)           { BaseAttribut::error_set() ; }\
+         virtual void setValue(const Array<TYPE,1>&)  { BaseAttribut::error_set() ; }\
+         virtual void setValue(const Array<TYPE,2>&)  { BaseAttribut::error_set() ; }\
+         virtual void setValue(const Array<TYPE,3>&)  { BaseAttribut::error_set() ; }\
+         virtual void setValue(const Array<TYPE,4>&)  { BaseAttribut::error_set() ; }\
+         virtual void getValue(TYPE&)          const  { BaseAttribut::error_get() ; }\
+         virtual void getValue(Array<TYPE,1>&) const  { BaseAttribut::error_get() ; }\
+         virtual void getValue(Array<TYPE,2>&) const  { BaseAttribut::error_get() ; }\
+         virtual void getValue(Array<TYPE,3>&) const  { BaseAttribut::error_get() ; }\
+         virtual void getValue(Array<TYPE,4>&) const  { BaseAttribut::error_get() ; }
 
          SETTER_AND_GETTER(int)
@@ -43 +52 @@
          SETTER_AND_GETTER(double)
          SETTER_AND_GETTER(char)
-         SETTER_AND_GETTER(string)
+         SETTER_AND_GETTER(std::string)
 
 #undef SETTER_AND_GETTER
 
+         virtual ~BaseAttribut(void)
+         { /* Ne rien faire de plus */ }
+
+      public : /* static */
+
          static void error_set(void)
-         { throw XMLIOIncompatibleTypeException("BaseAttribut::set<type> > Setting value type is incompatible with attribut type"); }
+         { throw XMLIOIncompatibleTypeException
+           ("BaseAttribut::set<type> > Setting value type is incompatible with attribut type"); }
 
          static void error_get(void)
-         { throw XMLIOIncompatibleTypeException("BaseAttribut::set<type> >Getting value type is incompatible with attribut type"); }
+         { throw XMLIOIncompatibleTypeException
+           ("BaseAttribut::set<type> >Getting value type is incompatible with attribut type"); }
 
    }; //class BaseAttribut

XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp

@@ -15 +15 @@
    static int called = 0; int i = 0;
    for (T it = begin; it != end; it++, i++)
-      (*it) = i + called * 0.1;
+      (*it) = i + called * 0.01;
    called++;
 }
@@ -23 +23 @@
    try
    {
-      Array<double, 3> arr(100, 100, 20) ; // Les données(les arguments en fonction des dimensions).
+      Array<double, 3> arr(100, 100, 20) ; // Initialisation des données (les arguments en fonction des dimensions).
       string file("/local/XMLIOSERVER_DEV/dev_rv/test/iodef_simple_test.xml"); // Le fichier de définition.
       ifstream istr( file.c_str() , ifstream::in );
@@ -34 +34 @@
 
       // On se place dans le contexte 'context1'.
-      Context::SetCurrentContext("context1") ;
+      Context::SetCurrentContext("context1", true) ;
 
-      std::cout << " * ----------- Début du traitement ----------- * " << std::endl;
+      std::cout << " * ----------- Début du traitement ----------- * " << std::endl << std::endl;
 
       {
          // On crée une instance de traitement de données dans le format NetCDF4.
-         AbstractDataTreatment *dtreat = new NetCDF4DataTreatment();
-         dtreat->createDataOutput();
+         DataTreatment dtreat;
+         dtreat.createDataOutput<NetCDF4DataOutput>();
 
          // Récupération du calendrier assossié au context courant et initialisation des delais d'écriture.
-         AbstractCalendar* calendar = dtreat->getCurrentContext()->getCalendar();
-         calendar->setTempo(1*Hour);
+         AbstractCalendar* calendar = dtreat.getCurrentContext()->getCalendar();
+         calendar->setTempo(1 * Hour);
 
-         //Affichage de la date initiale (pour vérification).
-         std::cout << *calendar << std::endl;
+         // Affichage de la date initiale (pour vérification).
+         std::cout << "Calendrier associé au contexte : " << *calendar << std::endl << std::endl;
 
          for(int tcourant = 0, tfinal = 9; tcourant <= tfinal; tcourant++)
@@ -56 +56 @@
             calendar->update();
 
-            std::cout << "> Itération de calcul " << tcourant << ", " << *calendar << std::endl;
+            // Affichage des informations temporelles sur l'itération actuelle.
+            std::cout << "> Itération de calcul effectuée à la date t" << tcourant << " = " << calendar->getCurrentDate()
+                      << " (soit aprÚs " << (Time)calendar->getCurrentDate() << " sec.)." << std::endl;
 
             // Mise à jour des données.
@@ -62 +64 @@
 
             // Ecriture des données.
-            dtreat->writeData<Array<double, 3> >("champ1", arr);
+            dtreat.writeData<Array<double, 3> >("champ1", arr);
          }
 
          // On écrit l'arborescence résultante du traitement sur la sortie de log.
-         // Context::ShowTree(std::clog);
-
-         delete dtreat;
+         //Context::ShowTree(std::clog);
       }
 

XMLIO_V2/dev/dev_rv/src/XMLIO/container.hpp

@@ -38 +38 @@
          {/* Ne rien faire de plus */}
 
-         bool addValue(const Key& kval, Mapped* element)
+         bool addValue(const Key& kval, Mapped* const element)
          {
-            pair<typename ExHashMap::Iterator,bool> p = this->insert(make_pair (kval,element));
+            std::pair<typename ExHashMap::Iterator, bool> p = this->insert(make_pair (kval,element));
             if(!p.second) return (false);
             return (this->addValue(element));
          }
 
-         bool addValue(Mapped* element)
+         bool addValue(Mapped* const element)
          {   this->_elemList.insert(this->_elemList.end(), element);   return (true);   }
 

XMLIO_V2/dev/dev_rv/src/XMLIO/context.hpp

@@ -16 +16 @@
             fieldDef(NULL), fileDef(NULL), axisDef(NULL), gridDef(NULL), domainDef(NULL)
          {/* Ne rien faire de plus */}
-
-         static void ShowTree(ostream& os = std::clog)
-         {
-            os << NIndent << "<?xml version=\"1.0\"?>" << std::endl;
-            os << NIndent << "<" << Context::GetRootName() << ">" << std::endl;
-
-            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
-            for (Poco::HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
-               // On sort chacun des contextes successivement.
-            { Context::SetCurrentContext((*it).first); os << *((*it).second)[(*it).first] << std::endl; }
-
-            os << NIndent << "</" << Context::GetRootName() << ">" << std::endl  ;
-         }
-
-         static void FreeMemory(void)
-         {
-            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
-            for (Poco::HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
-            { Context::SetCurrentContext((*it).first); delete ((*it).second)[(*it).first]; }
-         }
-
-         // Ne plus utiliser, disponible dans les classe treatment.
-         static void ResolveInheritance(void)
-         {
-            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
-            for (Poco::HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
-            {
-               // Résolution des héritages descendants (cà d des héritages de groupes) pour chacun des contextes.
-               Context::SetCurrentContext((*it).first);
-               ((*it).second)[(*it).first]->resolveDescInheritance();
-
-               // Résolution des héritages par référence au niveau des fichiers.
-               const std::vector<CFile*>& allFiles = CFile::GetCurrentListObject().getVector();
-               for (unsigned int i = 0; i < allFiles.size(); i++) allFiles[i]->resolveFieldRefInheritance();
-            }
-         }
-
-         static Context* SwapContext(void)
-         {
-            if (Stid.size() == 0)
-            {
-               WARNING("SwapContext impossible car le pile des contextes est vides !");
-               return (NULL);
-            }
-            string lastId = Stid.top (); Stid.pop ();
-            return (Context::GetObject(lastId));
-         }
-
-         static Context* GetCurrentContext(void)
-         { return (Context::GetObject(Context::GetCurrentContextId())); }
-
-         static void SetCurrentContext(const string& id, bool withSwap = false)
-         {
-            if (withSwap) Stid.push (Context::GetCurrentContextId());
-
-            // On modifie le context courrant pour tout les ObjectTemplate
-            Context::SetContext(id);
-
-            // Changement de context pour les champs et groupes de champs.
-            FieldGroup::SetContext(id);  CField::SetContext(id);
-
-            // Changement de context pour les fichiers et groupes de fichiers.
-            FileGroup::SetContext(id);   CFile::SetContext(id);
-
-            // Changement de context pour les grilles et groupes de grilles.
-            GridGroup::SetContext(id);   CGrid::SetContext(id);
-
-            // Changement de context pour les axes et groupes d'axes.
-            AxisGroup::SetContext(id);   CAxis::SetContext(id);
-
-            // Changement de context pour les domaines et groupes de domaines.
-            DomainGroup::SetContext(id); CDomain::SetContext(id);
-         }
-
-         virtual void parse (XMLNode& _node)
-         {
-            THashAttributes attributes;
-
-            /// PARSING POUR GESTION DES ENFANTS
-            if (_node.getElementName().compare(Context::GetName()))
-               WARNING("Le noeud est mal nommé mais sera traité comme un context !");
-
-            if (!(_node.goToChildElement()))
-               WARNING("Le context ne contient pas d'enfant !");
-            else
-            {
-              do { // Parcours des contexts pour traitement.
-
-                  string name = _node.getElementName();
-                  attributes.clear();
-                  _node.getAttributes(attributes);
-
-                  if (attributes.end() != attributes.find("id"))
-                  { WARNING("Le noeud de définition possÚde un identifiant, ce dernier ne sera pas pris en compte lors du traitement !"); }
-
-                  if (name.compare(FieldDefinition::GetDefName())  == 0) // Parsing pour la définition des champs.
-                  { fieldDef  = CreateInstanceAndParse<FieldDefinition >(_node, FieldDefinition::GetDefName().c_str()); continue; }
-
-                  if (name.compare(FileDefinition::GetDefName())  == 0) // Parsing pour la définition des fichiers.
-                  { fileDef   = CreateInstanceAndParse<FileDefinition  >(_node, FileDefinition  ::GetDefName().c_str()); continue; }
-
-                  if (name.compare(AxisDefinition::GetDefName())  == 0) // Parsing pour la définition des axes.
-                  { axisDef   = CreateInstanceAndParse<AxisDefinition  >(_node, AxisDefinition  ::GetDefName().c_str()); continue; }
-
-                  if (name.compare(GridDefinition::GetDefName())  == 0) // Parsing pour la définition des grilles.
-                  { gridDef   = CreateInstanceAndParse<GridDefinition  >(_node, GridDefinition  ::GetDefName().c_str()); continue; }
-
-                  if (name.compare(DomainDefinition::GetDefName()) == 0) // Parsing pour la définition des domaines.
-                  { domainDef = CreateInstanceAndParse<DomainDefinition>(_node, DomainDefinition::GetDefName().c_str()); continue; }
-
-                  WARNING("La définition est invalide, seuls les champs, grilles, axes et fichiers peuvent être définis !");
-
-               } while (_node.goToNextElement());
-
-               _node.goToParentElement(); // Retour au parent
-            }
-         }
-
-         static string GetRootName(void) { return ("simulation"); }
-         static string GetName(void)     { return ("context"); }
-         static string GetDefName(void)  { return (Context::GetName()); }
-
-
-         virtual bool hasChild(void) const
-         { return ((fieldDef != NULL) or (fileDef != NULL)  or (axisDef != NULL) or (gridDef != NULL) or (domainDef != NULL)); }
-
-         virtual void printChild(ostream& out) const
-         {
-            if(fieldDef  != NULL) out << *(FieldGroup*)       fieldDef  << std::endl;
-            if(fileDef   != NULL) out << *(FileGroup*)        fileDef   << std::endl;
-            if(axisDef   != NULL) out << *(AxisDefinition*)   axisDef   << std::endl;
-            if(gridDef   != NULL) out << *(GridDefinition*)   gridDef   << std::endl;
-            if(domainDef != NULL) out << *(DomainDefinition*) domainDef << std::endl;
-         }
-
-         virtual void resolveDescInheritance(const AttributRegistrar* const _parent = 0)
-         {
-            if (_parent != 0) return;
-            // Résolution des héritages descendants pour chacun des groupes de définitions.
-            if(fieldDef  != NULL) fieldDef ->resolveDescInheritance();
-            if(fileDef   != NULL) fileDef  ->resolveDescInheritance();
-            if(axisDef   != NULL) axisDef  ->resolveDescInheritance();
-            if(gridDef   != NULL) gridDef  ->resolveDescInheritance();
-            if(domainDef != NULL) domainDef->resolveDescInheritance();
-         }
 
          FieldDefinition  * getFieldDefinition(void)  const { return (this->fieldDef ); }
@@ -198 +53 @@
          }
 
+      public : /* virtual */
+
+         virtual void parse (XMLNode& _node)
+         {
+            THashAttributes attributes;
+
+            /// PARSING POUR GESTION DES ENFANTS
+            if (_node.getElementName().compare(Context::GetName()))
+               WARNING("Le noeud est mal nommé mais sera traité comme un context !");
+
+            if (!(_node.goToChildElement()))
+               WARNING("Le context ne contient pas d'enfant !");
+            else
+            {
+              do { // Parcours des contexts pour traitement.
+
+                  string name = _node.getElementName();
+                  attributes.clear();
+                  _node.getAttributes(attributes);
+
+                  if (attributes.end() != attributes.find("id"))
+                  { WARNING("Le noeud de définition possÚde un identifiant, ce dernier ne sera pas pris en compte lors du traitement !"); }
+
+                  if (name.compare(FieldDefinition::GetDefName())  == 0) // Parsing pour la définition des champs.
+                  { fieldDef  = CreateInstanceAndParse<FieldDefinition >(_node, FieldDefinition::GetDefName().c_str()); continue; }
+
+                  if (name.compare(FileDefinition::GetDefName())  == 0) // Parsing pour la définition des fichiers.
+                  { fileDef   = CreateInstanceAndParse<FileDefinition  >(_node, FileDefinition  ::GetDefName().c_str()); continue; }
+
+                  if (name.compare(AxisDefinition::GetDefName())  == 0) // Parsing pour la définition des axes.
+                  { axisDef   = CreateInstanceAndParse<AxisDefinition  >(_node, AxisDefinition  ::GetDefName().c_str()); continue; }
+
+                  if (name.compare(GridDefinition::GetDefName())  == 0) // Parsing pour la définition des grilles.
+                  { gridDef   = CreateInstanceAndParse<GridDefinition  >(_node, GridDefinition  ::GetDefName().c_str()); continue; }
+
+                  if (name.compare(DomainDefinition::GetDefName()) == 0) // Parsing pour la définition des domaines.
+                  { domainDef = CreateInstanceAndParse<DomainDefinition>(_node, DomainDefinition::GetDefName().c_str()); continue; }
+
+                  WARNING("La définition est invalide, seuls les champs, grilles, axes et fichiers peuvent être définis !");
+
+               } while (_node.goToNextElement());
+
+               _node.goToParentElement(); // Retour au parent
+            }
+         }
+
+         virtual bool hasChild(void) const
+         { return ((fieldDef != NULL) or (fileDef != NULL)  or (axisDef != NULL) or (gridDef != NULL) or (domainDef != NULL)); }
+
+         virtual void printChild(ostream& out) const
+         {
+            if(fieldDef  != NULL) out << *(FieldGroup*)       fieldDef  << std::endl;
+            if(fileDef   != NULL) out << *(FileGroup*)        fileDef   << std::endl;
+            if(axisDef   != NULL) out << *(AxisDefinition*)   axisDef   << std::endl;
+            if(gridDef   != NULL) out << *(GridDefinition*)   gridDef   << std::endl;
+            if(domainDef != NULL) out << *(DomainDefinition*) domainDef << std::endl;
+         }
+
+         virtual void resolveDescInheritance(const AttributRegistrar* const _parent = 0)
+         {
+            if (_parent != 0) return;
+            // Résolution des héritages descendants pour chacun des groupes de définitions.
+            if(fieldDef  != NULL) fieldDef ->resolveDescInheritance();
+            if(fileDef   != NULL) fileDef  ->resolveDescInheritance();
+            if(axisDef   != NULL) axisDef  ->resolveDescInheritance();
+            if(gridDef   != NULL) gridDef  ->resolveDescInheritance();
+            if(domainDef != NULL) domainDef->resolveDescInheritance();
+         }
+
+      public : /* static */
+
+         static string GetRootName(void) { return ("simulation"); }
+         static string GetName(void)     { return ("context"); }
+         static string GetDefName(void)  { return (Context::GetName()); }
+
+         static void ShowTree(ostream& os = std::clog)
+         {
+            os << NIndent << "<?xml version=\"1.0\"?>" << std::endl;
+            os << NIndent << "<" << Context::GetRootName() << ">" << std::endl;
+
+            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
+            for (Poco::HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
+               // On sort chacun des contextes successivement.
+            {
+               Context::SetCurrentContext((*it).first);
+               os << NIndent << std::endl;
+               os << *((*it).second)[(*it).first] << std::endl;
+            }
+
+            os << NIndent << std::endl;
+            os << NIndent << "</" << Context::GetRootName() << ">" << std::endl  ;
+         }
+
+         static void FreeMemory(void)
+         {
+            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
+            for (Poco::HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
+            { Context::SetCurrentContext((*it).first); delete ((*it).second)[(*it).first]; }
+         }
+
+         // Ne plus utiliser, disponible dans les classe treatment.
+         static void ResolveInheritance(void)
+         {
+            Poco::HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
+            for (Poco::HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
+            {
+               // Résolution des héritages descendants (cà d des héritages de groupes) pour chacun des contextes.
+               Context::SetCurrentContext((*it).first);
+               ((*it).second)[(*it).first]->resolveDescInheritance();
+
+               // Résolution des héritages par référence au niveau des fichiers.
+               const std::vector<CFile*>& allFiles = CFile::GetCurrentListObject().getVector();
+               for (unsigned int i = 0; i < allFiles.size(); i++) allFiles[i]->resolveFieldRefInheritance();
+            }
+         }
+
+         static Context* SwapContext(void)
+         {
+            if (Stid.size() == 0)
+            {
+               WARNING("SwapContext impossible car le pile des contextes est vides !");
+               return (NULL);
+            }
+            string lastId = Stid.top (); Stid.pop ();
+            return (Context::GetObject(lastId));
+         }
+
+         static Context* GetCurrentContext(void)
+         { return (Context::GetObject(Context::GetCurrentContextId())); }
+
+         static void SetCurrentContext(const string& id, bool withSwap = false)
+         {
+            if (withSwap) Stid.push (Context::GetCurrentContextId());
+
+            // On modifie le context courrant pour tout les ObjectTemplate
+            Context::SetContext(id);
+
+            // Changement de context pour les champs et groupes de champs.
+            FieldGroup::SetContext(id);  CField::SetContext(id);
+
+            // Changement de context pour les fichiers et groupes de fichiers.
+            FileGroup::SetContext(id);   CFile::SetContext(id);
+
+            // Changement de context pour les grilles et groupes de grilles.
+            GridGroup::SetContext(id);   CGrid::SetContext(id);
+
+            // Changement de context pour les axes et groupes d'axes.
+            AxisGroup::SetContext(id);   CAxis::SetContext(id);
+
+            // Changement de context pour les domaines et groupes de domaines.
+            DomainGroup::SetContext(id); CDomain::SetContext(id);
+         }
+
       private:
 
          static stack<string> Stid;
 
-         AbstractCalendar* ccalendar;
-
-         FieldDefinition*  fieldDef;
-         FileDefinition*   fileDef;
-         AxisDefinition*   axisDef;
-         GridDefinition*   gridDef;
-         DomainDefinition* domainDef;
+         AbstractCalendar * ccalendar;
+
+         FieldDefinition  * fieldDef;
+         FileDefinition   * fileDef;
+         AxisDefinition   * axisDef;
+         GridDefinition   * gridDef;
+         DomainDefinition * domainDef;
 
    }; //class Context
 
-   //stack<string> Context::Stid();
+   stack<string> Context::Stid;
 
 }// namespace XMLIOSERVER

XMLIO_V2/dev/dev_rv/src/XMLIO/declare_attribut.hpp

@@ -6 +6 @@
 #define Array(x,y) Array<x,y>
 
-#define DECLARE_ATTR(att_name,att_type)               \
-   class attr_##att_name : public Attribut<att_type>  \
+#define DECLARE_ATTR(att_name, att_type)              \
+   class Attr_##att_name : public Attribut<att_type>  \
    {                                                  \
       public:                                         \
-         virtual string getName(void) const { return #att_name ;}                   \
-         virtual const char * getType(void) const { return #att_type ;}             \
-         attr_##att_name(void) : Attribut<att_type>() {}                            \
-         attr_##att_name(const att_type& value_) : Attribut<att_type>(value_) {}    \
-         attr_##att_name(const attr_##att_name & att) : Attribut<att_type>(att) {}  \
-   } att_name
+                                                      \
+         virtual string       getName(void) const { return (#att_name) ;}           \
+         virtual const char * getType(void) const { return (#att_type) ;}           \
+                                                                                    \
+         Attr_##att_name(void) : Attribut<att_type>()                               \
+         { /* Ne rien faire de plus */ }                                            \
+         Attr_##att_name(const att_type& _value) : Attribut<att_type>(_value)       \
+         { /* Ne rien faire de plus */ }                                            \
+         Attr_##att_name(const Attr_##att_name & att) : Attribut<att_type>(att)     \
+         { /* Ne rien faire de plus */ }                                            \
+                                                                                    \
+         virtual ~Attr_##att_name()                                                 \
+         { /* Ne rien faire de plus */ }                                            \
+   };                                                                               \
+                                                                                    \
+   const Attr_##att_name& getAttr_##att_name(void) const { return (att_name); }     \
+   const Attr_##att_name& get_##att_name(void)     const { return (att_name); }     \
+                                                                                    \
+   void setAttr##att_name(const Attr_##att_name& _newattr) { att_name = _newattr; } \
+   void set_##att_name    (const Attr_##att_name& _newattr) { att_name = _newattr; }\
+                                                                                    \
+   void setAttr##att_name(const att_type& _newattr) { att_name.setValue(_newattr); }\
+   void set_##att_name   (const att_type& _newattr) { att_name.setValue(_newattr); }\
+   Attr_##att_name att_name
 
 #endif // __DECLARE_ATTRIBUT__

XMLIO_V2/dev/dev_rv/src/XMLIO/declare_group.hpp

@@ -2 +2 @@
 #define __DECLARE_GROUP__
 
-#define DECLARE_GROUP(child_type) \
-   namespace XMLIOSERVER \
-   {  \
-      class child_type##Group : public GroupTemplate<C##child_type, child_type##Attribut>\
-      {\
-         public:\
-            child_type##Group(void) : GroupTemplate<C##child_type, child_type##Attribut>(){}\
-            child_type##Group(const string& _id) : GroupTemplate<C##child_type, child_type##Attribut>(_id) {}\
-            void parse (XMLNode& _node, bool _withAttr = true) { _parse<child_type##Group>(_node, _withAttr); }\
-            virtual ~child_type##Group(void){}\
-      }; \
-      typedef child_type##Group child_type##Definition; \
+#define DECLARE_GROUP(child_type)                                          \
+   namespace XMLIOSERVER                                                   \
+   {                                                                       \
+      class child_type##Group                                              \
+         : public GroupTemplate<C##child_type, child_type##Attribut>       \
+      {                                                                    \
+         public:                                                           \
+                                                                           \
+            child_type##Group(void)                                        \
+               : GroupTemplate<C##child_type, child_type##Attribut>()      \
+            { /* Ne rien faire de plus */ }                                \
+                                                                           \
+            child_type##Group(const string& _id)                           \
+               : GroupTemplate<C##child_type, child_type##Attribut>(_id)   \
+            { /* Ne rien faire de plus */ }                                \
+                                                                           \
+            void parse (XMLNode& _node, bool _withAttr = true)             \
+            { _parse<child_type##Group>(_node, _withAttr); }               \
+                                                                           \
+            virtual ~child_type##Group(void){}                             \
+      };                                                                   \
+                                                                           \
+      typedef child_type##Group child_type##Definition;                    \
    }
 

XMLIO_V2/dev/dev_rv/src/XMLIO/domain_attribut.hpp

@@ -10 +10 @@
       public :
 
-         DECLARE_ATTR(name, string) ;
-         DECLARE_ATTR(description, string);
-         DECLARE_ATTR(ni_glo, int);
-         DECLARE_ATTR(nj_glo, int) ;
-         DECLARE_ATTR(ibegin, int) ;
-         DECLARE_ATTR(iend, int) ;
-         DECLARE_ATTR(ni, int) ;
-         DECLARE_ATTR(jbegin, int) ;
-         DECLARE_ATTR(jend, int) ;
-         DECLARE_ATTR(nj, int) ;
-         DECLARE_ATTR(mask, Array(bool, 2)) ;
+         DECLARE_ATTR(name          , string) ;
+         DECLARE_ATTR(standard_name , string) ;
+         DECLARE_ATTR(long_name     , string) ;
 
-         DECLARE_ATTR(data_dim, int) ;
-         DECLARE_ATTR(data_ni, int);
-         DECLARE_ATTR(data_nj, int) ;
-         DECLARE_ATTR(data_ibegin, int) ;
-         DECLARE_ATTR(data_jbegin, int) ;
-         DECLARE_ATTR(data_n_index, int) ;
-         DECLARE_ATTR(data_i_index,Array(int, 1)) ;
-         DECLARE_ATTR(data_j_index,Array(int, 1)) ;
+         DECLARE_ATTR(ni_glo        , int) ;
+         DECLARE_ATTR(nj_glo        , int) ;
+         DECLARE_ATTR(ibegin        , int) ;
+         DECLARE_ATTR(iend          , int) ;
+         DECLARE_ATTR(ni            , int) ;
+         DECLARE_ATTR(jbegin        , int) ;
+         DECLARE_ATTR(jend          , int) ;
+         DECLARE_ATTR(nj            , int) ;
+         DECLARE_ATTR(mask          , Array(bool, 2)) ;
+
+         DECLARE_ATTR(data_dim      , int) ;
+         DECLARE_ATTR(data_ni       , int) ;
+         DECLARE_ATTR(data_nj       , int) ;
+         DECLARE_ATTR(data_ibegin   , int) ;
+         DECLARE_ATTR(data_jbegin   , int) ;
+         DECLARE_ATTR(data_n_index  , int) ;
+         DECLARE_ATTR(data_i_index  , Array(int, 1)) ;
+         DECLARE_ATTR(data_j_index  , Array(int, 1)) ;
 
          DomainAttribut(void) : AttributRegistrar()
-         { registerAllAttributes(); }
+         { this->registerAllAttributes(); }
 
       private :
@@ -39 +41 @@
          {
             RegisterAttribut(&name) ;
-            RegisterAttribut(&description) ;
+            RegisterAttribut(&standard_name) ;
+            RegisterAttribut(&long_name) ;
             RegisterAttribut(&ni_glo);
             RegisterAttribut(&nj_glo) ;

XMLIO_V2/dev/dev_rv/src/XMLIO/field_attribut.hpp

@@ -8 +8 @@
       public :
 
-         DECLARE_ATTR(name, string) ;
-         DECLARE_ATTR(description, string) ;
-         DECLARE_ATTR(unit, string) ;
-         DECLARE_ATTR(operation, FieldOperation);
+         DECLARE_ATTR(name         , string) ;
+         DECLARE_ATTR(standard_name, string) ;
+         DECLARE_ATTR(long_name    , string) ;
 
-         DECLARE_ATTR(freq_op, Duration) ;
-         DECLARE_ATTR(level, int) ;
-         DECLARE_ATTR(prec, int) ;
+         DECLARE_ATTR(unit         , string) ;
+         DECLARE_ATTR(operation    , FieldOperation) ;
 
-         DECLARE_ATTR(enabled, bool);
+         DECLARE_ATTR(freq_op      , Duration) ;
+         DECLARE_ATTR(level        , int) ;
+         DECLARE_ATTR(prec         , int) ;
 
-         DECLARE_ATTR(domain_ref, string);
-         DECLARE_ATTR(axis_ref, string);
-         DECLARE_ATTR(grid_ref, string) ;
-         DECLARE_ATTR(zoom_ref, string);
-         DECLARE_ATTR(field_ref, string);
+         DECLARE_ATTR(enabled      , bool) ;
+
+         DECLARE_ATTR(domain_ref   , string) ;
+         DECLARE_ATTR(axis_ref     , string) ;
+         DECLARE_ATTR(grid_ref     , string) ;
+         DECLARE_ATTR(zoom_ref     , string) ;
+         DECLARE_ATTR(field_ref    , string) ;
 
          FieldAttribut(void) : AttributRegistrar()
-         { registerAllAttributes(); }
+         { this->registerAllAttributes(); }
 
       private :
@@ -33 +35 @@
          {
             RegisterAttribut(&name) ;
-            RegisterAttribut(&description) ;
+            RegisterAttribut(&standard_name) ;
+            RegisterAttribut(&long_name) ;
             RegisterAttribut(&unit) ;
             RegisterAttribut(&operation);
@@ -42 +45 @@
             RegisterAttribut(&enabled);
 
-            RegisterAttribut(&domain_ref);
-            RegisterAttribut(&axis_ref);
-            RegisterAttribut(&grid_ref);
-            RegisterAttribut(&zoom_ref);
-            RegisterAttribut(&field_ref);
+            RegisterAttribut(&domain_ref) ;
+            RegisterAttribut(&axis_ref) ;
+            RegisterAttribut(&grid_ref) ;
+            RegisterAttribut(&zoom_ref) ;
+            RegisterAttribut(&field_ref) ;
          }
 

XMLIO_V2/dev/dev_rv/src/XMLIO/file_attribut.hpp

@@ -8 +8 @@
       public :
 
-         DECLARE_ATTR(name, string) ;
-         DECLARE_ATTR(description, string) ;
-         DECLARE_ATTR(output_freq, Duration) ;
+         DECLARE_ATTR(name        , string) ;
+         DECLARE_ATTR(description , string) ;
+         DECLARE_ATTR(output_freq , Duration) ;
          DECLARE_ATTR(output_level, int) ;
-         DECLARE_ATTR(enabled, bool);
+         DECLARE_ATTR(enabled     , bool);
 
          FileAttribut(void) : AttributRegistrar()
-         { registerAllAttributes(); }
+         { this->registerAllAttributes(); }
 
       private :

XMLIO_V2/dev/dev_rv/src/XMLIO/grid_attribut.hpp

@@ -8 +8 @@
       public :
 
-         DECLARE_ATTR(name, string) ;
+         DECLARE_ATTR(name       , string) ;
          DECLARE_ATTR(description, string) ;
-         DECLARE_ATTR(domain_ref, string) ;
-         DECLARE_ATTR(axis_ref, string) ; 
+         DECLARE_ATTR(domain_ref , string) ;
+         DECLARE_ATTR(axis_ref   , string) ;
 
          GridAttribut(void) : AttributRegistrar()
-         { registerAllAttributes(); }
+         { this->registerAllAttributes(); }
 
       private :

XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp

@@ -9 +9 @@
       public:
 
-         GroupTemplate(void) : ObjectTemplate<GroupTemplate<T, U> >(),  U(), childList(), groupList()
-         {/* Ne rien faire de plus */}
-         GroupTemplate(const string& _id) : ObjectTemplate<GroupTemplate<T, U> >(_id), U(), childList(), groupList()
-         {/* Ne rien faire de plus */}
+         GroupTemplate(void)
+            : ObjectTemplate<GroupTemplate<T, U> >(),  U(), childList(), groupList()
+         { /* Ne rien faire de plus */ }
+
+         GroupTemplate(const string& _id)
+            : ObjectTemplate<GroupTemplate<T, U> >(_id), U(), childList(), groupList()
+         { /* Ne rien faire de plus */ }
 
          /// Pour les groupes d'objets enfants ///
 
-         static string GetName(void) {return (T::GetName().append("_group")); }
-         static string GetDefName(void) {return (T::GetName().append("_definition")); }
+         GroupTemplate<T, U>& createGroup(const string& _id)
+            throw (XMLIOUndefinedValueException)
+         {
+            GroupTemplate<T, U> &obj = *GroupTemplate<T, U>::CreateObject(_id);
+            groupList.addObject(&obj);
+
+            return (obj);
+         }
+
+         GroupTemplate<T, U>& createGroup(void)
+         {
+            GroupTemplate<T, U>& obj = *(GroupTemplate<T, U>::CreateObject());
+            groupList.addObject(&obj);
+
+            return (obj);
+         }
+
+         GroupTemplate<T, U>& getGroup(const string& _id) const
+            throw (XMLIOUndefinedValueException)
+         { return (*groupList[_id]); }
+
+         bool hasGroup(const string& _id) const { return (groupList.hasMappedValue(_id)); }
+
+         const StrHashMap<GroupTemplate<T, U>* >& getGroupList(void) const { return (groupList); }
+
+         size_t getNbGroup() const {return (groupList.getVectorSize()); }
+
+         /// Pour les objets enfants ///
+
+         T& createChild(const string& _id)
+            throw (XMLIOUndefinedValueException)
+         {
+            T& obj = *ObjectTemplate<T>::CreateObject(_id);
+            childList.addObject(&obj);
+            return (obj);
+         }
+
+         T& createChild(void)
+         {
+            T& obj = *ObjectTemplate<T>::CreateObject();
+            childList.addObject(&obj);
+            return (obj);
+         }
+
+         T& getChild(const string& _id) const
+            throw (XMLIOUndefinedValueException)
+         { return (*childList[_id]); }
+
+         bool hasChild(const string& _id) const { return (childList.hasMappedValue(_id)); }
+
+         const StrHashMap<T*> & getCurrentListChild  (void) const { return (childList); }
+         const std::vector<T*>& getCurrentVectorChild(void) const { return (childList.getVector()); }
+
+         size_t getNbChild() const {return (childList.getVectorSize()); }
+
+         void getAllChildren(std::vector<T*>& _allc ) const
+         {
+            const vector<GroupTemplate<T, U>*>& groupvect = groupList.getVector();
+            _allc.insert (_allc.end(), getCurrentVectorChild().begin(), getCurrentVectorChild().end());
+
+            for(unsigned int i = 0; i < groupvect.size() ; i++)
+               groupvect[i] -> getAllChildren(_allc);
+         }
+
+      public : /* static */
+
+         static string GetName(void)    { return (T::GetName().append("_group")); }
+         static string GetDefName(void) { return (T::GetName().append("_definition")); }
+
+      public : /* virtual */
+
+         virtual ~GroupTemplate()
+         {
+            for (unsigned int i = 0; i < childList.getVector().size(); i++)
+               delete childList.getVector()[i];
+            for (unsigned int i = 0; i < groupList.getVector().size(); i++)
+               delete groupList.getVector()[i];
+         }
 
          virtual bool hasChild(void) const { return ((getNbGroup() + getNbChild())>0); }
@@ -35 +114 @@
             const vector<GroupTemplate<T, U>*>& groupvect = groupList.getVector();
 
-            // On complÚte les propres attributs du groupe.
-            if (_parent!= NULL) AttributRegistrar::addAttributes(*_parent);
+            // On complÚte les propres attributs du groupe avec ceux du parent.
+            if (_parent != NULL) AttributRegistrar::addAttributes(*_parent);
 
             for(unsigned int i = 0; i < childvect.size() ; i++)
@@ -45 +124 @@
             // on complÚte les attributs des groupes enfants.
                groupvect[i] -> resolveDescInheritance(this);
-         }
-
-         GroupTemplate<T, U>& createGroup(const string& _id) throw (XMLIOUndefinedValueException)
-         {
-            GroupTemplate<T, U> &obj = *GroupTemplate<T, U>::CreateObject(_id);
-            groupList.addObject(&obj);
-
-            return (obj);
-         }
-
-         GroupTemplate<T, U>& createGroup(void)
-         {
-            GroupTemplate<T, U>& obj = *(GroupTemplate<T, U>::CreateObject());
-            groupList.addObject(&obj);
-
-            return (obj);
-         }
-
-         GroupTemplate<T, U>& getGroup(const string& _id) throw (XMLIOUndefinedValueException) { return (*groupList[_id]); }
-         bool hasGroup(const string _id) { return (groupList.hasMappedValue(_id)); }
-
-         const StrHashMap<GroupTemplate<T, U>* >& getGroupList(void) const { return (groupList); }
-
-         size_t getNbGroup() const {return (groupList.getVectorSize()); }
-
-         /// Pour les objets enfants ///
-
-         T& createChild(const string& _id) throw (XMLIOUndefinedValueException)
-         {
-            T& obj = *ObjectTemplate<T>::CreateObject(_id);
-            childList.addObject(&obj);
-            return (obj);
-         }
-
-         T& createChild(void)
-         {
-            T& obj = *ObjectTemplate<T>::CreateObject();
-            childList.addObject(&obj);
-            return (obj);
-         }
-
-         T& getChild(const string& _id) throw (XMLIOUndefinedValueException) { return (*childList[_id]); }
-         bool hasChild(const string& _id) { return (childList.hasMappedValue(_id)); }
-
-         const StrHashMap<T*>& getCurrentListChild(void) const { return (childList); }
-         const vector<T*>& getCurrentVectorChild(void) const { return (childList.getVector()); }
-
-         size_t getNbChild() const {return (childList.getVectorSize()); }
-
-         void getAllChildren(std::vector<T*>& _allc )
-         {
-            const vector<GroupTemplate<T, U>*>& groupvect = groupList.getVector();
-            _allc.insert (_allc.end(), getCurrentVectorChild().begin(), getCurrentVectorChild().end());
-
-            for(unsigned int i = 0; i < groupvect.size() ; i++)
-               groupvect[i] -> getAllChildren(_allc);
-         }
-
-         virtual ~GroupTemplate()
-         {
-            for (unsigned int i = 0; i < childList.getVector().size(); i++)
-               delete childList.getVector()[i];
-            for (unsigned int i = 0; i < groupList.getVector().size(); i++)
-               delete groupList.getVector()[i];
          }
 
@@ -158 +173 @@
             {// Si l'identifiant est défini.
                if (V::HasObject(attributes["id"]))
-                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommée \""+attributes["id"]+"\" existe déjà , le second fera référence au premier par défaut !"); // TODO TODO
+                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommée \""+attributes["id"]
+                          +"\" existe déjà , le second fera référence au premier par défaut !"); // TODO TODO
                instance_ptr = (V*)(&createGroup(attributes["id"]));
                instance_ptr->parse(_node);
@@ -176 +192 @@
             {// Si l'identifiant est défini.
                if (V::HasObject(attributes["id"]))
-                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommée \""+attributes["id"]+"\" existe déjà , le second fera référence au premier par défaut !"); // TODO TODO
+                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommée \""+attributes["id"]
+                          +"\" existe déjà , le second fera référence au premier par défaut !"); // TODO TODO
                instance_ptr = (V*)(&createChild(attributes["id"]));
                instance_ptr->parse(_node);

XMLIO_V2/dev/dev_rv/src/XMLIO/object_template.hpp

@@ -27 +27 @@
 
             if (c.baseObject != NULL)
-               out <<  IncIndent << "<-- Reference resolved for the following "+ T::GetName() +
-                       " : \"" << c.baseObject->getId() << "\" -->" << DecEndl << std::endl;
+               out <<  IncIndent << "<-- Référence résolu sur l'instance de "<< T::GetName()
+                   <<   " nommée \"" << c.baseObject->getId() << "\" -->" << DecEndl << std::endl;
+
+            if (c.isDefinition())
+            {
+               out << NIndent << std::endl;
+               out << NIndent << "<!-- Groupe de définition dans le contexte \"" << ObjectTemplate<T>::GetCurrentContextId() << "\" courant -->" << std::endl;
+            }
 
             if (c.hasChild())
             {
-               out << IncIndent  << "<" << c.getName()   << c.printId() << ar << ">" << std::endl;
+               out << IncIndent  << "<"  << c.getName()  << c.printId() << ar << ">" << std::endl;
                c.printChild(out); // << Ecriture des objets enfants ici.
+               if (c.hasId() && (c.getName().compare("context") == 0))
+                  out << NIndent << std::endl;
                out << NIndent    << "</" << c.getName()  << ">" << DecEndl;
             }
-            else out << IncIndent << "<" << c.getName()  << c.printId() << ar << "/>" << DecEndl;
+            else
+               out << IncIndent << "<" << c.getName()  << c.printId() << ar << "/>" << DecEndl;
 
             return (out);
          }
 
+         bool isDefinition(void) const
+         {
+            if (!this->hasId()) return (false);
+            return (this->getName().compare(this->getId()) == 0);
+         }
+
          string getName(void) const
          {
-            if (hasId())
+            if (this->hasId())
                if (T::GetDefName().compare(getId()) == 0)
-                  return T::GetDefName();
+                  return (T::GetDefName());
             return (T::GetName());
          }
@@ -51 +66 @@
          T* getBaseObject(void) const { return (baseObject); }
 
-         virtual T* getReference(void) const { return (NULL); }
-
          const vector<T*>& getVectRefObject(void) const { return (refObject); }
 
-         bool hasRefObject(void) { return (!refObject.empty()); }
+         bool hasRefObject(void) const { return (!refObject.empty()); }
 
          const T* addRefObject(T* obj)
          { refObject.push_back (obj); return (obj); }
 
+      public : /* virtual */
+
+         virtual T* getReference(void) const { return (NULL); }
          virtual bool hasChild(void) const { return (false); }
-         virtual void printChild(ostream& out) const { out << NIndent << "<!-- No child -->" << std::endl; }
-
-         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0) { addAttributes(*_parent); }
+
+         virtual void printChild(ostream& out) const
+         { out << NIndent << "<!-- No child -->" << std::endl; }
+
+         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0)
+         { this->addAttributes(*_parent); }
+
          virtual void resolveRefInheritance (void)
          {
@@ -89 +109 @@
 
             /// PARSING POUR GESION DES ENFANTS ///
-            // Rien à faire.
-         }
+            // Rien à faire ici.
+         }
+
+         virtual ~ObjectTemplate(void)
+         {/* Ne rien faire de plus */}
 
       public : /* static */
@@ -118 +141 @@
          static bool HasObject(const string& _id)
          {
-            if(ObjectTemplate<T>::AllListObj.find(CurrContext) == ObjectTemplate<T>::AllListObj.end()) return false;
+            if(ObjectTemplate<T>::AllListObj.find(CurrContext) ==
+               ObjectTemplate<T>::AllListObj.end())
+               return (false);
             return (ObjectTemplate<T>::AllListObj[CurrContext].hasMappedValue(_id));
          }
@@ -125 +150 @@
          static Poco::HashMap<string, StrHashMap<T> >& GetAllListObject(void) { return (AllListObj); }
 
-         static void SetContext(const string& id){ ObjectTemplate<T>::CurrContext = id; }
-
-         static string& GetCurrentContextId(void) { return (CurrContext); }
-
-         virtual ~ObjectTemplate(void)
-         {/* Ne rien faire de plus */}
+         static void SetContext(const string& id) { ObjectTemplate<T>::CurrContext = id; }
+
+         static string& GetCurrentContextId(void) { return (ObjectTemplate<T>::CurrContext); }
 
       protected :
 
-         ObjectTemplate(void) : AbstractObject(), baseObject(NULL), refObject()
-         {/* Ne rien faire de plus */}
-         ObjectTemplate(const string& _id) : AbstractObject(_id), baseObject(NULL), refObject()
-         {/* Ne rien faire de plus */}
+         ObjectTemplate(void)
+            : AttributRegistrar(), AbstractObject(), baseObject(NULL), refObject()
+         { /* Ne rien faire de plus */ }
+
+         ObjectTemplate(const string& _id)
+            : AttributRegistrar(), AbstractObject(_id), baseObject(NULL), refObject()
+         { /* Ne rien faire de plus */ }
+
+         ObjectTemplate(const ObjectTemplate<T>& _ot, bool _withAttrList = true, bool _withId = true)
+            : AttributRegistrar(), AbstractObject(), baseObject(_ot.baseObject), refObject(_ot.refObject)
+         {
+            // Si requis, ajout de l'identifiant lors de la copie.
+            if (_ot.hasId() && _withId) this->setId(_ot.getId());
+            // Si requis, ajout des attributs lors de la copie.
+            if (_withAttrList) this->addAttributes(_ot);
+         }
 
          XML::XMLNode getNodeIncludedFile(const string& path, const string& _rootName)
          {
             ifstream istr( path.c_str() , ifstream::in );
-            return XML::XMLNode::CreateNode(istr, _rootName);
+            return (XML::XMLNode::CreateNode(istr, _rootName));
          }
 
@@ -151 +185 @@
             {
                if (V::HasObject(did))
-                  WARNING("Le noeud nommé \""+ did +"\" existe déjà pour les instances de type "+V::GetName()+", le dernier défini complétera le premier dans le context actuel!");
+                  WARNING("Le noeud nommé \""+ did +"\" existe déjà pour les instances de type "+
+                           V::GetName()+", le dernier défini complétera le premier dans le context actuel!");
                instance_ptr = (V*)V::CreateObject(did);
                instance_ptr->parse(_node, parseAttr);
@@ -159 +194 @@
 
       private :
+
          T* baseObject;
-         vector<T*> refObject;
+         std::vector<T*> refObject;
+
+      private : /* static */
 
          static string CurrContext;
@@ -167 +205 @@
    };// class ObjectTemplate
 
+   // Initialisation des variables statiques de la classe ObjectTemplate.
    template <class T> string ObjectTemplate<T>::CurrContext ;
    template <class T> Poco::HashMap<string, StrHashMap<T> > ObjectTemplate<T>::AllListObj;

XMLIO_V2/dev/dev_rv/src/XMLIO/xml_node.hpp

@@ -12 +12 @@
       {
          public :
-
-            static XMLNode CreateNode(std::istream& _istr, const std::string& _rootName)
-            {
-               XMLNode node(_rootName);
-
-               if (_istr.good())
-               { // S'il est possible de lire le flux en entrée ...
-
-                  Poco::XML::InputSource src(_istr);
-                  Poco::XML::DOMParser parser;
-
-                  node.pDoc = parser.parse(&src);
-                  node.setCNode(node.pDoc->documentElement());
-                  if (node.getElementName().compare(_rootName) != 0) // << A passer en avertissement.
-                     throw XMLParsingException("L'élément racine doit avoir pour valeur <" + _rootName + "> (\"" + node.getElementName() + "\" lue)");
-               }
-               else
-                  throw XMLIOStreamException("Impossible de lire le flux en entrée pour le parsing XML !");
-
-               return (node);
-            }
 
             string getElementName(void) const
@@ -97 +76 @@
             }
 
+            THashAttributes getAttributes(void) const // Idem que précédemment mais avec copie.
+            { THashAttributes __attributes; this->getAttributes(__attributes); return (__attributes); }
+
             ~XMLNode()
             { /* Ne rien faire de plus */ }
+
+         public : /* static */
+
+            static XMLNode CreateNode(std::istream& _istr, const std::string& _rootName)
+            {
+               XMLNode node(_rootName);
+
+               if (_istr.good())
+               { // S'il est possible de lire le flux en entrée ...
+
+                  Poco::XML::InputSource src(_istr);
+                  Poco::XML::DOMParser parser;
+
+                  node.pDoc = parser.parse(&src);
+                  node.setCNode(node.pDoc->documentElement());
+                  if (node.getElementName().compare(_rootName) != 0) // << A passer en avertissement.
+                     throw XMLParsingException("L'élément racine doit avoir pour valeur <" + _rootName + "> (\"" + node.getElementName() + "\" lue)");
+               }
+               else
+                  throw XMLIOStreamException("Impossible de lire le flux en entrée pour le parsing XML !");
+
+               return (node);
+            }
 
          protected :
@@ -104 +109 @@
             Poco::XML::Node * getCNode(void) const { return (this->cNode); }
             void setCNode(Poco::XML::Node * _otherNode) { this->cNode = _otherNode; }
+
+         protected : /* static */
 
             static bool IsPtrNull(const Poco::XML::Node * const _ptr) { return (_ptr == NULL); }
@@ -120 +127 @@
 
             Poco::XML::AutoPtr<Poco::XML::Document> pDoc;
-            Poco::XML::Node*  cNode;
+            Poco::XML::Node* cNode;
 
             string rootName;

XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp

@@ -12 +12 @@
 #include <stack>
 
-//Flux.
+// Flux.
 #include <iostream>
 #include <fstream>
@@ -87 +87 @@
 #include "NetCDF4_data_output.hpp"
 
-// Traitement des données (abstract puis selon types de sortie)
-#include "abstract_data_treatment.hpp"
-#include "NetCDF4_data_treatment.hpp"
-
-
+// Traitement des données.
+#include "data_treatment.hpp"
 
 #endif // __XMLIO__