Index: /XMLIO_V2/dev/dev_rv/README
===================================================================
--- /XMLIO_V2/dev/dev_rv/README	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/README	(revision 88)
@@ -0,0 +1,9 @@
+ ============================== README ==============================
+
+Ceci est une version expÃ©rimentale non fonctionnelle et non documentÃ©e.
+
+* Certaines classes et fonctionnalitÃ© sont prÃ©sentes pour effectuer des tests.
+* Les classes de gestion des grilles, des fichiers et des axes ne sont pas prÃ©sents dans cete version.
+* Le rÃ©pertoire old disparaitera dans les versions ultÃ©rieures.
+
+<<commit pour sauvegarde uniquement>>
Index: /XMLIO_V2/dev/dev_rv/attribut.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/attribut.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/attribut.hpp	(revision 88)
@@ -0,0 +1,103 @@
+#ifndef __ATTRIBUT__
+#define __ATTRIBUT__
+
+#include "base_attribut.hpp"
+
+using XMLIOSERVER::BaseAttribut;
+using XMLIOSERVER::XMLIOUndefinedValueException;
+using std::ostringstream;
+
+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 :
+     
+         bool hasValue ;
+         Ctype value ;
+
+         virtual const char * getName(void) const = 0 ;
+      
+         Attribut(void) : hasValue(false) {} ;
+         Attribut(const Ctype& value_) : value(value_), hasValue(true) {} ;
+         
+         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 ; 
+         }
+     
+         virtual const char * getType(void) const = 0;
+     
+         virtual void setFromString(const std::string str) 
+         {    
+            IStringStream_alt iss(str); Ctype val;
+            iss >> val;
+            this->setValue(val);
+         }   
+
+         operator Ctype()
+         {
+            if (!hasValue)
+            {
+               ostringstream oss;
+               oss << "CAttribut& CAttribut<Ctype>::operator Ctype , access to undefined value of attribut <<" << this->getName() <<">>";
+                                                                          
+               throw XMLIOUndefinedValueException(oss.str());
+            }
+            return value ;
+         }
+
+         virtual ostream& print(ostream & o) const
+         {
+            o<<"Attribut : "<<getName()<<"  ---->" ;
+            if (hasValue) o<< boolalpha <<" value = "<< value ;
+            else o<< "/" ;
+            return o ;
+         }
+
+         virtual void setValue(const Ctype & value_)
+         { hasValue=true ; value=value_ ; }
+
+         virtual void getValue(Ctype & value_) const
+         {
+            if (!hasValue)
+            {
+               ostringstream oss;
+               oss << "CAttribut& CAttribut<Ctype>::operator Ctype , access to undefined value of attribut <<" << this->getName() <<">>";
+                                                                          
+               throw XMLIOUndefinedValueException(oss.str());
+            }
+            value_=value ;
+         }
+
+   }; // class Attribut 
+}; // namespace XMLIOSERVER
+  
+#endif //__ATTRIBUT__
Index: /XMLIO_V2/dev/dev_rv/attribut_registrar.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/attribut_registrar.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/attribut_registrar.hpp	(revision 88)
@@ -0,0 +1,49 @@
+#ifndef __ATTRIBUT_REGISTRAR__
+#define __ATTRIBUT_REGISTRAR__
+
+#include "attribut.hpp"
+
+namespace XMLIOSERVER
+{
+   class AttributRegistrar
+   {
+      public :
+        
+         AttributRegistrar():attrList()
+         {/* Ne rien faire de plus */}
+      
+         void RegisterAttribut(BaseAttribut* attribut){ attrList.addPtrObject(attribut); }         
+         StrHashMap<BaseAttribut*>& getAttributList(void) { return (attrList); }         
+         size_t getNbAttributes() const {return (attrList.getSize()); }
+         bool hasAttribut(const string _id) { return (attrList.hasMappedValue(_id)); }
+         
+         BaseAttribut* getAttribut(const string _id) throw (XMLIOUndefinedValueException) { return (attrList[_id]); }
+        
+         void setSAttribut(const string& att_name, const std::string& value)
+         {
+            //std::cout << "Attribut :" <<  att_name<< ", " << value<< std::endl;
+
+            if (hasAttribut(att_name))
+            { getAttribut(att_name)->setFromString(value) ; }
+            else
+            {
+               ostringstream oss;
+               oss << "CAttributRegistrar::setAttribut<ValueType>, could not find <<"<<att_name<<">> attribut in registred list" <<">>";
+               throw XMLIOUndefinedValueException(oss.str());
+            }
+          
+         }
+              
+         ostream & PrintAttribut(ostream& o) {o << "A rÃ©implÃ©menter"; return o ;}
+         
+        ~AttributRegistrar(void)
+        {/* Ne rien faire de plus */}
+        
+      private :
+         StrHashMap<BaseAttribut*> attrList;
+        
+   }; // class AttributRegistrar  
+}; // namespace XMLIOSERVER
+
+
+#endif //__ATTRIBUT_REGISTRAR__
Index: /XMLIO_V2/dev/dev_rv/base_attribut.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/base_attribut.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/base_attribut.hpp	(revision 88)
@@ -0,0 +1,94 @@
+#ifndef __BASE_ATTRIBUT__
+#define __BASE_ATTRIBUT__
+
+using std::ostream;
+using namespace blitz ;
+
+
+using XMLIOSERVER::XMLIOIncompatibeTypeException;
+
+namespace XMLIOSERVER
+{
+   class BaseAttribut
+   {
+     public:
+     
+     virtual const char * getName(void) const = 0  ;
+        
+     virtual ostream & print(ostream& o) const = 0  ;
+     
+     friend ostream& operator <<(ostream& o,const BaseAttribut& Attr)
+     {return Attr.print(o) ; }
+     
+     virtual const char * getId(void) {return getName();} ;
+     bool hasId(void){return (true);}
+
+     virtual void setFromString(const std::string str) = 0;
+      
+     virtual void setValue(const int & value)          { error_set() ; }
+     virtual void setValue(const Array<int,1>& value)  { error_set() ; }
+     virtual void setValue(const Array<int,2>& value)  { error_set() ; }
+     virtual void setValue(const Array<int,3>& value)  { error_set() ; }
+     
+     virtual void setValue(const double & value)          { error_set() ; }
+     virtual void setValue(const Array<double,1>& value)  { error_set() ; }
+     virtual void setValue(const Array<double,2>& value)  { error_set() ; }
+     virtual void setValue(const Array<double,3>& value)  { error_set() ; }
+     
+     virtual void setValue(const bool & value)          { error_set() ; }
+     virtual void setValue(const Array<bool,1>& value)  { error_set() ; }
+     virtual void setValue(const Array<bool,2>& value)  { error_set() ; }
+     virtual void setValue(const Array<bool,3>& value)  { error_set() ; }
+     
+     virtual void setValue(const char * value)            { error_set() ; }
+     virtual void setValue(const string & value)          { error_set() ; }
+     virtual void setValue(const Array<string,1>& value)  { error_set() ; }
+     virtual void setValue(const Array<string,2>& value)  { error_set() ; }
+     virtual void setValue(const Array<string,3>& value)  { error_set() ; }
+     
+     virtual void setValue(const char & value)          { error_set() ; }
+     virtual void setValue(const Array<char,1>& value)  { error_set() ; }
+     virtual void setValue(const Array<char,2>& value)  { error_set() ; }
+     virtual void setValue(const Array<char,3>& value)  { error_set() ; }
+
+
+     virtual void getValue(int & value) const        { error_get() ; }
+     virtual void getValue(Array<int,1>& value) const  { error_get() ; }
+     virtual void getValue(Array<int,2>& value) const  { error_get() ; }
+     virtual void getValue(Array<int,3>& value) const  { error_get() ; }
+     
+     virtual void getValue(double & value) const          { error_get() ; }
+     virtual void getValue(Array<double,1>& value) const  { error_get() ; }
+     virtual void getValue(Array<double,2>& value) const  { error_get() ; }
+     virtual void getValue(Array<double,3>& value) const  { error_get() ; }
+     
+     virtual void getValue(bool & value) const          { error_get() ; }
+     virtual void getValue(Array<bool,1>& value) const  { error_get() ; }
+     virtual void getValue(Array<bool,2>& value) const  { error_get() ; }
+     virtual void getValue(Array<bool,3>& value) const  { error_get() ; }
+     
+     virtual void getValue(char * value) const            { error_get() ; }
+     virtual void getValue(string & value) const          { error_get() ; }
+     virtual void getValue(Array<string,1>& value) const  { error_get() ; }
+     virtual void getValue(Array<string,2>& value) const  { error_get() ; }
+     virtual void getValue(Array<string,3>& value) const  { error_get() ; }
+     
+     virtual void getValue(char & value) const          { error_get() ; }
+     virtual void getValue(Array<char,1>& value) const  { error_get() ; }
+     virtual void getValue(Array<char,2>& value) const  { error_get() ; }
+     virtual void getValue(Array<char,3>& value) const  { error_get() ; }
+
+     static void error_set(void)
+     {
+        throw XMLIOIncompatibeTypeException("BaseAttribut::set<type> > Setting value type is incompatible with attribut type");
+     }
+
+     static void error_get(void)
+     {
+        throw XMLIOIncompatibeTypeException("BaseAttribut::set<type> >Getting value type is incompatible with attribut type");
+     }
+   }; //class BaseAttribut
+} // namespace XMLIOSERVER
+
+#endif //__BASE_ATTRIBUT__
+  
Index: /XMLIO_V2/dev/dev_rv/context.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/context.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/context.hpp	(revision 88)
@@ -0,0 +1,81 @@
+#ifndef __CONTEXT__
+#define __CONTEXT__ 
+
+      
+namespace XMLIOSERVER
+{ 
+   class Context : public ObjectTemplate<Context>
+   {
+      public:
+            
+         Context(void) : ObjectTemplate<Context>()
+         {/* Ne rien faire de plus */}               
+         Context(const string& _id) : ObjectTemplate<Context>(_id)
+         {/* Ne rien faire de plus */}   
+         
+         void parse (XMLNode& _node)
+         {
+            THashAttributes attributes;
+           
+            /// PARSING POUR GESTION DES ENFANTS
+            if (_node.getElementName().compare(string("context")))
+               WARNING("Le noeud est mal nommÃ© mais sera traitÃ© comme un context !");
+            
+            if (!(_node.goToChildElement()))
+               WARNING("Le contexts ne contient pas d'enfant !"); 
+            else
+            {
+               //////////////////////////////////////
+              do { // Parcours des contexts pour traitement.        
+                            
+                  string name = _node.getElementName();
+                  std::cout << name << std::endl;
+                  attributes.clear();
+                  _node.getAttributes(attributes);   
+                  
+                  if (attributes.end() != attributes.find("id"))
+                  { WARNING("Le noeud de dÃ©finition possÃšde un identifiant, il ne sera pas pris en compte lors du traitement !"); }
+                  
+                  if (name.compare("field_definition") == 0)
+                  { // Parsing pour la dÃ©finition des champs.
+                  
+                     if (FieldDefinition::HasObject("field_definition")) 
+                        WARNING("Le context possÃšde dÃ©jÃ  un noeud de dÃ©finition de champs, le dernier dÃ©fini complÃ©tera le premier !");
+                     
+                     fieldDef = (FieldDefinition*)&FieldDefinition::CreateObject("field_definition");
+                     fieldDef->parse(_node, true);
+                     continue;
+                  }                  
+                  // Traitement file, grid et axis Ã  complÃ©ter.
+               } while (_node.goToNextElement());
+               //////////////////////////////////////
+               _node.goToParentElement(); // Retour au parent
+            }
+            
+            return;
+         }
+         
+         void registerAllAttributes(void)
+         { /* Ne rien faire de plus */ }
+         
+         virtual const char* getName(void) const {return ("Context"); }
+         
+         FieldDefinition* getFieldDefinition(void) { return (this->fieldDef); }
+                  
+         ~Context()
+         {/* Ne rien faire de plus pour le moment */ }
+         
+      protected:
+      
+      private:
+      
+         FieldDefinition*  fieldDef;
+         /*FileDefinition* fileDef;
+         AxisDefinition*   axisDef;
+         GridDefinition*   gridDef;*/
+
+      
+   }; //class Context
+}// namespace XMLIOSERVER
+
+#endif  // __CONTEXT__
Index: /XMLIO_V2/dev/dev_rv/declare_attribut.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/declare_attribut.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/declare_attribut.hpp	(revision 88)
@@ -0,0 +1,17 @@
+#ifndef __DECLARE_ATTRIBUT__
+#define __DECLARE_ATTRIBUT__
+
+#include "attribut.hpp"
+
+#define DECLARE_ATTR(att_name,att_type)               \
+   class attr_##att_name : public Attribut<att_type>  \
+   {                                                  \
+      public:                                         \
+         const char * 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
+
+#endif // __DECLARE_ATTRIBUT__
Index: /XMLIO_V2/dev/dev_rv/field.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/field.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/field.hpp	(revision 88)
@@ -0,0 +1,34 @@
+#ifndef __FIELD__
+#define __FIELD__
+
+namespace XMLIOSERVER
+{
+   class Field : public ObjectTemplate<Field>
+   {
+      public:
+         Field(void) : ObjectTemplate<Field>()
+			{/* Ne rien faire de plus */}	         	
+			Field(const string& _id) : ObjectTemplate<Field>(_id)
+         {/* Ne rien faire de plus */}	
+         
+         virtual const char* getName(void) const {return ("Field"); }   
+
+			void parse (XMLNode& _node)
+			{
+            /// PARSING GESTION DES ATTRIBUTS ///
+            // A complÃ©ter.
+            
+            /// PARSING POUR GESION DES ENFANTS
+            // Rien Ã  faire.
+            
+            return;
+         }
+         
+         ~Field(void) 
+         {/* Ne rien faire de plus */}	       
+      
+   }; // class Field 
+      
+}; // namespace XMLIOSERVER
+   
+#endif // __FIELD__
Index: /XMLIO_V2/dev/dev_rv/field_attribut.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/field_attribut.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/field_attribut.hpp	(revision 88)
@@ -0,0 +1,56 @@
+#ifndef __FIELD_ATTRIBUT__
+#define __FIELD_ATTRIBUT__
+
+#include "declare_attribut.hpp"
+#include "attribut_registrar.hpp"
+
+namespace XMLIOSERVER
+{
+   class FieldAttribut : public virtual AttributRegistrar
+   {
+      public :
+      
+         DECLARE_ATTR(name, string) ;
+         DECLARE_ATTR(description, string) ; 
+         DECLARE_ATTR(unit, string) ;
+         DECLARE_ATTR(operation, string);
+      
+         DECLARE_ATTR(freq_op, int) ;
+         DECLARE_ATTR(level, int) ;
+         DECLARE_ATTR(prec, int) ;
+      
+         DECLARE_ATTR(enabled, bool);
+      
+         DECLARE_ATTR(axis_ref, string);
+         DECLARE_ATTR(grid_ref, string);
+         DECLARE_ATTR(zoom_ref, string);
+         DECLARE_ATTR(field_ref, string);
+      
+         FieldAttribut(void)
+         { /* Ne rien faire de plus */ }
+                 
+         // TODO DÃ©finir un constructeur par copie au lieu de registerAllAttributes (Ã©ventuellement)
+         
+         virtual void registerAllAttributes(void)
+         {
+            RegisterAttribut(&name) ;
+            RegisterAttribut(&description) ; 
+            RegisterAttribut(&unit) ;
+            RegisterAttribut(&operation);
+      
+            RegisterAttribut(&freq_op) ;
+            RegisterAttribut(&level) ;
+            RegisterAttribut(&prec) ;
+            RegisterAttribut(&enabled);
+      
+            RegisterAttribut(&axis_ref);
+            RegisterAttribut(&grid_ref);
+            RegisterAttribut(&zoom_ref);
+            RegisterAttribut(&field_ref);
+         }
+     
+   } ; // class CFieldAttribut
+   
+}// namespace XMLIOSERVER
+
+#endif //__FIELD_ATTRIBUT__
Index: /XMLIO_V2/dev/dev_rv/field_group.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/field_group.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/field_group.hpp	(revision 88)
@@ -0,0 +1,53 @@
+#ifndef __FIELD_GROUP__
+#define __FIELD_GROUP__
+
+namespace XMLIOSERVER
+{   
+   class FieldGroup : public GroupTemplate<Field>, public FieldAttribut
+   {
+      public:
+      
+         FieldGroup(void) : GroupTemplate<Field>(), FieldAttribut()
+         {/* Ne rien faire de plus */}               
+         FieldGroup(const string& _id) : GroupTemplate<Field>(_id), FieldAttribut()
+         {/* Ne rien faire de plus */}
+         
+         void setAttributes(const THashAttributes& attr)
+         {
+            for (THashAttributes::ConstIterator it = attr.begin(); it != attr.end(); it++)
+               if ((*it).first.compare(string("id"))) // Non prise en compte de l'identifiant lors de l'affectation des attributs.
+                  this->setSAttribut((*it).first, (*it).second);
+            
+            return;
+         }
+                 
+         virtual const char* getName(void) const {return ("FieldGroup"); }  
+         
+         void parse (XMLNode& _node, bool isFieldDef = false)
+         {
+            string name = _node.getElementName();            
+            THashAttributes attributes;
+            std::cout << "Traitement de " << name << std::endl;
+            
+            /// PARSING GESTION DES ATTRIBUTS ///
+            _node.getAttributes(attributes);  
+            this->setAttributes(attributes);
+            attributes.clear();
+               
+            /// PARSING POUR GESION DES ENFANTS
+            // A complÃ©ter.
+               
+            return;
+         }
+         
+         ~FieldGroup(void) 
+         {/* Ne rien faire de plus */}   
+         
+   }; // class FieldGroup
+     
+   typedef FieldGroup FieldDefinition ;
+   
+}; // namespace XMLIOSERVER
+   
+#endif // __FIELD_GROUP__
+
Index: /XMLIO_V2/dev/dev_rv/main.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/main.cpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/main.cpp	(revision 88)
@@ -0,0 +1,28 @@
+#include "xmlio.hpp"
+
+using namespace XMLIOSERVER;
+using namespace XMLIOSERVER::XML;
+using namespace std;
+
+int main (void)
+{
+	try
+	{
+		// Tests de la classe StrHashMap :
+		//StrHashMap<AbstractObject>::CLASS_TEST();
+		//ObjectTemplate<AbstractObject>::CLASS_TEST();
+		//GroupTemplate<AbstractObject>::CLASS_TEST();
+		XMLParser::CLASS_TEST();
+
+            
+		// Code Ã  executer ici
+	}
+	catch(const XMLIOException &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);
+} 
Index: /XMLIO_V2/dev/dev_rv/xmlio.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/xmlio.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/xmlio.hpp	(revision 88)
@@ -0,0 +1,46 @@
+#ifndef __XMLIO__
+#define __XMLIO__
+
+/// EntÃªtes STL ///
+#include <utility>
+#include <string>
+
+#include <vector>
+#include <deque>
+
+#include <iostream>
+#include <fstream>
+
+/// EntÃªtes Poco ///
+#include <Poco/Exception.h>
+#include <Poco/HashMap.h>
+#include <Poco/Hash.h>
+
+/// EntÃªte Blitz array ///
+#include <blitz/array.h>
+
+/// EntÃªtes crÃ©Ã©s dans le cadre du projet XMLIOSERVER. ///
+#include "xmlio_exception.hpp"
+#include "xmlio_logger.hpp"
+#include "xmlio_container.hpp"
+
+// Concernant les attributs ...
+#include "field_attribut.hpp"
+
+#include "xmlio_object.hpp"
+
+
+#include "xmlio_object_template.hpp"
+//#include "xmlio_group_template.hpp" // < Inclusion dans "xmlio_xml_parser.hpp
+
+// Les Objets "principaux" 
+// #include "field.hpp" // < Inclusion dans "xmlio_xml_parser.hpp" 
+
+// Concernant le parsing xml ...
+#include "xmlio_xml_parser.hpp" 
+
+//#include "context.hpp" // < Inclusion dans "xmlio_xml_parser.hpp" 
+
+
+
+#endif // __XMLIO__ 
Index: /XMLIO_V2/dev/dev_rv/xmlio_c_interface.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/xmlio_c_interface.cpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/xmlio_c_interface.cpp	(revision 88)
@@ -0,0 +1,13 @@
+extern "C"
+{ // DÃ©but du code C
+
+   using namespace XMLIOSERVER;
+   using namespace XMLIOSERVER::XML;
+   using namespace std;
+   
+   typedef void *XMLIOhandle;
+   
+   // VIDE TEMPORAIREMENT
+   
+}
+
Index: /XMLIO_V2/dev/dev_rv/xmlio_container.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/xmlio_container.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/xmlio_container.hpp	(revision 88)
@@ -0,0 +1,127 @@
+#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
+using std::vector;
+using std::string;
+using std::pair;
+using std::ostream;
+
+// Classes XMLIOSERVER
+using XMLIOSERVER::XMLIOUndefinedValueException;
+
+namespace XMLIOSERVER
+{
+   template<class Key, class Mapped, class HashFunc = Hash<Key> >
+      class ExHashMap
+         : private HashMap<Key, Mapped, 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[] invalide.");
+            return (find(kval)->second); 
+         }
+          
+         bool hasMappedValue(const Key& kval) {return (find(kval) != this->end());}
+          
+         const vector<Mapped*> getVector(void) { return (this->_elemList); }         
+
+         size_t getVectorSize(void) const {return (this->_elemList.size());}
+         size_t getSize(void) const {return (this->size());}
+         
+         virtual ~ExHashMap()
+         {/* Ne rien faire de plus */}
+         
+      protected :
+      
+         bool addValue(const Key& kval, Mapped& element)
+         {
+            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)
+         {   this->_elemList.insert(this->_elemList.end(), &element);   return (true);   }   
+         
+         
+         void removeValue(const Key& kval)
+         { Mapped& element = find(kval)->second; removeValue(element); this->erase(kval);   }
+         
+         void removeValue(const Mapped& element)
+         {
+            for (int i = 0; i < this->_elemList.size(); i++)             
+               if (*this->_elemList[i] == element ) this->_elemList.erase(this->_elemList.begin()+i);
+         }
+         
+      private :   
+         vector<Mapped*> _elemList;
+         
+   }; // class ExHashMap
+   
+   /////////////////////////////////////////////////////////////
+   
+   template<class Mapped>
+      class StrHashMap
+         : public ExHashMap<string, Mapped, Hash<string> >
+   {
+      public :
+      
+         StrHashMap() :  ExHashMap<string, Mapped, Hash<string> >()   
+         {/* Ne rien faire de plus */}   
+         
+         bool addObject(Mapped& element)
+         { if(element.hasId()) return(addValue(element.getId(), element));   return(addValue(element));   }
+         
+         bool addPtrObject(Mapped 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); 
+         }
+         
+         virtual ~StrHashMap()   
+         {/* Ne rien faire de plus */}
+         
+
+#define   STRHASHMAP_TEST(DESC, SIZE, VECTORSIZE) \
+         if(map.getSize() != SIZE or map.getVectorSize() != VECTORSIZE) \
+         { log << "Test de la classe StrHashMap > " << DESC << "... echec !" << std::endl; return (false); }
+      
+         /// POUR TESTS ///
+         static bool CLASS_TEST(ostream& log = std::clog)
+         {
+            StrHashMap<Mapped> map;
+            Mapped obj0("toto"), obj1("titi"),  obj3;
+            
+            ////////////////////////////////////////////////////////////////////
+            map.addObject(obj0);   map.addObject(obj1);
+            STRHASHMAP_TEST("Ajout d'objets identifiÃ©s au conteneur", 2, 2);
+            map.removeObject("toto");
+            STRHASHMAP_TEST("Suppression d'objets identifiÃ©s du conteneur", 1, 1);
+            map.addObject(obj3);   
+            STRHASHMAP_TEST("Ajout d'objets non-identifiÃ©s au conteneur", 1, 2);
+            // A Ã©toffer en cas de soucis avec cette classe ...
+            ////////////////////////////////////////////////////////////////////
+            
+            log << "Test  StrHashMap ... ok !" << std::endl;
+            return (true);      
+         };
+#undef   STRHASHMAP_TEST
+         
+   }; // class StrHashMap
+            
+}; // namespace XMLIOSERVER
+
+#endif // __XMLIO_CONTAINER__ 
Index: /XMLIO_V2/dev/dev_rv/xmlio_exception.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/xmlio_exception.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/xmlio_exception.hpp	(revision 88)
@@ -0,0 +1,79 @@
+#ifndef __XMLIO_EXCEPTION__
+#define __XMLIO_EXCEPTION__ 
+
+// Classes utilisÃ©es issues de la STL
+using std::string;
+
+// Classes utilisÃ©es issues de Poco
+using Poco::Exception;
+
+namespace XMLIOSERVER
+{
+   class XMLIOException : public Exception
+   {
+      public :
+            
+         XMLIOException(int _code): Exception(_code)                                                   
+         { /* Ne rien faire de plus */ }                                                                     
+         XMLIOException(const std::string& _msg, int _code): Exception(_msg, _code)                              
+         { /* Ne rien faire de plus */ }                                                                        
+         XMLIOException(const std::string& _msg, const std::string& _arg, int _code): Exception(_msg, _arg, _code)      
+         { /* Ne rien faire de plus */ }                                                                        
+         XMLIOException(const std::string& _msg, const Poco::Exception& _exc, int _code): Exception(_msg, _exc, _code)   
+         { /* Ne rien faire de plus */ }   
+         
+                                                                              
+         XMLIOException(const XMLIOException& _exc): Exception(_exc)                                                
+         { /* Ne rien faire de plus */ }
+         
+         ~XMLIOException() throw()
+         { /* Ne rien faire de plus */ }
+         
+         XMLIOException& operator = (const XMLIOException& _exc)                                             
+         { Exception::operator = (_exc); return *this; }   
+                                                                           
+         virtual const char* name(void) const throw() { return ("XMLIO>XMLIOException"); }                                                                     
+         virtual const char* className(void) const throw() { return (typeid(*this).name()); }      
+                                                                     
+         virtual Exception* clone(void) const {   return new XMLIOException(*this); }                                                                     
+         virtual void rethrow(void) const { throw *this; }
+               
+   };// class XMLIOException
+   
+   class XMLIOUndefinedValueException : public XMLIOException
+   {
+      public :
+         XMLIOUndefinedValueException(const std::string& _msg): XMLIOException(_msg, 1001) {}
+         const char* name(void) const throw() { return ("XMLIO>UndefinedValueException"); }
+            
+   }; //class XMLIOUndefinedException
+   
+   class XMLIOStreamException : public XMLIOException
+   {
+      public :
+         XMLIOStreamException(const std::string& _msg): XMLIOException(_msg, 1002) {}
+         const char* name(void) const throw() { return ("XMLIO>StreamException"); }
+            
+   }; //class XMLIOStreamException
+   
+   class XMLParsingException : public XMLIOException
+   {
+      public :
+         XMLParsingException(const std::string& _msg): XMLIOException(_msg, 1003) {}
+         const char* name(void) const throw() { return ("XMLIO>XMLParsingException"); }
+            
+   }; //class XMLParsingException
+   
+   class XMLIOIncompatibeTypeException : public XMLIOException
+   {
+      public :
+         XMLIOIncompatibeTypeException(const std::string& _msg): XMLIOException(_msg, 1003) {}
+         const char* name(void) const throw() { return ("XMLIO>XMLIOIncompatibeTypeException"); }
+            
+   }; //class XMLIOIncompatibeTypeException
+   
+   // A complÃ©ter.
+   
+};// namespace XMLIOSERVER
+
+#endif // __XMLIO_EXCEPTION__ 
Index: /XMLIO_V2/dev/dev_rv/xmlio_group_template.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/xmlio_group_template.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/xmlio_group_template.hpp	(revision 88)
@@ -0,0 +1,95 @@
+#ifndef __XMLIO_GROUP_TEMPLATE__
+#define __XMLIO_GROUP_TEMPLATE__ 
+
+namespace XMLIOSERVER
+{
+   template <class T>
+      class GroupTemplate : public ObjectTemplate<GroupTemplate<T> >
+   {
+      public:
+            
+         GroupTemplate(void) : ObjectTemplate<GroupTemplate<T> >(), childList(), groupList()
+         {/* Ne rien faire de plus */}               
+         GroupTemplate(const string& _id) : ObjectTemplate<GroupTemplate<T> >(_id), childList(), groupList()
+         {/* Ne rien faire de plus */}            
+      
+         virtual const char* getName(void) const {return ("GroupTemplate"); }
+         
+         /// Pour les groupes d'objets enfants ///
+         
+         GroupTemplate<T>& createGroup(const string _id) throw (XMLIOUndefinedValueException) 
+         {
+            GroupTemplate<T>& obj = GroupTemplate<T>::CreateObject(_id);
+            groupList.addPtrObject(&obj);
+            return (obj);
+         }
+         
+         GroupTemplate<T>& createGroup(void)
+         {
+            GroupTemplate<T>& obj = GroupTemplate<T>::CreateObject();
+            groupList.addPtrObject(&obj);            
+            return (obj);
+         }
+         
+         GroupTemplate<T>& getGroup(const string _id) throw (XMLIOUndefinedValueException) { return (*groupList[_id]); }
+         bool hasGroup(const string _id) { return (groupList.hasMappedValue(_id)); }
+         
+         const StrHashMap<GroupTemplate<T>* >& getGroupList(void) { 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.addPtrObject(&obj);
+            return (obj);
+         }
+         
+         T& createChild(void)
+         {
+            T& obj = ObjectTemplate<T>::CreateObject();
+            childList.addPtrObject(&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) { return (childList); }
+         
+         size_t getNbChild() const {return (childList.getVectorSize()); }
+            
+         static bool CLASS_TEST(ostream& log = std::clog)
+         {
+            GroupTemplate<T> group;
+            /////////////////////////////////////////            
+            GroupTemplate<T>& group0 = group.createGroup("toto");
+            GroupTemplate<T>& group1 = group.createGroup();
+            T& child0 = group.createChild("toto");
+            T& child1 = group.createChild();
+            log << "Nombre de (groupes) enfants : " << group.getNbChild() << "/" << group.getNbGroup() << " (2/2 attendu)" << std::endl;
+            /////////////////////////////////////////
+            log << "Test  GroupTemplate ... ok !" << std::endl;
+            return (true);      
+         };   
+
+        
+         ~GroupTemplate()
+         {/* Ne rien faire de plus pour le moment */ }
+         
+      protected:
+      
+      private:
+         StrHashMap<T*> childList;
+         StrHashMap<GroupTemplate<T>* > groupList;
+
+   }; // class GroupTemplate
+   
+   
+   
+}// namespace XMLIOSERVER
+
+
+#endif // __XMLIO_GROUP_TEMPLATE__
Index: /XMLIO_V2/dev/dev_rv/xmlio_logger.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/xmlio_logger.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/xmlio_logger.hpp	(revision 88)
@@ -0,0 +1,91 @@
+#ifndef __XMLIO_LOGGER__
+#define __XMLIO_LOGGER__ 
+
+// EntÃªte Poco logging
+#include "Poco/Logger.h"
+#include "Poco/PatternFormatter.h"
+#include "Poco/FormattingChannel.h"
+#include "Poco/ConsoleChannel.h"
+#include "Poco/FileChannel.h"
+#include "Poco/Message.h"
+
+// Classes utilisÃ©es issues de Poco
+using Poco::Logger;
+using Poco::PatternFormatter;
+using Poco::FormattingChannel;
+using Poco::ConsoleChannel;
+using Poco::FileChannel;
+using Poco::Message;
+
+namespace XMLIOSERVER
+{
+   class ILogger
+   {
+      public :
+      
+         ILogger(const string& _fileLogName, bool _withConsole = true)
+         {
+            // Perte mÃ©moire faible ici (/ still reachable: 84 bytes in 2 blocks /)
+   
+            // TODO CrÃ©er une sortie fichier.
+            pf = new PatternFormatter("[%Y-%m-%d %H:%M:%S] %t");
+            cc = new ConsoleChannel();
+            pFCConsole = new FormattingChannel();
+            pFCConsole->setChannel(cc);
+            pFCConsole->open();            
+            Logger::create("ConsoleLogger", pFCConsole, Message::PRIO_INFORMATION);
+         }
+
+         static Logger & GetConsoleLogger(void) {return (Logger::get("ConsoleLogger"));}   
+         
+         ~ILogger(void) { delete pf, pFCConsole;}   
+         
+      private :
+         FormattingChannel * pFCConsole;
+         PatternFormatter  * pf;
+         ConsoleChannel      * cc;
+      
+   }; // class XMLIOLogger
+   
+   // Initialisation de la classe de Logging
+   static ILogger LOGGER("xmlio.log");
+
+#define   ERROR(MSG)   (ILogger::GetConsoleLogger().error(MSG))
+#define   WARNING(MSG)   (ILogger::GetConsoleLogger().warning(MSG))
+// A complÃ©ter.
+
+
+
+/************* POUR MEMOIRE **********************
+#include <stdio.h> 
+#include <execinfo.h> 
+#include <signal.h> 
+#include <stdlib.h> 
+ 
+void handler(int sig) { 
+  void *array[10]; 
+  size_t size; 
+  // get void*'s for all entries on the stack 
+  size = backtrace(array, 10); 
+  // print out all the frames to stderr 
+  fprintf(stderr, "Error: signal %d:\n", sig); 
+  backtrace_symbols_fd(array, size, 2); 
+  exit(1); 
+} 
+void baz() { 
+ int *foo = (int*)-1; // make a bad pointer 
+  printf("%d\n", *foo);       // causes segfault 
+} 
+void bar() { baz(); } 
+void foo() { bar(); } 
+ 
+int main(int argc, char **argv) { 
+  signal(SIGSEGV, handler);   // install our handler 
+  foo(); // this will call foo, bar, and baz.  baz segfaults. 
+} 
+ 
+ ***************************************************************/
+   
+}; // namespace XMLIOSERVER
+
+#endif // __XMLIO_LOGGER__  
Index: /XMLIO_V2/dev/dev_rv/xmlio_object.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/xmlio_object.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/xmlio_object.hpp	(revision 88)
@@ -0,0 +1,68 @@
+#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;
+
+namespace XMLIOSERVER
+{
+   class AbstractObject 
+   {
+      public :
+      
+         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) 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 de ne sont pas "Ã©gaux".
+            if(!this->hasId() or !other.hasId()) return false;
+            return (id.compare(other.id) == 0);
+         }
+         
+         friend ostream& operator<< (ostream& out, const AbstractObject& c) 
+         { out << c.toString(); return (out);}   
+         
+         virtual ~AbstractObject(void)
+         {/* Ne rien faire de plus */}
+      
+      protected :
+      
+         virtual string toString(void) const
+         {
+            ostringstream st("[");
+            st << "[" << this->getName();
+            if (hasId()) st << " id=\"" <<  id << "\"";
+            st << "]" ;
+            return (st.str());
+         }
+         
+         virtual const char* getName(void) const {return ("AbstractObject"); }
+            
+      private :
+      
+         string id ;
+         bool IdDefined ;
+      
+   };// class AbstractObject
+   
+}// namespace XMLIOSERVER
+
+#endif // __XMLIO_OBJECT__   
Index: /XMLIO_V2/dev/dev_rv/xmlio_object_template.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/xmlio_object_template.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/xmlio_object_template.hpp	(revision 88)
@@ -0,0 +1,89 @@
+#ifndef __XMLIO_OBJECT_TEMPLATE__
+#define __XMLIO_OBJECT_TEMPLATE__ 
+
+// Classes utilisÃ©es issues de la STL
+using std::pair;
+using std::string;
+using std::ostream;
+
+using XMLIOSERVER::StrHashMap;
+   
+namespace XMLIOSERVER
+{
+   template <class T>
+      class ObjectTemplate : public AbstractObject
+   {
+      public :
+         
+         static T& CreateObject(const string _id) throw (XMLIOUndefinedValueException) 
+         {
+            // Si l'identifiant est rÃ©pertoriÃ©, on retourne l'Ã©lÃ©ment existant.
+            if(ObjectTemplate<T>::HasObject(_id))
+               return (ObjectTemplate<T>::GetObject(_id));
+                              
+            // Ajout d'un nouvel objet si l'identifiant n'est pas rÃ©pertoriÃ©.
+            T identified_object(_id);
+            ObjectTemplate<T>::CurrListObj.addObject(identified_object);
+            ObjectTemplate<T>::GetObject(_id).registerAllAttributes();
+            return (ObjectTemplate<T>::GetObject(_id));
+         }
+         
+         static T& CreateObject(void)
+         {
+            ObjectTemplate<T>::CurrListObj.addObject(*(new T)); //<< Perte mÃ©moire ici
+            return (*(ObjectTemplate<T>::CurrListObj.getVector()[ObjectTemplate<T>::CurrListObj.getVectorSize()-1]));
+         }
+         
+         static T& GetObject(const string _id) throw (XMLIOUndefinedValueException) { return (ObjectTemplate<T>::CurrListObj[_id]); }
+         static bool HasObject(const string _id) { return (ObjectTemplate<T>::CurrListObj.hasMappedValue(_id)); }
+         
+         static const StrHashMap<T> GetCurrentListObject(void) { return (CurrListObj); }
+         
+         virtual void registerAllAttributes(void) {};
+         
+         virtual const char* getName(void) const {return ("ObjectTemplate"); }
+         
+         /// POUR TESTS ///
+         
+#define   OBJECTTEMPLATE_TEST(DESC, SIZE, VECTORSIZE) \
+         if(ObjectTemplate<T>::CurrListObj.getSize() != SIZE or ObjectTemplate<T>::CurrListObj.getVectorSize() != VECTORSIZE) \
+         { log << "Test de la classe ObjectTemplate > " << DESC << "... echec !" << std::endl; return (false); }
+            
+         static bool CLASS_TEST(ostream& log = std::clog)
+         {
+            ////////////////////////////////////////////////////////////////////
+            T& obj0= ObjectTemplate<T>::CreateObject("toto");
+            T& obj1= ObjectTemplate<T>::CreateObject("tata");
+            OBJECTTEMPLATE_TEST("Ajout d'objets identifiÃ©s au conteneur", 2, 2);
+            T& obj2= ObjectTemplate<T>::CreateObject("tata");
+            OBJECTTEMPLATE_TEST("Ajout d'objets identifiÃ©s dÃ©jÃ  existants au conteneur", 2, 2);            
+            T& obj3= ObjectTemplate<T>::CreateObject();
+            OBJECTTEMPLATE_TEST("Ajout d'objets non-identifiÃ©s au conteneur", 2, 3);
+            ////////////////////////////////////////////////////////////////////
+            
+            log << "Test  ObjectTemplate ... ok !" << std::endl;
+            return (true);      
+         };   
+#undef   OBJECTTEMPLATE_TEST
+         
+         
+         virtual ~ObjectTemplate(void)
+         {/* Ne rien faire de plus */}
+         
+      protected :
+      
+         ObjectTemplate(void) : AbstractObject()
+         {/* Ne rien faire de plus */}         
+         ObjectTemplate(const string& _id) : AbstractObject(_id) 
+         {/* Ne rien faire de plus */}
+         
+      private :
+         static StrHashMap<T> CurrListObj;
+      
+   };// class ObjectTemplate
+   
+   template <class T> StrHashMap<T> ObjectTemplate<T>::CurrListObj ;
+   
+}// namespace XMLIOSERVER
+   
+#endif // __XMLIO_OBJECT_TEMPLATE__ 
Index: /XMLIO_V2/dev/dev_rv/xmlio_xml_parser.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/xmlio_xml_parser.hpp	(revision 88)
+++ /XMLIO_V2/dev/dev_rv/xmlio_xml_parser.hpp	(revision 88)
@@ -0,0 +1,189 @@
+#ifndef __XMLIO_XML_PARSER__
+#define __XMLIO_XML_PARSER__ 
+
+// 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::deque;
+
+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;
+
+namespace XMLIOSERVER
+{
+   namespace XML
+   {
+      
+      typedef HashMap<string, string> THashAttributes;
+         
+      // TODO Mettre des auto_ptr ici car gestion de la mÃ©moire lamentable sans.
+      typedef Document* PDocument;
+      typedef Node*     PNode;
+         
+      class XMLNode
+      {
+         protected :
+            
+            XMLNode(const string& _rootName) : rootName(_rootName) { this->cNode = NULL ; }
+            
+         public :
+            
+            static XMLNode CreateNode(istream& _istr, const string& _rootName = string("simulation"))
+            {
+               XMLNode node(_rootName);
+                  
+               if ((_istr.good()))
+               { // S'il est possible de lire le flux en entrÃ©e ...
+                  InputSource src(_istr);
+                  DOMParser parser;
+                     
+                  // On parse la source XML et on vÃ©rifie que le premier noeud (racine) est du type "Element"
+                  // ... et Ã  pour valeur la chaÃ®ne rootName.
+                  PDocument pDoc = parser.parse(&src);
+                  if (!(pDoc->documentElement()->nodeName().compare(_rootName)))
+                  {
+                     node.cNode = pDoc->documentElement();
+                     node.goToChildElement();
+                  }
+                  else
+                  {
+                     ostringstream oss;
+                     oss << "L'Ã©lÃ©ment racine doit avoir pour valeur <" << _rootName << "> (\"" <<  (pDoc->documentElement()->nodeName()) <<"\" lue)";
+                     throw XMLParsingException(oss.str());
+                  }    
+               }
+               else
+                  throw XMLIOStreamException("Impossible de lire le flux en entrÃ©e pour le parsing XML !");
+                  
+               return (node);
+            }
+               
+            string getElementName(void) const {return (this->cNode->nodeName());}
+                
+            bool goToNextElement(Node* nextElement = 0) 
+            {
+               nextElement = (!nextElement)? this->cNode->nextSibling() : nextElement;
+              
+               // On parcourt la liste des "siblings" jusqu'Ã  trouver un Ã©lÃ©ment quelconque.
+               for(; ; nextElement = nextElement->nextSibling())
+               if (nextElement == NULL) break;
+               else if (nextElement->nodeType() == 1)
+               {// Si l'un des noeuds est un Ã©lÃ©ment...
+                this->cNode = nextElement ;
+                return (true);
+               } 
+              return (false);
+             }
+             
+             bool goToChildElement(void)
+             {
+              // On parcourt la liste des enfants jusqu'Ã  trouver un Ã©lÃ©ment quelconque.
+              if (this->cNode->firstChild())
+               if (this->goToNextElement(this->cNode->firstChild()))
+                return (true);
+                
+              return (false);
+             }
+             
+             bool goToParentElement(void)
+             { 
+              // Pas de retour au parent si on est Ã  la racine.
+              if (!(this->getElementName().compare(rootName))) return (false);
+              this->cNode = this->cNode->parentNode();
+              return (true);
+             }
+             
+             bool getAttributes(THashAttributes& attributes) const
+             {
+              if(!this->cNode->hasAttributes()) return (false);
+              NamedNodeMap* map = this->cNode->attributes();
+              
+              for(unsigned int i = 0; i< map->length(); i++)
+               attributes[map->item(i)->nodeName()] = map->item(i)->nodeValue();
+
+              return (true);
+             }
+            
+            ~XMLNode() 
+            { /* Ne rien faire de plus */ }
+
+         private :
+                  
+            PNode  cNode;
+            string rootName;      
+         
+      };// class XMLNode
+      
+      #include "field.hpp"
+      
+      #include "xmlio_group_template.hpp"      
+      #include "field_group.hpp"
+      
+      #include "context.hpp"
+            
+      using XMLIOSERVER::Context;
+      
+      class XMLParser
+      {
+         public : 
+            static void Parse(XMLNode& _node)
+            {
+               THashAttributes attributes;
+               
+              do {                
+                 // Traitement de l'identifiant
+                  _node.getAttributes(attributes);            
+                  if (attributes.end() == attributes.find("id"))
+                  { WARNING("L'un des contexts ne sera pas traitÃ© car il n'est pas identifiÃ© !"); continue; }
+                  Context& context = Context::CreateObject(attributes["id"]);
+                  context.parse(_node);
+                  attributes.clear();
+                  
+               } while (_node.goToNextElement());               
+            }    
+            
+            static bool CLASS_TEST(ostream& log = std::clog)
+            {
+               ifstream istr( "/local/testsuite/iodef_test.xml" , ifstream::in ); // Modifier le rÃ©pertoire de test ici
+               XMLNode node = XMLNode::CreateNode(istr);
+               XMLParser::Parse(node);
+               log << "Nombre de contexts listÃ©s : " << Context::GetCurrentListObject().getSize() << " contre 2 attendus."<< std::endl;
+               log << "Test  XMLParser ... ok !" << std::endl;
+               return (true);
+            }
+                 
+      }; // class XMLParser     
+   }; // namespace XML
+
+};// namespace XMLIOSERVER
+
+
+#endif // __XMLIO_XML_PARSER__ 
