Changeset 120 for XMLIO_V2/dev/dev_rv

Timestamp:

09/08/10 15:02:31 (14 years ago)

Author:

hozdoba

Message:

Mise à jour intermédiaire ...
A venir : commit d'une version stable intégrant l'écriture de fichiers NetCDF4.
(en cours de finalisation actuellement)

Location:

XMLIO_V2/dev/dev_rv/src/XMLIO

Files:

• NetCDF4_data_treatment.hpp (added)
• abstract_calendar.hpp (modified) (1 diff)
• abstract_data_treatment.hpp (added)
• abstract_object.hpp (modified) (1 diff)
• attribut.hpp (modified) (2 diffs)
• attribut_registrar.hpp (modified) (1 diff)
• axis_attribut.hpp (modified) (3 diffs)
• base_attribut.hpp (modified) (2 diffs)
• c_interface.cpp (modified) (3 diffs)
• calendar.hpp (modified) (3 diffs)
• container.hpp (modified) (4 diffs)
• context.hpp (modified) (8 diffs)
• date.hpp (modified) (2 diffs)
• declare_attribut.hpp (modified) (1 diff)
• domain.hpp (added)
• domain_attribut.hpp (added)
• field.hpp (modified) (1 diff)
• field_attribut.hpp (modified) (2 diffs)
• field_gridrefsolver.hpp (added)
• file.hpp (modified) (5 diffs)
• grid.hpp (modified) (1 diff)
• grid_attribut.hpp (modified) (2 diffs)
• group_template.hpp (modified) (5 diffs)
• logger.hpp (modified) (2 diffs)
• object_template.hpp (modified) (7 diffs)
• xml_node.hpp (modified) (10 diffs)
• xml_parser.hpp (modified) (1 diff)
• xmlio.hpp (modified) (3 diffs)

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

@@ -31 +31 @@
             for(_d0.setMonth(1); _d0.getMonth() < d.getMonth(); _d0.setMonth(_d0.getMonth()+1))
                nbday += getMonthLength(_d0);
-            //std::cout << "nombre de jours : " << nbday << std::endl;
             return ((((nbday + d.getDay()) * getDayLength() + d.getHour())
                      * getHourLength() + d.getMinute()) * getMinuteLength() + d.getSecond());

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

@@ -1 +1 @@
 #ifndef __XMLIO_OBJECT__
-#define __XMLIO_OBJECT__ 
-
-// Classes utilisées issues de la STL
-using std::pair;
-using std::string;
-using std::ostream;
-using std::ostringstream;
-
-// Classes XMLIOSERVER
-using XMLIOSERVER::XMLIOException;
-using XMLIOSERVER::XMLIOUndefinedValueException;
+#define __XMLIO_OBJECT__
 
 namespace XMLIOSERVER
 {
-   class AbstractObject 
+   class AbstractObject
    {
       public :
-      
+
+         const std::string& getId(void) const throw (XMLIOUndefinedValueException)
+         {
+            if (!hasId()) // Si l'identifiant de l'objet n'est pas défini.
+               throw XMLIOSERVER::XMLIOUndefinedValueException("Appel de la méthode AbstractObject::getId invalide.");
+            return (id);
+         }
+
+         bool hasId(void) const { return(IdDefined); }
+         void resetId(void) { IdDefined = false ;}
+         void setId(const std::string& _id) { id = _id ; IdDefined = true ;}
+
+         bool operator==(const AbstractObject& other) const
+         {
+            // Si l'un ou l'autre des objets n'a pas d'identifiant, les objets ne sont pas "égaux".
+            if(!this->hasId() || !other.hasId()) return false;
+            return (id.compare(other.id) == 0);
+         }
+
+         std::string printId(void) const
+         { if(hasId()) return (" id=\""+getId()+"\""); return (""); }
+
+         virtual ~AbstractObject(void)
+         {/* Ne rien faire de plus */}
+
+      protected :
+
          AbstractObject(void) : IdDefined(false)
          {/* Ne rien faire de plus */}
-         
-         AbstractObject(const string& _id) : id(_id), IdDefined(true)
-         {/* Ne rien faire de plus */}      
-   
-         const string& getId(void) const throw (XMLIOUndefinedValueException)
-         { if (!IdDefined) throw XMLIOUndefinedValueException("Appel de la méthode AbstractObject::getId invalide."); return (id); }   
-         
-         bool hasId(void) const { return(IdDefined); }
-         void resetId(void) { IdDefined = false ;}
-         void setId(const string& _id) { id = _id ; IdDefined = true ;}
-         
-         bool operator==(const AbstractObject& other)
-         {
-            // Si l'un ou l'autre des objets n'a pas d'identifiant, les objets ne sont pas "égaux".
-            if(!this->hasId() or !other.hasId()) return false;
-            return (id.compare(other.id) == 0);
-         }
-         
-         string printId(void) const
-         { if(hasId()) return (" id=\""+getId()+"\""); return (""); }
-         
-         virtual ~AbstractObject(void)
+
+         AbstractObject(const std::string& _id) : id(_id), IdDefined(true)
          {/* Ne rien faire de plus */}
-      
-      protected :
 
-            
       private :
-      
-         string id ;
+
+         std::string id ;
          bool IdDefined ;
-      
+
    };// class AbstractObject
-   
+
 }// namespace XMLIOSERVER
 
-#endif // __XMLIO_OBJECT__   
+#endif // __XMLIO_OBJECT__

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

@@ -7 +7 @@
 using XMLIOSERVER::XMLIOUndefinedValueException;
 using std::ostringstream;
+using namespace blitz ;
 
 namespace XMLIOSERVER
 {
-   class IStringStream_alt
-   {
-      public :
-         IStringStream_alt(const std::string& str) : iss(str)
-         { /* Ne rien faire de plus */}
-
-         istream& operator>> (std::string& s)
-         {s.assign(this->iss.str()); return (this->iss);}
-         istream& operator>> (int& s) { return (iss>>s); }
-         istream& operator>> (bool& s)
-         {
-            if(!this->iss.str().compare(string(".TRUE."))) s =  true;
-            else s = false;
-            return (this->iss);
-         }
-
-      private :
-         istringstream iss;
-
-   }; // class IStringStream_alt
-
-
    template <class Ctype>
       class Attribut : public BaseAttribut
    {
       public :
-
          operator Ctype() const
          {
-            if (!hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
+            if (!_hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
             return (value) ;
          }
 
-         virtual bool _hasValue() const { return (hasValue); }
+         Ctype* operator ->() { return (&value) ; }
+         Ctype& operator *() { return (value) ; }
 
-      protected :
+         virtual bool hasValue() const { return (_hasValue); }
+         virtual const char * getType(void) const = 0;
 
-         Attribut(void) : hasValue(false) {} ;
-         Attribut(const Ctype& value_) : hasValue(true), value(value_) {} ;
+         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(const Attribut& attr) : _hasValue(attr._hasValue)
+         {  if (_hasValue) value = attr.value ; }
 
          Attribut& operator = (const Attribut & attr)
          {
-            hasValue=attr.hasValue ;
-            if (hasValue) value=attr.value ;
-            return *this ;
+            _hasValue = attr._hasValue ;
+            if (_hasValue) setValue(attr.value) ;
+            return (*this) ;
          }
 
-         virtual const char * getType(void) const = 0;
-
-         virtual void setFromString(const std::string str)
+         virtual void setFromString(const std::string& str)
          {
-            IStringStream_alt iss(str); Ctype val;
+            istringstream iss(str); Ctype val;
             iss >> val;
             this->setValue(val);
@@ -70 +48 @@
 
          virtual void assignValue(const BaseAttribut* _ba)
-         { value = ((Attribut*)_ba) -> value; hasValue = true; }
+         { value = ((Attribut*)_ba) -> value; _hasValue = true; }
 
          virtual ostream& print(ostream & o) const
-         { if (hasValue) o << " " << getName() << "=\"" << boolalpha << value << "\"" ; return o ; }
+         { if (_hasValue) o << " " << getName() << "=\"" << boolalpha << value << "\"" ; return o ; }
 
          virtual void setValue(const Ctype & value_)
-         { hasValue=true ; value=value_ ; }
+         { _hasValue = true ; value = value_ ;}
 
          virtual void getValue(Ctype & value_) const
          {
-            if (!hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
-            value_=value ;
+            if (!_hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
+            value_ = value ;
          }
 
       private :
 
-         bool hasValue ;
+         bool _hasValue ;
          Ctype value ;
 
    }; // class Attribut
+
+#define SET_ARRAY_DIM(type,dim)                                              \
+   template<>                                                                \
+      void Attribut<Array<type,dim> >::setValue (const Array<type,dim>& val) \
+   { _hasValue = true ; value.resize(val.shape()); value = val ; }
+
+#define SET_ARRAY_TYPE(type) \
+   SET_ARRAY_DIM(type,1)     \
+   SET_ARRAY_DIM(type,2)     \
+   SET_ARRAY_DIM(type,3)     \
+   SET_ARRAY_DIM(type,4)
+
+   SET_ARRAY_TYPE(double)
+   SET_ARRAY_TYPE(int)
+   SET_ARRAY_TYPE(bool)
+
+   template <>
+      void Attribut<bool>::setFromString(const std::string& str)
+   {
+      istringstream iss(str) ;
+      bool val = (! iss.str().compare(string(".TRUE."))) ? true : false;
+      this->setValue(val);
+   }
+
+   template <>
+      void Attribut<string>::setFromString(const std::string& str)
+   { this->setValue(str); }
+
 } // namespace XMLIOSERVER
 
 #endif //__ATTRIBUT__
-
-

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

@@ -45 +45 @@
             for(unsigned int i = 0; i < _lattr.getVectorSize(); i++)
             {
-               if(_lattr.getVector()[i]->_hasValue() or !_pattr.getVector()[i]->_hasValue()) continue;
+               if(_lattr.getVector()[i]->hasValue() or !_pattr.getVector()[i]->hasValue()) continue;
                _lattr.getVector()[i]->assignValue(_pattr.getVector()[i]);
             }

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

@@ -1 +1 @@
 #ifndef __AXIS_ATTRIBUT__
 #define __AXIS_ATTRIBUT__
+
+using namespace blitz ;
 
 namespace XMLIOSERVER
@@ -11 +13 @@
          DECLARE_ATTR(description, string) ;
          DECLARE_ATTR(unit, string) ;
-         DECLARE_ATTR(size_axis, int) ;
+         DECLARE_ATTR(size, int) ;
+         DECLARE_ATTR(value, Array(double,1)) ;
 
          AxisAttribut(void) : AttributRegistrar()
@@ -23 +26 @@
             RegisterAttribut(&description) ;
             RegisterAttribut(&unit) ;
-            RegisterAttribut(&size_axis) ;
+            RegisterAttribut(&size) ;
+            RegisterAttribut(&value) ;
          }
 

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

@@ -24 +24 @@
 
          virtual void assignValue(const BaseAttribut*) = 0;
-         virtual void setFromString(const std::string str) = 0;
-         virtual bool _hasValue() const = 0;
+         virtual void setFromString(const std::string&) = 0;
+         virtual bool hasValue() const = 0;
 
 #define  SETTER_AND_GETTER(TYPE) \
@@ -32 +32 @@
          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,3>& value) const  { error_get() ; }\
+         virtual void getValue(Array<TYPE,4>& value) const  { error_get() ; }
 
          SETTER_AND_GETTER(int)

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

@@ -12 +12 @@
    try
    {
-      /*string file("/local/XMLIOSERVER_DEV/dev_rv/test/iodef_test.xml");
+      string file("/local/XMLIOSERVER_DEV/dev_rv/test/iodef_test.xml");
       //string file("/local/XMLIOSERVER_DEV/dev_rv/iodef_test.xml");
 
@@ -23 +23 @@
 
       // On résoud les héritages descendants ainsi que les héritages par référence.
-      Context::ResolveInheritance();*/
+      //Context::ResolveInheritance(); // Plus nécessaire!!
 
+      // On se place dans le contexte 'context1'.
+      Context::SetCurrentContext("context1") ;
+
+      // On crée une instance de traitement de données dans le format NetCDF4.
+      AbstractDataTreatment *dtreat = new NetCDF4DataTreatment(Context::GetObject("context1"));
+
+      // Affichage de la liste des fichiers à sortir (par id).
+      dtreat->printEnabledFilesId();
+
+      // On écrit l'arborescence résultante du traitement sur la sortie.
+      //Context::ShowTree(std::clog);
+
+      delete dtreat;
+
+   }
+   catch(const Exception &exc)
+   {  // Pour tout type d'exceptions, on note les informations sur la sortie paramétrée.
+      ERROR(exc.displayText());
+      // On retourne le code d'erreur en fin d'application pour traitements éventuels.
+      // return (exc.code());
+   }
+
+// return (0);
+}
+
+
+      /* CODE TEST POUR CALENDRIER
       AbstractCalendar* calendar = new GregorianCalendar();
+
       Date dd (*calendar, 2000, 05, 03, 00, 00, 00) ;
       Date ddd(*calendar, 2030, 11, 02, 10, 33, 40) ;
@@ -61 +89 @@
 
       delete calendar;
+      */
 
-      //On écrit l'arborescence résultante du traitement sur la sortie.
-      //Context::ShowTree(std::clog);
-
-   }
-   catch(const Exception &exc)
-   {  // Pour tout type d'exceptions, on note les informations sur la sortie paramétrée.
-      ERROR(exc.displayText());
-      // On retourne le code d'erreur en fin d'application pour traitements éventuels.
-      // return (exc.code());
-   }
-
-// return (0);
-}

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

@@ -9 +9 @@
          JulianCalendar() : AbstractCalendar("Julian")
          {/* Ne rien faire de plus */}
-         JulianCalendar(const string& dateStr) : AbstractCalendar("Julian", dateStr)
+         JulianCalendar(const string& _dateStr) : AbstractCalendar("Julian", _dateStr)
          {/* Ne rien faire de plus */}
 
-         virtual int getYearTotalLength(const Date& d) const
+         virtual int getYearTotalLength(const Date& _d) const
          { // Retourne la durée d'une année en seconde.
-            if (d.getYear()%4 == 0) return (366 * 86400);
+            if (_d.getYear()%4 == 0) return (366 * 86400);
             return (365 * 86400);
          }
 
-         virtual int getMonthLength(const Date& d) const
+         virtual int getMonthLength(const Date& _d) const
          { // Retourne la durée du mois en jour.
-            if (d.getMonth() == 2)
-            { if (d.getYear()%4 == 0) return 29; return 28; }
-            return AbstractCalendar::getMonthLength(d);
+            if (_d.getMonth() == 2)
+            { if (_d.getYear()%4 == 0) return 29; return 28; }
+            return (AbstractCalendar::getMonthLength(_d));
          }
 
@@ -49 +49 @@
             { // Traitement du cas particulier en Février.
                if ((d.getYear() % 4 == 0) && (d.getYear() % 100 != 0 || d.getYear() % 400 == 0))
-                  return 29;
-               return 28;
+                  return (29);
+               return (28);
             }
-            return AbstractCalendar::getMonthLength(d);
+            return (AbstractCalendar::getMonthLength(d));
          }
 
@@ -82 +82 @@
 
          virtual int getMonthLength(const Date& d) const
-         { if (d.getMonth() == 2) return (29); return AbstractCalendar::getMonthLength(d); }
+         { if (d.getMonth() == 2) return (29); return (AbstractCalendar::getMonthLength(d)); }
 
          virtual int getYearTotalLength(const Date& d) const { return (366 * 86400); }

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

@@ -1 +1 @@
 #ifndef __XMLIO_CONTAINER__
 #define __XMLIO_CONTAINER__
-
-// Classes utilisées issues de Poco
-using Poco::HashMap;
-using Poco::Hash;
 
 // Classes utilisées issues de la STL
@@ -12 +8 @@
 using std::ostream;
 
-// Classes XMLIOSERVER
-using XMLIOSERVER::XMLIOUndefinedValueException;
-
 namespace XMLIOSERVER
 {
-   template<class Key, class Mapped, class HashFunc = Hash<Key> >
+   template<class Key, class Mapped, class HashFunc = Poco::Hash<Key> >
       class ExHashMap
-         : private HashMap<Key, Mapped*, Hash<Key> >
+         : private Poco::HashMap<Key, Mapped*, Poco::Hash<Key> >
    {
       public :
-
-         ExHashMap() :  HashMap<Key, Mapped*, Hash<Key> >(), _elemList()
-         {/* Ne rien faire de plus */}
 
          Mapped* operator[] (const Key& kval) throw (XMLIOUndefinedValueException)
          {
             if(!hasMappedValue(kval))
-               throw XMLIOUndefinedValueException("Appel de la méthode ExHashMap::operator["+kval+"] invalide.");
+               throw XMLIOSERVER::XMLIOUndefinedValueException("Appel de la méthode ExHashMap::operator["+kval+"] invalide.");
             return (find(kval)->second);
          }
@@ -44 +34 @@
 
       protected :
+
+         ExHashMap() :  Poco::HashMap<Key, Mapped*, Poco::Hash<Key> >(), _elemList()
+         {/* Ne rien faire de plus */}
 
          bool addValue(const Key& kval, Mapped* element)
@@ -77 +70 @@
    template<class Mapped>
       class StrHashMap
-         : public ExHashMap<string, Mapped, Hash<string> >
+         : public ExHashMap<string, Mapped, Poco::Hash<string> >
    {
       public :
 
-         StrHashMap() :  ExHashMap<string, Mapped, Hash<string> >()
+         StrHashMap() :  ExHashMap<string, Mapped, Poco::Hash<string> >()
          {/* Ne rien faire de plus */}
 
          bool addObject(Mapped* element)
-         { if(element->hasId()) return(addValue(element->getId(), element));   return(addValue(element)); }
+         { if(element->hasId()) return(addValue(element->getId(), element)); return(addValue(element)); }
 
          bool removeObject(const string& kval)
          {
-            if(!ExHashMap<string, Mapped, Hash<string> >::hasMappedValue(kval)) return (false);
-            ExHashMap<string, Mapped, Hash<string> >::removeValue(kval); return (true);
+            if(!ExHashMap<string, Mapped, Poco::Hash<string> >::hasMappedValue(kval)) return (false);
+            ExHashMap<string, Mapped, Poco::Hash<string> >::removeValue(kval); return (true);
          }
 

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

@@ -22 +22 @@
             os << NIndent << "<"<< Context::GetRootName() << ">" << std::endl;
 
-            HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
-            for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
+            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; }
@@ -32 +32 @@
          static void FreeMemory(void)
          {
-            HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
-            for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
+            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)
          {
-            HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
-            for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
+            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.
@@ -58 +59 @@
 
             // Changement de context pour les champs et groupes de champs.
-            FieldGroup::SetContext(id);
-            CField::SetContext(id);
+            FieldGroup::SetContext(id); CField::SetContext(id);
 
             // Changement de context pour les fichiers et groupes de fichiers.
-            FileGroup::SetContext(id);
-            CFile::SetContext(id);
+            FileGroup::SetContext(id);  CFile::SetContext(id);
 
             // Changement de context pour les grilles et groupes de grilles.
-            GridGroup::SetContext(id);
-            CGrid::SetContext(id);
+            GridGroup::SetContext(id);  CGrid::SetContext(id);
 
             // Changement de context pour les axes et groupes d'axes.
-            AxisGroup::SetContext(id);
-            CAxis::SetContext(id);
+            AxisGroup::SetContext(id);  CAxis::SetContext(id);
          }
 
@@ -107 +104 @@
                   { gridDef  = CreateInstanceAndParse<GridDefinition >(_node, GridDefinition ::GetDefName().c_str()); continue; }
 
-                  WARNING("La définition est invalide, seules les champs, grilles, axes et fichiers peuvent être définis !");
+                  WARNING("La définition est invalide, seuls les champs, grilles, axes et fichiers peuvent être définis !");
 
                } while (_node.goToNextElement());
@@ -115 +112 @@
          }
 
-         static string GetName(void) {return ("context"); }
-         static string GetRootName(void) {return ("simulation"); }
+         static string GetName(void)     { return ("context"); }
+         static string GetRootName(void) { return ("simulation"); }
 
          virtual bool hasChild(void) const
@@ -129 +126 @@
          }
 
-         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0)
+         virtual void resolveDescInheritance(const AttributRegistrar* const _parent = 0)
          {
             if (_parent != 0) return;
@@ -145 +142 @@
 
          AbstractCalendar * getCalendar(void) const { return (this->ccalendar ); }
-         AbstractCalendar * setCalendar(const string& _calName, const string& dateStr)
+         AbstractCalendar * setCalendar(const string& _calName, const string& _dateStr)
          {
             if (_calName.compare("D360")      == 0)
-               return (ccalendar = new D360Calendar(dateStr));
+               return (ccalendar = new D360Calendar(_dateStr));
             if (_calName.compare("AllLeap")   == 0)
-               return (ccalendar = new AllLeapCalendar(dateStr));
+               return (ccalendar = new AllLeapCalendar(_dateStr));
             if (_calName.compare("NoLeap")    == 0)
-               return (ccalendar = new NoLeapCalendar(dateStr));
+               return (ccalendar = new NoLeapCalendar(_dateStr));
             if (_calName.compare("Julian")    == 0)
-               return (ccalendar = new JulianCalendar(dateStr));
+               return (ccalendar = new JulianCalendar(_dateStr));
             if (_calName.compare("Gregorian") == 0)
-               return (ccalendar = new GregorianCalendar(dateStr));
+               return (ccalendar = new GregorianCalendar(_dateStr));
 
             WARNING("L'identifiant "+_calName+" est inconnu, le calendrier grégorien sera choisi par défault pour le contexte "+getId());
 
-            return (ccalendar = new GregorianCalendar(dateStr));
+            return (ccalendar = new GregorianCalendar(_dateStr));
          }
 
@@ -166 +163 @@
          {
             // Désallocation dynamique de mémoire pour chacun des groupes de définition si nécessaire.
-            if(fieldDef != NULL) delete fieldDef;
-            if(fileDef  != NULL) delete fileDef;
-            if(axisDef  != NULL) delete axisDef;
-            if(gridDef  != NULL) delete gridDef;
+            if(fieldDef != NULL) delete fieldDef; if(fileDef  != NULL) delete fileDef ;
+            if(axisDef  != NULL) delete axisDef ; if(gridDef  != NULL) delete gridDef ;
+
             // Désallocation dynamique de mémoire pour le calendrier associé au contexte courant si nécessaire.
             if(ccalendar !=  NULL) delete ccalendar;

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

@@ -27 +27 @@
          friend std::ostream& operator<<(std::ostream& out, const Date& d)
          {
-            out << d.day  << "/" << d.month  << "/" << d.year   << "-"
-                << d.hour << ":" << d.minute << ":" << d.second;
+            out << d.day  << '/' << d.month  << '/' << d.year   << '-'
+                << d.hour << ':' << d.minute << ':' << d.second;
             return (out);
          }
@@ -60 +60 @@
             if (month == 0 ) { year--; month = 12; }
          }
+
          void setYear  (int newyear)  { year  = newyear; }
 

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

@@ -3 +3 @@
 
 #include "attribut.hpp"
+
+#define Array(x,y) Array<x,y>
 
 #define DECLARE_ATTR(att_name,att_type)               \

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

@@ -7 +7 @@
 namespace XMLIOSERVER
 {
+   class CGrid; // CGRID = CDOMAINE + CAXIS
+
    class CField : public ObjectTemplate<CField>, public FieldAttribut
    {
       public:
 
-         CField(void) : ObjectTemplate<CField>(), FieldAttribut()
+         CField(void) : ObjectTemplate<CField>(), FieldAttribut(), grid(NULL)
          {/* Ne rien faire de plus */}
-         CField(const string& _id) : ObjectTemplate<CField>(_id), FieldAttribut()
+         CField(const string& _id) : ObjectTemplate<CField>(_id), FieldAttribut(), grid(NULL)
          {/* Ne rien faire de plus */}
 
          static string GetName(void) {return ("field"); }
 
+         inline void SolveGridRef(void) ;
+
+         CGrid* getGrid(void) const { return (grid); }
+
          virtual CField* getReference(void) const
          {
-            if(!field_ref._hasValue()) return (NULL);
+            if(!field_ref.hasValue()) return (NULL);
             if (!CField::HasObject(field_ref))
             { WARNING("Référence invalide sur l'objet "+GetName()+" nommé \""+((string)field_ref)+"\""); return (NULL);}
 
-            return (&CField::GetObject(field_ref));
+            return (CField::GetObject(field_ref));
          }
 
          virtual ~CField(void)
          { /* Ne rien faire de plus */ }
+
+      private :
+
+         CGrid* grid ;
 
    }; // class CField

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

@@ -19 +19 @@
          DECLARE_ATTR(enabled, bool);
 
+         DECLARE_ATTR(domain_ref, string);
          DECLARE_ATTR(axis_ref, string);
-         DECLARE_ATTR(grid_ref, string);
+         DECLARE_ATTR(grid_ref, string) ;
          DECLARE_ATTR(zoom_ref, string);
          DECLARE_ATTR(field_ref, string);
@@ -41 +42 @@
             RegisterAttribut(&enabled);
 
+            RegisterAttribut(&domain_ref);
             RegisterAttribut(&axis_ref);
             RegisterAttribut(&grid_ref);

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

@@ -11 +11 @@
       public:
 
-         CFile(void) : ObjectTemplate<CFile>(), FileAttribut(), vfieldGroup(NULL)
+         CFile(void) : ObjectTemplate<CFile>(), FileAttribut(), vfieldGroup(NULL), enabledFields()
          {/* Ne rien faire de plus */}
-         CFile(const string& _id) : ObjectTemplate<CFile>(_id), FileAttribut(), vfieldGroup(NULL)
+         CFile(const string& _id) : ObjectTemplate<CFile>(_id), FileAttribut(), vfieldGroup(NULL), enabledFields()
          {/* Ne rien faire de plus */}
 
@@ -37 +37 @@
 
          void getAllFields(std::vector<CField*>& _allF) const {  if (vfieldGroup!=NULL) vfieldGroup->getAllChildren(_allF); }
+
          virtual bool hasChild(void) const { return (vfieldGroup != NULL); }
+
          virtual void printChild(ostream& out) const { out << *vfieldGroup << std::endl; }
          /*{ // Sortie sans affichage des groupes.
@@ -44 +46 @@
                out << *(allF[i]) << std::endl;
          }*/
+
          virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0)
          { addAttributes(*_parent); if(vfieldGroup != NULL) vfieldGroup->resolveDescInheritance(); }
@@ -55 +58 @@
          FieldGroup* getVirtualFieldGroup(void) { return (vfieldGroup); }
 
+         void findEnabledFields(int default_outputlevel = 5, int default_level = 1, bool default_enabled = true )
+         {
+            const int _outputlevel = (output_level.hasValue()) ? (int)output_level : default_outputlevel;
+            std::vector<CField*>::iterator it;
+
+            getAllFields(enabledFields);
+
+            for ( it = enabledFields.begin() ; it < enabledFields.end(); it++ )
+            {
+               if ((*it)->enabled.hasValue()) // Si l'attribut 'enabled' est défini ...
+               {
+                  if (! ((*it)->enabled))
+                  { enabledFields.erase(it); continue; }
+               }
+               else // Si l'attribut 'enabled' n'est pas défini ...
+               {
+                  if (!default_enabled)
+                  { enabledFields.erase(it); continue; }
+               }
+
+               if ((*it)->level.hasValue()) // Si l'attribut 'level' est défini ...
+               {
+                  if ((*it)->level > _outputlevel)
+                  { enabledFields.erase(it); continue; }
+               }
+               else // Si l'attribut 'level' n'est pas défini ...
+               {
+                  if (default_level > _outputlevel)
+                  { enabledFields.erase(it); continue; }
+               }
+
+            }
+         }
+
          virtual  ~CFile(void)
          { if(vfieldGroup != NULL) delete vfieldGroup; }
@@ -61 +98 @@
 
          FieldGroup* vfieldGroup; // FieldGroup "virtuel"
+         std::vector<CField*> enabledFields;
 
    }; // class CFile

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

@@ -7 +7 @@
 namespace XMLIOSERVER
 {
-   class CGrid: public ObjectTemplate<CGrid>, public GridAttribut
+   class CGrid : public ObjectTemplate<CGrid>, public GridAttribut
    {
       public:
 
-         CGrid(void) : ObjectTemplate<CGrid>(), GridAttribut()
-         {/* Ne rien faire de plus */}
-         CGrid(const string& _id) : ObjectTemplate<CGrid>(_id), GridAttribut()
-         {/* Ne rien faire de plus */}
+         CGrid(void) : ObjectTemplate<CGrid>(), GridAttribut(), hasAxis(false), axis(NULL), domain(NULL)
+         { /* Ne rien faire de plus */ }
+         CGrid(const string& _id) : ObjectTemplate<CGrid>(_id), GridAttribut(), hasAxis(false), axis(NULL), domain(NULL)
+         { /* Ne rien faire de plus */ }
 
          static string GetName(void) { return ("grid"); }
+
+         inline void solveReference(void) ;
+         inline void solveDomainRef(void) ;
+         inline void solveAxisRef(void) ;
+
+         inline void computeIndex(void);
+
+         inline void storeField(const Array<double,1>& field, Array<double,1>& stored);
+         inline void storeField(const Array<double,2>& field, Array<double,1>& stored);
+         inline void storeField(const Array<double,3>& field, Array<double,1>& stored);
+         inline void storeField(const double* const data, Array<double,1>& stored);
+
+         inline void outputField(const Array<double,1>& stored, Array<double,2>& outField);
+         inline void outputField(const Array<double,1>& stored, Array<double,3>& outField);
+
+         inline static CGrid* CreateObject(const CDomain* const a_domain, const CAxis* const a_axis);
+         inline static CGrid* CreateObject(const CDomain* const a_domain);
 
          virtual ~CGrid(void)
          { /* Ne rien faire de plus */ }
 
+
+      private:
+
+         bool hasAxis ;
+
+         CAxis* axis ;
+         CDomain* domain ;
+
+         Array<int,1> storeIndex ;
+         Array<int,1> out_i_index ;
+         Array<int,1> out_j_index ;
+         Array<int,1> out_l_index ;
+
    }; // class CGrid
 
+
+   CGrid* CGrid::CreateObject(const CDomain* const a_domain, const CAxis* const a_axis)
+   {
+      string new_id = string("___") + a_domain->getId() + string("_") + a_axis->getId() + string("__") ;
+      CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;
+
+      grid->domain_ref = a_domain->getId() ;
+      grid->axis_ref = a_axis->getId() ;
+
+      return (grid);
+   }
+
+   CGrid* CGrid::CreateObject(const CDomain* const a_domain)
+   {
+      string new_id = string("___") + a_domain->getId() + string("__") ;
+      CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;
+
+      grid->domain_ref = a_domain->getId() ;
+
+      return (grid);
+   }
+
+   void CGrid::solveReference(void)
+   {
+      static bool isReferenceSolved = false;
+      if (isReferenceSolved) return;
+
+      // Résolution de chacune des références et indexation.
+      solveDomainRef() ;
+      solveAxisRef() ;
+      computeIndex() ;
+
+      isReferenceSolved = true ;
+   }
+
+   void CGrid::solveDomainRef(void)
+   {
+      if (domain_ref.hasValue())
+      {
+         if (CDomain::HasObject(domain_ref))
+         {
+           domain=CDomain::GetObject(domain_ref) ;
+           domain->check() ;
+         }
+         else ERROR("Référence au domaine incorrecte") ;
+      }
+      else ERROR("Domaine non défini") ;
+   }
+
+   void CGrid::solveAxisRef(void)
+   {
+      if (axis_ref.hasValue())
+      {
+         hasAxis = true ;
+         if (CAxis::HasObject(axis_ref)) axis = CAxis::GetObject(axis_ref) ;
+         else ERROR("Référence a l'axe incorrecte") ;
+      }
+      else hasAxis = false ; // hasAxis est normalement déjà à false(?).
+   }
+
+   void CGrid::computeIndex(void)
+   {
+      int ni = domain->ni ;
+      int nj = domain->nj ;
+      int size = (hasAxis) ? (int)axis->size : 1 ;
+      int data_dim = domain->data_dim ;
+      int data_n_index = domain->data_n_index ;
+      int data_ibegin  = domain->data_ibegin ;
+      int data_jbegin  = (data_dim == 2) ? (int)domain->data_jbegin : -1;
+
+      Array<int,1>& data_i_index =* domain->data_i_index ;
+      Array<int,1>& data_j_index =* domain->data_j_index ;
+      Array<bool,2>& mask =* domain->mask ;
+      int i, j, l, n ;
+      int count, indexCount ;
+
+      for(indexCount=0, l=0; l<size ; l++)
+      {
+         for(n=0, indexCount=0; n<data_n_index; n++)
+         {
+            if (data_dim == 1)
+            {
+               i = (data_i_index(n) + data_ibegin) % ni ;
+               j = (data_i_index(n) + data_ibegin) / ni ;
+               cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
+            }
+            else
+            {
+               i = data_i_index(n) + data_ibegin ;
+               j = data_j_index(n) + data_jbegin ;
+               cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
+            }
+
+            if (i>=0 && i<ni && j>=0 && j<nj && mask(i,j) ) indexCount++ ;
+         }
+      }
+
+      storeIndex.resize(indexCount) ;
+      out_l_index.resize(indexCount) ;
+      out_i_index.resize(indexCount) ;
+      out_j_index.resize(indexCount) ;
+
+      for(count=0, indexCount=0, l=0; l<size; l++)
+      {
+         for(n=0; n<data_n_index; n++)
+         {
+            if (data_dim == 1)
+            {
+               i = (data_i_index(n) + data_ibegin) % ni ;
+               j = (data_i_index(n) + data_ibegin) / ni ;
+            }
+            else
+            {
+               i = data_i_index(n) + data_ibegin ;
+               j = data_j_index(n) + data_jbegin ;
+            }
+
+            if (i>=0 && i<ni && j>=0 && j<nj && mask(i,j))
+            {
+               storeIndex(indexCount) = n ;
+               out_l_index(indexCount) = l ;
+               out_i_index(indexCount) = i ;
+               out_j_index(indexCount) = j ;
+               indexCount++ ;
+            }
+            count++ ;
+         }
+      }
+
+      cout << "Out of CGrid::ComputeIndex" << endl ;
+      cout << storeIndex << endl ;
+      cout << out_i_index << endl ;
+      cout << out_j_index << endl ;
+      cout << out_l_index << endl ;
+   }
+
+   void CGrid::storeField(const Array<double, 1>& field, Array<double, 1>& stored)
+   {
+      storeField(field.dataFirst(), stored) ;
+      //cout<<"Stored 1"<<stored<<endl ;
+   }
+
+   void CGrid::storeField(const Array<double, 2>& field, Array<double, 1>& stored)
+   {
+      storeField(field.dataFirst(), stored) ;
+      //cout<<"Stored 2"<<stored<<endl ;
+   }
+
+   void CGrid::storeField(const Array<double, 3>& field, Array<double, 1>& stored)
+   {
+      storeField(field.dataFirst(), stored) ;
+      //cout<<"Stored 3"<<stored<<endl ;
+   }
+
+   void CGrid::storeField(const double* const data, Array<double, 1>& stored)
+   {
+      int size = storeIndex.size() ;
+      //cout << "size " << size << endl ;
+
+      stored.resize(shape(size)) ;
+      //cout << "Stored " << stored << endl ;
+
+      for(int i = 0; i < size; i++) stored(i) = data[storeIndex(i)] ;
+      //cout << "Stored " << stored << endl ;
+   }
+
+   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 2>& outField)
+   {
+      for(int n = 0; n < storeIndex.size(); n++)
+         outField(out_i_index(n), out_j_index(n)) = stored(n) ;
+   }
+
+   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 3>& outField)
+   {
+      for(int n = 0; n < storeIndex.size(); n++)
+         outField(out_i_index(n), out_j_index(n), out_l_index(n)) = stored(n) ;
+   }
 } // namespace XMLIOSERVER
 
+
 DECLARE_GROUP(Grid)
 
+
+
 #endif // __GRID__
 

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

@@ -10 +10 @@
          DECLARE_ATTR(name, string) ;
          DECLARE_ATTR(description, string) ;
+         DECLARE_ATTR(domain_ref, string) ;
+         DECLARE_ATTR(axis_ref, string) ; 
 
          GridAttribut(void) : AttributRegistrar()
@@ -20 +22 @@
             RegisterAttribut(&name) ;
             RegisterAttribut(&description) ;
+            RegisterAttribut(&domain_ref) ;
+            RegisterAttribut(&axis_ref) ;
          }
 

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

@@ -41 +41 @@
             // on complÚte les attributs des enfants.
                childvect[i] -> resolveDescInheritance(this);
+
             for(unsigned int i = 0; i < groupvect.size() ; i++)
             // on complÚte les attributs des groupes enfants.
@@ -48 +49 @@
          GroupTemplate<T, U>& createGroup(const string& _id) throw (XMLIOUndefinedValueException)
          {
-            GroupTemplate<T, U> &obj = GroupTemplate<T, U>::CreateObject(_id);
+            GroupTemplate<T, U> &obj = *GroupTemplate<T, U>::CreateObject(_id);
             groupList.addObject(&obj);
 
@@ -56 +57 @@
          GroupTemplate<T, U>& createGroup(void)
          {
-            GroupTemplate<T, U>& obj = GroupTemplate<T, U>::CreateObject();
+            GroupTemplate<T, U>& obj = *(GroupTemplate<T, U>::CreateObject());
             groupList.addObject(&obj);
 
@@ -73 +74 @@
          T& createChild(const string& _id) throw (XMLIOUndefinedValueException)
          {
-            T& obj = ObjectTemplate<T>::CreateObject(_id);
+            T& obj = *ObjectTemplate<T>::CreateObject(_id);
             childList.addObject(&obj);
             return (obj);
@@ -80 +81 @@
          T& createChild(void)
          {
-            T& obj = ObjectTemplate<T>::CreateObject();
+            T& obj = *ObjectTemplate<T>::CreateObject();
             childList.addObject(&obj);
             return (obj);

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

@@ -48 +48 @@
          }
 
-
          static void ShowBTrace(std::ostream& out = std::clog)
          {
@@ -94 +93 @@
 
    // Initialisation de la classe de Logging
-   static ILogger LOGGER;
+   ILogger LOGGER;
 
    /////////////////////////////////////////////////////////////////////
-   static unsigned int Indent = 0;
-   static const char*  Increm = "   ";
+   unsigned int Indent = 0;
+   const char*  Increm = "   ";
 
    std::ostream& NIndent(std::ostream& out)

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 << "<-- Reference resolved for the following "+ T::GetName() +
+                       " : \"" << c.baseObject->getId() << "\" -->" << DecEndl << std::endl;
 
             if (c.hasChild())
@@ -48 +49 @@
 
          virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0) { addAttributes(*_parent); }
-         virtual void resolveRefInheritance(void)
+         virtual void resolveRefInheritance (void)
          {
             std::set<T*> sset;
@@ -76 +77 @@
          }
 
-         static T& CreateObject(const string& _id) throw (XMLIOUndefinedValueException)
+         static T* CreateObject(const string& _id) throw (XMLIOUndefinedValueException)
          {
             // Si l'identifiant est répertorié, on retourne l'élément existant.
@@ -88 +89 @@
          }
 
-         static T& CreateObject(void)
+         static T* CreateObject(void)
          {
             T* value = new T;
             ObjectTemplate<T>::AllListObj[CurrContext].addObject(value);
-            return (*value);
+            return (value);
          }
 
-         static T& GetObject(const string& _id) throw (XMLIOUndefinedValueException)
-         { return (*ObjectTemplate<T>::AllListObj[CurrContext][_id]); }
+         static T* GetObject(const string& _id) throw (XMLIOUndefinedValueException)
+         { return (ObjectTemplate<T>::AllListObj[CurrContext][_id]); }
 
          static bool HasObject(const string& _id)
@@ -105 +106 @@
 
          static const StrHashMap<T>& GetCurrentListObject(void) { return (AllListObj[CurrContext]); }
-         static HashMap<string, StrHashMap<T> >& GetAllListObject(void) { return (AllListObj); }
+         static Poco::HashMap<string, StrHashMap<T> >& GetAllListObject(void) { return (AllListObj); }
 
          static void SetContext(const string& id){ ObjectTemplate<T>::CurrContext = id; }
@@ -134 +135 @@
                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!");
-               instance_ptr = (V*)&V::CreateObject(did);
+               instance_ptr = (V*)V::CreateObject(did);
                instance_ptr->parse(_node, parseAttr);
             }
@@ -144 +145 @@
 
          static string CurrContext;
-         static HashMap<string, StrHashMap<T> > AllListObj;
+         static Poco::HashMap<string, StrHashMap<T> > AllListObj;
 
    };// class ObjectTemplate
 
    template <class T> string ObjectTemplate<T>::CurrContext ;
-   template <class T> HashMap<string, StrHashMap<T> > ObjectTemplate<T>::AllListObj;
+   template <class T> Poco::HashMap<string, StrHashMap<T> > ObjectTemplate<T>::AllListObj;
 
 }// namespace XMLIOSERVER

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

@@ -2 +2 @@
 #define __XMLIO_XML_NODE__
 
-// Entêtes Poco DOM
-#include <Poco/DOM/DOMParser.h>
-#include <Poco/DOM/Document.h>
-#include <Poco/DOM/Element.h>
-
-#include <Poco/DOM/NamedNodeMap.h>
-
-#include <Poco/DOM/AutoPtr.h>
-
-// Entêtes Poco SAX.
-#include <Poco/SAX/InputSource.h>
-
-// Utilisation de la STL.
-using std::string;
-
-using std::pair;
-using std::vector;
-
-using std::istream;
-using std::ostream;
-using std::ostringstream;
-using std::ifstream;
-
-// Utilisation de la biliothÚque POCO.
-using Poco::XML::DOMParser;
-using Poco::XML::InputSource;
-
-using Poco::XML::Document;
-using Poco::XML::Node;
-using Poco::XML::Element;
-
-using Poco::XML::NamedNodeMap;
-
-using Poco::HashMap;
-
-using Poco::XML::AutoPtr;
 
 namespace XMLIOSERVER
@@ -43 +7 @@
    namespace XML
    {
-
-      typedef HashMap<string, string> THashAttributes;
+      typedef Poco::HashMap<std::string, std::string> THashAttributes;
 
       class XMLNode
@@ -50 +13 @@
          public :
 
-            XMLNode(const string& _rootName) : rootName(_rootName)
-            { /* Ne rien faire de plus */}
-
-            static XMLNode CreateNode(istream& _istr, const string& _rootName)
+            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 ...
-                  InputSource src(_istr);
-                  DOMParser parser;
+
+                  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)
+                  if (node.getElementName().compare(_rootName) != 0) // << A passer en avertissement.
                      throw XMLParsingException("L'élément racine doit avoir pour valeur <" + _rootName + "> (\"" + node.getElementName() + "\" lue)");
                }
@@ -73 +35 @@
 
             string getElementName(void) const
-            { string _str(this->getCNode()->nodeName()); return (_toLower(_str)); }
+            {
+               std::string _str(this->getCNode()->nodeName());
+               return (_toLower(_str));
+            }
 
             bool goToNextElement(void)
             {
-               Node* nextElement = this->getCNode()->nextSibling();
+               Poco::XML::Node* nextElement = this->getCNode()->nextSibling();
 
                // On parcourt la liste des "siblings" jusqu'à trouver un élément quelconque.
@@ -92 +57 @@
             bool goToChildElement(void)
             {
-               Node* nextElement = this->getCNode()->firstChild();
+               Poco::XML::Node* nextElement = this->getCNode()->firstChild();
 
                // On parcourt la liste des enfants jusqu'à trouver un élément quelconque.
@@ -98 +63 @@
                {
                   for(; ; nextElement = nextElement->nextSibling())
-                     if (IsPtrNull(nextElement)) break;
+                     if (IsPtrNull(nextElement)) return (false);
                      else if (nextElement->nodeType() == 1)
                      {// Si l'un des noeuds est un élément...
@@ -104 +69 @@
                         return (true);
                      }
-                  return (false);
                }
-
                return (false);
             }
@@ -118 +81 @@
             }
 
-            bool getAttributes(THashAttributes& attributes) const
+            bool getAttributes(THashAttributes& _attributes) const
             {
                if(!this->getCNode()->hasAttributes()) return (false);
-               AutoPtr<NamedNodeMap> map = this->getCNode()->attributes();
+               Poco::XML::AutoPtr<Poco::XML::NamedNodeMap> map = this->getCNode()->attributes();
 
                for(unsigned int i = 0; i< map->length(); i++)
                { // Suppression des espaces en début et fin de valeur d'attribut xml.
-                  string _str(map->item(i)->nodeName());
+                  std::string _str(map->item(i)->nodeName());
                   size_t d = map->item(i)->nodeValue().find_first_not_of(' ');
                   size_t f = map->item(i)->nodeValue().find_last_not_of (' ');
-                  attributes[_toLower(_str)] = map->item(i)->nodeValue().substr(d,f-d+1);
+
+                  _attributes[_toLower(_str)] = map->item(i)->nodeValue().substr(d,f-d+1);
                }
                return (true);
@@ -138 +102 @@
          protected :
 
-            Node* getCNode(void) const { return (this->cNode); }
-            void setCNode(Node* other) { this->cNode = other; }
+            Poco::XML::Node * getCNode(void) const { return (this->cNode); }
+            void setCNode(Poco::XML::Node * _otherNode) { this->cNode = _otherNode; }
 
-            static bool IsPtrNull(Node* ptr) { return (ptr==NULL); }
+            static bool IsPtrNull(const Poco::XML::Node * const _ptr) { return (_ptr == NULL); }
 
          private :
 
-            const string& _toLower(string& _str) const
+            XMLNode(const std::string& _rootName) : rootName(_rootName)
+            { /* Ne rien faire de plus */}
+
+            const string& _toLower(std::string& _str) const
             {
                for (unsigned int i = 0; i < _str.size(); i++)
@@ -152 +119 @@
             }
 
-            AutoPtr<Document> pDoc;
-            Node*  cNode;
+            Poco::XML::AutoPtr<Poco::XML::Document> pDoc;
+            Poco::XML::Node*  cNode;
 
             string rootName;

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

@@ -35 +35 @@
 
                   Context::SetCurrentContext(attributes["id"]);
-                  Context& context = Context::CreateObject(attributes["id"]);
+                  Context& context = *Context::CreateObject(attributes["id"]);
 
                   context.parse(_node);

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

@@ -17 +17 @@
 #include <Poco/HashMap.h>
 #include <Poco/Hash.h>
+
+// Entêtes Poco DOM
+#include <Poco/DOM/DOMParser.h>
+#include <Poco/DOM/Document.h>
+#include <Poco/DOM/Element.h>
+
+#include <Poco/DOM/NamedNodeMap.h>
+
+#include <Poco/DOM/AutoPtr.h>
+
+// Entêtes Poco SAX.
+#include <Poco/SAX/InputSource.h>
 
 /// Entête Blitz array ///
@@ -40 +52 @@
 #include "grid_attribut.hpp"
 #include "axis_attribut.hpp"
+#include "domain_attribut.hpp"
 #include "field_attribut.hpp"
 #include "file_attribut.hpp"
@@ -46 +59 @@
 #include "declare_group.hpp"
 
-// Prise en charge des champs...
+// Prise en charge des champs, fichiers, axes, domaines, grilles ...
 #include "field.hpp"
-// Prise en charge des fichiers ...
 #include "file.hpp"
-// Prise en charge des axes ...
 #include "axis.hpp"
-// Prise en charge des grilles ...
+#include "domain.hpp"
 #include "grid.hpp"
+
+#include "field_gridrefsolver.hpp"
 
 #include "context.hpp"
 #include "xml_parser.hpp"
 
+#include "abstract_data_treatment.hpp"
+#include "NetCDF4_data_treatment.hpp"
+
 #endif // __XMLIO__