Index: XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_object.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_object.hpp	(revision 112)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_object.hpp	(revision 112)
@@ -0,0 +1,58 @@
+#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) 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)
+         {/* Ne rien faire de plus */}
+      
+      protected :
+
+            
+      private :
+      
+         string id ;
+         bool IdDefined ;
+      
+   };// class AbstractObject
+   
+}// namespace XMLIOSERVER
+
+#endif // __XMLIO_OBJECT__   
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/axis.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/axis.hpp	(revision 111)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/axis.hpp	(revision 112)
@@ -25,3 +25,5 @@
 }; // namespace XMLIOSERVER
 
+DECLARE_GROUP(Axis);
+
 #endif // __AXIS__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/axis_group.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/axis_group.hpp	(revision 111)
+++ 	(revision )
@@ -1,70 +1,0 @@
-#ifndef __AXIS_GROUP__
-#define __AXIS_GROUP__
-
-namespace XMLIOSERVER
-{
-   class AxisGroup : public GroupTemplate<CAxis, AxisAttribut>
-   {
-      public:
-
-         AxisGroup(void) : GroupTemplate<CAxis, AxisAttribut>()
-         {/* Ne rien faire de plus */}
-         AxisGroup(const string& _id) : GroupTemplate<CAxis, AxisAttribut>(_id)
-         {/* Ne rien faire de plus */}
-
-         void parse (XMLNode& _node, bool _withAttr = true)
-         {
-            string name = _node.getElementName();
-            THashAttributes attributes;
-
-            /// PARSING GESTION DES ATTRIBUTS ///
-            if (_withAttr)
-            {
-               _node.getAttributes(attributes);
-               this->setAttributes(attributes);
-
-               if (attributes.end() != attributes.find("src"))
-               { // Si une demande d'inclusion de fichier est trouvÃ©e.
-                  XMLNode _node_inc = getNodeIncludedFile(attributes["src"], name);
-                  parse (_node_inc);
-               }
-               attributes.clear();
-            }
-
-            /// PARSING POUR GESTION DES ENFANTS
-            if (!(_node.goToChildElement()))
-               WARNING("Le groupe d'axes ne contient pas d'enfant !");
-            else
-            {
-               //////////////////////////////////////
-               do { // Parcours pour traitement.
-
-                  string name = _node.getElementName();
-                  attributes.clear();
-                  _node.getAttributes(attributes);
-
-                  if (name.compare(AxisGroup::GetName()) == 0)
-                  { createGroupAndParse<AxisGroup>(attributes, _node); continue; }
-
-                  if (name.compare(CAxis::GetName()) == 0)
-                  { createChildAndParse<CAxis>(attributes, _node); continue; }
-
-                  WARNING("Un groupe d'axes ne peut contenir qu'un axe ou un autre groupe d'axes !");
-
-               } while (_node.goToNextElement());
-               //////////////////////////////////////
-               _node.goToParentElement(); // Retour au parent
-            }
-         }
-
-         virtual ~AxisGroup(void)
-         {/* Ne rien faire de plus */ }
-
-   }; // class AxisGroup
-
-   typedef AxisGroup AxisDefinition ;
-
-}; // namespace XMLIOSERVER
-
-#endif // __AXIS_GROUP__
-
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp	(revision 112)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp	(revision 112)
@@ -0,0 +1,13 @@
+/*using namespace XMLIOSERVER;
+using namespace XMLIOSERVER::XML;
+using namespace std;
+
+extern "C"
+{ // DÃ©but du code C
+   
+   typedef void *XMLIOhandle;
+   
+   // VIDE TEMPORAIREMENT
+   
+}*/
+
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/container.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/container.hpp	(revision 112)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/container.hpp	(revision 112)
@@ -0,0 +1,102 @@
+#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["+kval+"] invalide.");
+            return (find(kval)->second);
+         }
+
+         bool hasMappedValue(const Key& kval) {return (find(kval) != this->end());}
+
+         const vector<Mapped*>& getVector(void) const { 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) // Non testÃ©
+         { Mapped* element = find(kval)->second; removeValue(element); this->erase(kval); }
+
+         void removeValue(const Mapped* element) // Non testÃ©
+         {
+            for (int i = 0; i < this->_elemList.size(); i++)
+               if (*this->_elemList[i] == element )
+                  this->_elemList.erase(this->_elemList.begin()+i);
+
+            delete element;
+         }
+
+      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 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 */}
+
+   }; // class StrHashMap
+
+}; // namespace XMLIOSERVER
+
+#endif // __XMLIO_CONTAINER__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/declare_group.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/declare_group.hpp	(revision 112)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/declare_group.hpp	(revision 112)
@@ -0,0 +1,18 @@
+#ifndef __DECLARE_GROUP__
+#define __DECLARE_GROUP__
+
+#define DECLARE_GROUP(child_type) \
+   namespace XMLIOSERVER \
+   {  \
+      class child_type##Group : public GroupTemplate<C##child_type, child_type##Attribut>\
+      {\
+         public:\
+            child_type##Group(void) : GroupTemplate<C##child_type, child_type##Attribut>(){}\
+            child_type##Group(const string& _id) : GroupTemplate<C##child_type, child_type##Attribut>(_id) {}\
+            void parse (XMLNode& _node, bool _withAttr = true) { _parse<child_type##Group>(_node, _withAttr); }\
+            virtual ~child_type##Group(void){}\
+      }; \
+      typedef child_type##Group child_type##Definition; \
+   };
+
+#endif // __DECLARE_GROUP__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/exception.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/exception.hpp	(revision 112)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/exception.hpp	(revision 112)
@@ -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 XMLIOIncompatibleTypeException : public XMLIOException
+   {
+      public :
+         XMLIOIncompatibleTypeException(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/src/XMLIO/field.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/field.hpp	(revision 111)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/field.hpp	(revision 112)
@@ -34,3 +34,5 @@
 }; // namespace XMLIOSERVER
 
+DECLARE_GROUP(Field);
+
 #endif // __FIELD__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/field_group.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/field_group.hpp	(revision 111)
+++ 	(revision )
@@ -1,70 +1,0 @@
-#ifndef __FIELD_GROUP__
-#define __FIELD_GROUP__
-
-namespace XMLIOSERVER
-{
-   class FieldGroup : public GroupTemplate<CField, FieldAttribut>
-   {
-      public:
-
-         FieldGroup(void) : GroupTemplate<CField, FieldAttribut>()
-         {/* Ne rien faire de plus */}
-         FieldGroup(const string& _id) : GroupTemplate<CField, FieldAttribut>(_id)
-         {/* Ne rien faire de plus */}
-
-         void parse (XMLNode& _node, bool _withAttr = true)
-         {
-            string name = _node.getElementName();
-            THashAttributes attributes;
-
-            /// PARSING GESTION DES ATTRIBUTS ///
-            if (_withAttr)
-            {
-               _node.getAttributes(attributes);
-               this->setAttributes(attributes);
-
-               if (attributes.end() != attributes.find("src"))
-               { // Si une demande d'inclusion de fichier est trouvÃ©e.
-                  XMLNode _node_inc = getNodeIncludedFile(attributes["src"], name);
-                  parse (_node_inc);
-               }
-               attributes.clear();
-            }
-
-            /// PARSING POUR GESTION DES ENFANTS
-            if (!(_node.goToChildElement()))
-               WARNING("Le groupe de champ ne contient pas d'enfant !");
-            else
-            {
-               //////////////////////////////////////
-               do { // Parcours pour traitement.
-
-                  string name = _node.getElementName();
-                  attributes.clear();
-                  _node.getAttributes(attributes);
-
-                  if (name.compare(FieldGroup::GetName()) == 0)
-                  { createGroupAndParse<FieldGroup>(attributes, _node); continue; }
-
-                  if (name.compare(CField::GetName()) == 0)
-                  { createChildAndParse<CField>(attributes, _node); continue; }
-
-                  WARNING("Un groupe de champs ne peut contenir qu'un champ ou un autre groupe de champs !");
-
-               } while (_node.goToNextElement());
-               //////////////////////////////////////
-               _node.goToParentElement(); // Retour au parent
-            }
-         }
-
-         virtual ~FieldGroup(void)
-         {/* Ne rien faire de plus */ }
-
-   }; // class FieldGroup
-
-   typedef FieldGroup FieldDefinition ;
-
-}; // namespace XMLIOSERVER
-
-#endif // __FIELD_GROUP__
-
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp	(revision 111)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp	(revision 112)
@@ -66,3 +66,6 @@
 }; // namespace XMLIOSERVER
 
+DECLARE_GROUP(File);
+
+
 #endif // __CFILE__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/file_group.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/file_group.hpp	(revision 111)
+++ 	(revision )
@@ -1,71 +1,0 @@
-#ifndef __FILE_GROUP__
-#define __FILE_GROUP__
-
-namespace XMLIOSERVER
-{
-   class FileGroup : public GroupTemplate<CFile, FileAttribut>
-   {
-      public:
-
-         FileGroup(void) : GroupTemplate<CFile, FileAttribut>()
-         {/* Ne rien faire de plus */}
-         FileGroup(const string& _id) : GroupTemplate<CFile, FileAttribut>(_id)
-         {/* Ne rien faire de plus */}
-
-         void parse (XMLNode& _node, bool _withAttr = true)
-         {
-            string name = _node.getElementName();
-            THashAttributes attributes;
-
-            /// PARSING GESTION DES ATTRIBUTS ///
-            if (_withAttr)
-            {
-               _node.getAttributes(attributes);
-               this->setAttributes(attributes);
-
-               if (attributes.end() != attributes.find("src"))
-               { // Si une demande d'inclusion de fichier est trouvÃ©e.
-                  XMLNode _node_inc = getNodeIncludedFile(attributes["src"], name);
-                  parse (_node_inc);
-               }
-
-               attributes.clear();
-            }
-
-            /// PARSING POUR GESTION DES ENFANTS ///
-            if (!(_node.goToChildElement()))
-               WARNING("Le groupe de fichier ne contient pas d'enfant !");
-            else
-            {
-               //////////////////////////////////////
-               do { // Parcours  pour traitement.
-
-                  string name = _node.getElementName();
-                  attributes.clear();
-                  _node.getAttributes(attributes);
-
-                  if (name.compare(FileGroup::GetName()) == 0)
-                  { createGroupAndParse<FileGroup>(attributes, _node); continue; }
-
-                  if (name.compare(CFile::GetName()) == 0)
-                  { createChildAndParse<CFile>(attributes, _node) ; continue; }
-
-                  WARNING("Un groupe de fichiers ne peut contenir qu'un fichier ou un autre groupe de fichiers !");
-
-               } while (_node.goToNextElement());
-               //////////////////////////////////////
-               _node.goToParentElement(); // Retour au parent
-            }
-         }
-
-         virtual ~FileGroup(void)
-         {/* Ne rien faire de plus */ }
-
-   }; // class FileGroup
-
-   typedef FileGroup FileDefinition ;
-
-}; // namespace XMLIOSERVER
-
-#endif // __FILE_GROUP__
-
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp	(revision 111)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp	(revision 112)
@@ -25,4 +25,6 @@
 }; // namespace XMLIOSERVER
 
+DECLARE_GROUP(Grid);
+
 #endif // __GRID__
 
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/grid_group.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/grid_group.hpp	(revision 111)
+++ 	(revision )
@@ -1,71 +1,0 @@
-#ifndef __GRID_GROUP__
-#define __GRID_GROUP__
-
-namespace XMLIOSERVER
-{
-   class GridGroup : public GroupTemplate<CGrid, GridAttribut>
-   {
-      public:
-
-         GridGroup(void) : GroupTemplate<CGrid, GridAttribut>()
-         {/* Ne rien faire de plus */}
-         GridGroup(const string& _id) : GroupTemplate<CGrid, GridAttribut>(_id)
-         {/* Ne rien faire de plus */}
-
-         void parse (XMLNode& _node, bool _withAttr = true)
-         {
-            string name = _node.getElementName();
-            THashAttributes attributes;
-
-            /// PARSING GESTION DES ATTRIBUTS ///
-            if (_withAttr)
-            {
-               _node.getAttributes(attributes);
-               this->setAttributes(attributes);
-
-               if (attributes.end() != attributes.find("src"))
-               { // Si une demande d'inclusion de fichier est trouvÃ©e.
-                  XMLNode _node_inc = getNodeIncludedFile(attributes["src"], name);
-                  parse (_node_inc);
-               }
-               attributes.clear();
-            }
-
-            /// PARSING POUR GESTION DES ENFANTS
-            if (!(_node.goToChildElement()))
-               WARNING("Le groupe de grilles ne contient pas d'enfant !");
-            else
-            {
-               //////////////////////////////////////
-               do { // Parcours pour traitement.
-
-                  string name = _node.getElementName();
-                  attributes.clear();
-                  _node.getAttributes(attributes);
-
-                  if (name.compare(GridGroup::GetName()) == 0)
-                  { createGroupAndParse<GridGroup>(attributes, _node); continue; }
-
-                  if (name.compare(CGrid::GetName()) == 0)
-                  { createChildAndParse<CGrid>(attributes, _node); continue; }
-
-                  WARNING("Un groupe de grilles ne peut contenir qu'une grille ou un autre groupe de grilles !");
-
-               } while (_node.goToNextElement());
-               //////////////////////////////////////
-               _node.goToParentElement(); // Retour au parent
-            }
-         }
-
-         virtual ~GridGroup(void)
-         {/* Ne rien faire de plus */ }
-
-   }; // class GridGroup
-
-   typedef GridGroup GridDefinition ;
-
-}; // namespace XMLIOSERVER
-
-#endif // __GRID_GROUP__
-
-
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp	(revision 112)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp	(revision 112)
@@ -0,0 +1,201 @@
+#ifndef __XMLIO_GROUP_TEMPLATE__
+#define __XMLIO_GROUP_TEMPLATE__
+
+namespace XMLIOSERVER
+{
+   template <class T, class U>
+      class GroupTemplate : public ObjectTemplate<GroupTemplate<T, U> >, public U
+   {
+      public:
+
+         GroupTemplate(void) : ObjectTemplate<GroupTemplate<T, U> >(),  U(), childList(), groupList()
+         {/* Ne rien faire de plus */}
+         GroupTemplate(const string& _id) : ObjectTemplate<GroupTemplate<T, U> >(_id), U(), childList(), groupList()
+         {/* Ne rien faire de plus */}
+
+         /// Pour les groupes d'objets enfants ///
+
+         static string GetName(void) {return (T::GetName().append("_group")); }
+         static string GetDefName(void) {return (T::GetName().append("_definition")); }
+
+         virtual bool hasChild(void) const { return ((getNbGroup() + getNbChild())>0); }
+         virtual void printChild(ostream& out) const
+         {
+            // Ecriture des sous-groupes.
+            for(unsigned int i = 0; i < groupList.getVector().size() ; i++)
+               out << *(groupList.getVector()[i])  << std::endl;
+            // Ecriture des enfants.
+            for(unsigned int i = 0; i < childList.getVector().size() ; i++)
+               out << *(childList.getVector()[i]) << std::endl;
+         }
+
+         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0)
+         {
+            const vector<T*>&  childvect = childList.getVector();
+            const vector<GroupTemplate<T, U>*>& groupvect = groupList.getVector();
+
+            // On complÃšte les propres attributs du groupe.
+            if (_parent!= NULL) AttributRegistrar::addAttributes(*_parent);
+
+            for(unsigned int i = 0; i < childvect.size() ; i++)
+            // 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.
+               groupvect[i] -> resolveDescInheritance(this);
+         }
+
+         GroupTemplate<T, U>& createGroup(const string _id) throw (XMLIOUndefinedValueException)
+         {
+            GroupTemplate<T, U> &obj = GroupTemplate<T, U>::CreateObject(_id);
+            groupList.addObject(&obj);
+
+            return (obj);
+         }
+
+         GroupTemplate<T, U>& createGroup(void)
+         {
+            GroupTemplate<T, U>& obj = GroupTemplate<T, U>::CreateObject();
+            groupList.addObject(&obj);
+
+            return (obj);
+         }
+
+         GroupTemplate<T, U>& getGroup(const string _id) throw (XMLIOUndefinedValueException) { return (*groupList[_id]); }
+         bool hasGroup(const string _id) { return (groupList.hasMappedValue(_id)); }
+
+         const StrHashMap<GroupTemplate<T, U>* >& getGroupList(void) { return (groupList); }
+
+         size_t getNbGroup() const {return (groupList.getVectorSize()); }
+
+         /// Pour les objets enfants ///
+
+         T& createChild(const string _id) throw (XMLIOUndefinedValueException)
+         {
+            T& obj = ObjectTemplate<T>::CreateObject(_id);
+            childList.addObject(&obj);
+            return (obj);
+         }
+
+         T& createChild(void)
+         {
+            T& obj = ObjectTemplate<T>::CreateObject();
+            childList.addObject(&obj);
+            return (obj);
+         }
+
+         T& getChild(const string _id) throw (XMLIOUndefinedValueException) { return (*childList[_id]); }
+         bool hasChild(const string _id) { return (childList.hasMappedValue(_id)); }
+
+         const StrHashMap<T*>& getCurrentListChild(void) { return (childList); }
+         const vector<T*>& getCurrentVectorChild(void) { return (childList.getVector()); }
+
+         size_t getNbChild() const {return (childList.getVectorSize()); }
+
+         void getAllChildren(std::vector<T*>& _allc )
+         {
+            const vector<GroupTemplate<T, U>*>& groupvect = groupList.getVector();
+            _allc.insert (_allc.end(), getCurrentVectorChild().begin(), getCurrentVectorChild().end());
+
+            for(unsigned int i = 0; i < groupvect.size() ; i++)
+               groupvect[i] -> getAllChildren(_allc);
+         }
+
+         virtual ~GroupTemplate()
+         {
+            for (unsigned int i = 0; i < childList.getVector().size(); i++)
+               delete childList.getVector()[i];
+            for (unsigned int i = 0; i < groupList.getVector().size(); i++)
+               delete groupList.getVector()[i];
+         }
+
+      protected:
+
+
+         template <class W> void _parse (XMLNode& _node, bool _withAttr = true)
+         {
+            string name = _node.getElementName();
+            THashAttributes attributes;
+
+            /// PARSING GESTION DES ATTRIBUTS ///
+            if (_withAttr)
+            {
+               _node.getAttributes(attributes);
+               this->setAttributes(attributes);
+
+               if (attributes.end() != attributes.find("src"))
+               { // Si une demande d'inclusion de fichier est trouvÃ©e.
+                  XMLNode _node_inc = ObjectTemplate<GroupTemplate<T, U> >::getNodeIncludedFile(attributes["src"], name);
+                  _parse<W> (_node_inc);
+               }
+               attributes.clear();
+            }
+
+            /// PARSING POUR GESTION DES ENFANTS ///
+            if (!(_node.goToChildElement()))
+               WARNING("L'objet de type \""+W::GetName()+"\" ne contient pas d'enfant !");
+            else
+            {
+               do { // Parcours pour traitement.
+
+                  string name = _node.getElementName();
+                  attributes.clear(); _node.getAttributes(attributes);
+
+                  if (name.compare(W::GetName()) == 0) { createGroupAndParse<W>(attributes, _node); continue; }
+                  if (name.compare(T::GetName()) == 0) { createChildAndParse<T>(attributes, _node); continue; }
+
+                  WARNING("Un objet de type \""+W::GetName()+"\" ne peut contenir qu'un object de type \""+T::GetName()+"\" ou \""+W::GetName()+"\" !");
+
+               } while (_node.goToNextElement());
+               _node.goToParentElement(); // Retour au parent
+            }
+         }
+
+
+         template <class V> V* createGroupAndParse(THashAttributes& attributes, XMLNode& _node)
+         {
+            V* instance_ptr = NULL;
+            if (attributes.end() != attributes.find("id"))
+            {// Si l'identifiant est dÃ©fini.
+               if (V::HasObject(attributes["id"]))
+                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommÃ©e \""+attributes["id"]+"\" existe dÃ©jÃ , le second fera rÃ©fÃ©rence au premier par dÃ©faut !"); // TODO TODO
+               instance_ptr = (V*)(&createGroup(attributes["id"]));
+               instance_ptr->parse(_node);
+            }
+            else
+            {// Si l'identifiant n'est pas dÃ©fini.
+               instance_ptr = (V*)(&createGroup());
+               instance_ptr->parse(_node);
+            }
+            return (instance_ptr);
+         }
+
+         template <class V> V* createChildAndParse(THashAttributes& attributes, XMLNode& _node)
+         {
+            V* instance_ptr = NULL;
+            if (attributes.end() != attributes.find("id"))
+            {// Si l'identifiant est dÃ©fini.
+               if (V::HasObject(attributes["id"]))
+                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommÃ©e \""+attributes["id"]+"\" existe dÃ©jÃ , le second fera rÃ©fÃ©rence au premier par dÃ©faut !"); // TODO TODO
+               instance_ptr = (V*)(&createChild(attributes["id"]));
+               instance_ptr->parse(_node);
+            }
+            else
+            {// Si l'identifiant n'est pas dÃ©fini.
+               instance_ptr = (V*)(&createChild());
+               instance_ptr->parse(_node);
+            }
+            return (instance_ptr);
+         }
+
+      private :
+
+         StrHashMap<T> childList;
+         StrHashMap<GroupTemplate<T, U> > groupList;
+
+   }; // class GroupTemplate
+
+}// namespace XMLIOSERVER
+
+
+#endif // __XMLIO_GROUP_TEMPLATE__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/logger.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/logger.hpp	(revision 112)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/logger.hpp	(revision 112)
@@ -0,0 +1,123 @@
+#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>
+
+#include <Poco/AutoPtr.h>
+
+#include <csignal>
+
+#ifdef __GNUC__
+#include <execinfo.h>
+#include <cxxabi.h>
+#endif // __GNUC__
+
+// Classes utilisÃ©es issues de Poco
+using Poco::Logger;
+using Poco::PatternFormatter;
+using Poco::FormattingChannel;
+using Poco::ConsoleChannel;
+using Poco::FileChannel;
+using Poco::Message;
+
+using Poco::AutoPtr;
+
+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.
+            AutoPtr<PatternFormatter> pf = new PatternFormatter("[%Y-%m-%d %H:%M:%S] %t");
+            AutoPtr<ConsoleChannel> cc = new ConsoleChannel();
+            AutoPtr<FormattingChannel> pFCConsole = new FormattingChannel(pf);
+            pFCConsole->setChannel(cc);
+            pFCConsole->open();
+            Logger::create("ConsoleLogger", pFCConsole, Message::PRIO_INFORMATION);
+
+            signal(SIGSEGV, SigHandler);
+         }
+
+
+         static void ShowBTrace(std::ostream& out = std::clog)
+         {
+#ifdef __GNUC__
+            int status = 0;
+            string value;
+            void *stack_addrs[20] = {NULL};
+            size_t stack_depth = backtrace(stack_addrs, 20);
+            char **stack_strings = backtrace_symbols(stack_addrs, stack_depth);
+
+            out << "Trace : " << std::endl;
+            for (size_t i = 2, j = 0; i < stack_depth; i++)
+            {
+               value.assign(stack_strings[i]);
+               size_t bpos = value.find ('('), epos = value.find ('+');
+               if ((bpos != string::npos) and (epos != string::npos))
+               {
+                  char* demangled_name = abi::__cxa_demangle(value.substr(bpos+1, epos-bpos-1).c_str(), 0, 0, &status);
+                  if (status == 0) out << "   "  << ++j << " -> "  << (demangled_name) << std::endl;
+                  else out << "   "  << ++j << " -> "  << value.substr(bpos+1, epos-bpos-1) << std::endl;
+                  free(demangled_name);
+               }
+            }
+
+            free(stack_strings);
+#endif // __GNUC__
+         }
+
+         static void SigHandler(int _sigValue)
+         {
+            std::cerr << "============= Erreur =============" << std::endl;
+            std::cerr << "Signal " << _sigValue << " reÃ§u !" << std::endl;
+            ShowBTrace(std::cerr);
+            std::cerr << "==================================" << std::endl;
+            exit(EXIT_FAILURE);
+         }
+
+
+         static Logger & GetConsoleLogger(void) {return (Logger::get("ConsoleLogger"));}
+
+         ~ILogger(void)
+         { /* Ne rien faire de plus */ }
+
+   }; // class XMLIOLogger
+
+   // Initialisation de la classe de Logging
+   static ILogger LOGGER("xmlio.log");
+
+   /////////////////////////////////////////////////////////////////////
+   static unsigned int Indent = 0;
+   static const char*  Increm = "   ";
+
+   std::ostream& NIndent(std::ostream& out)
+   {
+      static unsigned int LineNB = 1;
+      out<< LineNB++ << ". ";
+      for(unsigned int i = 0;i < Indent; i++) out << Increm;
+      return(out);
+   }
+
+   std::ostream& IncIndent(std::ostream& out) { Indent++; return (NIndent(out)); }
+   std::ostream& DecEndl(std::ostream& out) { Indent--; return (out); }
+   /////////////////////////////////////////////////////////////////////
+
+}; // namespace XMLIOSERVER
+
+#define   ERROR(MSG)   (XMLIOSERVER::ILogger::GetConsoleLogger().error(MSG))
+#define   WARNING(MSG) (XMLIOSERVER::ILogger::GetConsoleLogger().warning(MSG))
+#define   INFO(MSG)    (XMLIOSERVER::ILogger::GetConsoleLogger().information(MSG))
+// A complÃ©ter.
+
+#endif // __XMLIO_LOGGER__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/main_cpp.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/main_cpp.cpp	(revision 111)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/main_cpp.cpp	(revision 112)
@@ -24,6 +24,4 @@
       Context::ResolveInheritance();
 
-      // On poursuit le traitement ...
-
       // On Ã©crit l'arborescence rÃ©sultante du traitement sur la sortie.
       Context::ShowTree(std::clog);
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/object_template.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/object_template.hpp	(revision 112)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/object_template.hpp	(revision 112)
@@ -0,0 +1,155 @@
+#ifndef __XMLIO_OBJECT_TEMPLATE__
+#define __XMLIO_OBJECT_TEMPLATE__
+
+#include "declare_attribut.hpp"
+#include "attribut_registrar.hpp"
+
+// Classes utilisÃ©es issues de la STL
+using std::pair;
+using std::string;
+using std::ostream;
+
+using XMLIOSERVER::StrHashMap;
+
+using XMLIOSERVER::XML::XMLNode;
+using XMLIOSERVER::XML::THashAttributes;
+
+namespace XMLIOSERVER
+{
+   template <class T>
+      class ObjectTemplate : public AbstractObject, public virtual AttributRegistrar
+   {
+      public :
+
+         friend ostream& operator<< (ostream& out, const T& c)
+         {
+            const AttributRegistrar &ar = c;
+
+            if (c.baseObject != NULL)
+               out <<  IncIndent << "<-- Reference resolved for the following "+ T::GetName() +" : \"" << c.baseObject->getId() << "\" -->" << DecEndl << std::endl;
+
+            if (c.hasChild())
+            {
+               out << IncIndent  << "<" << c.getName()   << c.printId() << ar << ">" << std::endl;
+               c.printChild(out); // << Ecriture des objets enfants ici.
+               out << NIndent    << "</" << c.getName()  << ">" << DecEndl;
+            }
+            else out << IncIndent << "<" << c.getName()  << c.printId() << ar << "/>" << DecEndl;
+
+            return (out);
+         }
+
+         string getName(void) const {return (T::GetName()); }
+
+         virtual T* getReference(void) const { return (NULL); }
+
+         virtual bool hasChild(void) const { return (false); }
+         virtual void printChild(ostream& out) const { /* Ne rien faire de plus */ }
+
+         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0) { addAttributes(*_parent); }
+         virtual void resolveRefInheritance(void)
+         {
+            std::set<T*> sset;
+            T* refer = (T*)this;
+            // On remonte le fil des hÃ©ritages par rÃ©fÃ©rence (Boucle infinie).
+            while((refer = refer->getReference()) != NULL)
+            {
+               if(sset.end() != sset.find(refer))
+               { WARNING ("DÃ©pendance circulaire stoppÃ©e pour l'objet de type "+T::GetName()+" sur \""+refer->getId()+"\" !"); break; }
+               addAttributes(*refer);
+               sset.insert(baseObject = refer);
+            }
+         }
+
+         virtual void parse (XMLNode& _node)
+         {
+            string name = _node.getElementName();
+            THashAttributes attributes;
+
+            /// PARSING GESTION DES ATTRIBUTS ///
+            _node.getAttributes(attributes);
+            this->setAttributes(attributes);
+            attributes.clear();
+
+            /// PARSING POUR GESION DES ENFANTS ///
+            // Rien Ã  faire.
+         }
+
+         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Ã©.
+            ObjectTemplate<T>::AllListObj[CurrContext].addObject(new T(_id));
+
+            return (ObjectTemplate<T>::GetObject(_id));
+         }
+
+         static T& CreateObject(void)
+         {
+            T* value = new T;
+            ObjectTemplate<T>::AllListObj[CurrContext].addObject(value);
+            return (*value);
+         }
+
+         static T& GetObject(const string _id) throw (XMLIOUndefinedValueException)
+         { return (*ObjectTemplate<T>::AllListObj[CurrContext][_id]); }
+
+         static bool HasObject(const string _id)
+         {
+            if(ObjectTemplate<T>::AllListObj.find(CurrContext) == ObjectTemplate<T>::AllListObj.end()) return false;
+            return (ObjectTemplate<T>::AllListObj[CurrContext].hasMappedValue(_id));
+         }
+
+         static const StrHashMap<T>& GetCurrentListObject(void) { return (AllListObj[CurrContext]); }
+         static HashMap<string, StrHashMap<T> >& GetAllListObject(void) { return (AllListObj); }
+
+         static void SetContext(const string& id){ ObjectTemplate<T>::CurrContext = id; }
+
+         static string& GetCurrentContextId(void) { return (CurrContext); }
+
+         virtual ~ObjectTemplate(void)
+         {/* Ne rien faire de plus */}
+
+      protected :
+
+         ObjectTemplate(void) : AbstractObject(), baseObject(NULL)
+         {/* Ne rien faire de plus */}
+         ObjectTemplate(const string& _id) : AbstractObject(_id), baseObject(NULL)
+         {/* Ne rien faire de plus */}
+
+         XML::XMLNode getNodeIncludedFile(const string& path, const string& _rootName)
+         {
+            ifstream istr( path.c_str() , ifstream::in );
+            return XML::XMLNode::CreateNode(istr, _rootName);
+         }
+
+         template <class V> static V* CreateInstanceAndParse( THashAttributes& attributes, XMLNode& _node, const char* defaultId, bool parseAttr = true )
+         {
+            V* instance_ptr = NULL; string did(defaultId);
+            if (defaultId != NULL)
+            {
+               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->parse(_node, parseAttr);
+            }
+            return (instance_ptr);
+         }
+
+      private :
+         T* baseObject;
+
+         static string CurrContext;
+         static HashMap<string, StrHashMap<T> > AllListObj;
+
+   };// class ObjectTemplate
+
+   template <class T> string ObjectTemplate<T>::CurrContext ;
+   template <class T> HashMap<string, StrHashMap<T> > ObjectTemplate<T>::AllListObj;
+
+}// namespace XMLIOSERVER
+
+#endif // __XMLIO_OBJECT_TEMPLATE__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xml_node.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xml_node.hpp	(revision 112)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/xml_node.hpp	(revision 112)
@@ -0,0 +1,170 @@
+#ifndef __XMLIO_XML_NODE__
+#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
+{
+   namespace XML
+   {
+
+      typedef HashMap<string, string> THashAttributes;
+
+      class XMLNode
+      {
+         public :
+
+            XMLNode(const string& _rootName) : rootName(_rootName)
+            { /* Ne rien faire de plus */}
+
+            static XMLNode CreateNode(istream& _istr, const string& _rootName)
+            {
+               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.
+                  node.pDoc = parser.parse(&src);
+                  node.setCNode(node.pDoc->documentElement());
+                  if (node.getElementName().compare(_rootName) != 0)
+                     throw XMLParsingException("L'Ã©lÃ©ment racine doit avoir pour valeur <" + _rootName + "> (\"" + node.getElementName() + "\" lue)");
+               }
+               else
+                  throw XMLIOStreamException("Impossible de lire le flux en entrÃ©e pour le parsing XML !");
+
+               return (node);
+            }
+
+            string getElementName(void) const
+            { string _str(this->getCNode()->nodeName()); return (_toLower(_str)); }
+
+            bool goToNextElement(void)
+            {
+               Node* nextElement = this->getCNode()->nextSibling();
+
+               // On parcourt la liste des "siblings" jusqu'Ã  trouver un Ã©lÃ©ment quelconque.
+               for(; ; nextElement = nextElement->nextSibling())
+                  if (IsPtrNull(nextElement)) break;
+                  else if (nextElement->nodeType() == 1)
+                  {// Si l'un des noeuds est un Ã©lÃ©ment...
+                     this->setCNode(nextElement) ;
+                     return (true);
+                  }
+               return (false);
+            }
+
+            bool goToChildElement(void)
+            {
+               Node* nextElement = this->getCNode()->firstChild();
+
+               // On parcourt la liste des enfants jusqu'Ã  trouver un Ã©lÃ©ment quelconque.
+               if (!IsPtrNull(nextElement))
+               {
+                  for(; ; nextElement = nextElement->nextSibling())
+                     if (IsPtrNull(nextElement)) break;
+                     else if (nextElement->nodeType() == 1)
+                     {// Si l'un des noeuds est un Ã©lÃ©ment...
+                        this->setCNode(nextElement) ;
+                        return (true);
+                     }
+                  return (false);
+               }
+
+               return (false);
+            }
+
+            bool goToParentElement(void)
+            {
+               // Pas de retour au parent si on est Ã  la racine.
+               if (!(this->getElementName().compare(rootName))) return (false);
+               this->setCNode(this->getCNode()->parentNode());
+               return (true);
+            }
+
+            bool getAttributes(THashAttributes& attributes) const
+            {
+
+               if(!this->getCNode()->hasAttributes()) return (false);
+               AutoPtr<NamedNodeMap> map = this->getCNode()->attributes();
+
+               for(unsigned int i = 0; i< map->length(); i++)
+               {
+                  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);
+               }
+
+               return (true);
+            }
+
+            ~XMLNode()
+            { /* Ne rien faire de plus */ }
+
+         protected :
+
+            Node* getCNode(void) const {return (this->cNode); }
+            void setCNode(Node* other) { this->cNode = other; }
+
+            static bool IsPtrNull(Node* ptr) {return (ptr==NULL);}
+
+         private :
+
+            string& _toLower(string& _str) const
+            {
+               for (unsigned int i = 0; i < _str.size(); i++)
+                  _str[i] = tolower(_str[i]);
+               return (_str);
+            }
+
+            AutoPtr<Document> pDoc;
+            Node*  cNode;
+
+            string rootName;
+
+      };// class XMLNode
+
+         }; // namespace XML
+
+};// namespace XMLIOSERVER
+
+
+#endif // __XMLIO_XML_NODE__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xml_parser.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xml_parser.hpp	(revision 112)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/xml_parser.hpp	(revision 112)
@@ -0,0 +1,50 @@
+#ifndef __XMLIO_XML_PARSER__
+#define __XMLIO_XML_PARSER__
+
+#include <stdlib.h>
+
+// Utilisation de la STL
+using std::string;
+
+namespace XMLIOSERVER
+{
+   namespace XML
+   {
+      using XMLIOSERVER::Context;
+
+      class XMLParser
+      {
+         public :
+
+            static void Parse(XMLNode& _node)
+            {
+               THashAttributes attributes;
+
+               _node.goToChildElement(); // On se place sur le premier Ã©lÃ©ment enfant du noeud racine.
+               atexit (&Context::FreeMemory); // Pour supprimer la mÃ©moire liÃ©e Ã  l'allocation dynamique en fin d'exÃ©cution du programme.
+
+               do {
+                 // Traitement de l'identifiant
+                  _node.getAttributes(attributes);
+
+                  if (attributes.end() == attributes.find("id"))
+                  { WARNING("Le context ne sera pas traitÃ© car il n'est pas identifiÃ© !"); continue; }
+
+                  if( Context::GetAllListObject().find(attributes["id"]) != Context::GetAllListObject().end())
+                  { WARNING("Le context ne sera pas traitÃ© car il existe dÃ©jÃ  un autre context possÃ©dant le mÃªme nom !"); continue; }
+
+                  Context::SetCurrentContext(attributes["id"]);
+                  Context& context = Context::CreateObject(attributes["id"]);
+
+                  context.parse(_node);
+                  attributes.clear();
+
+               } while (_node.goToNextElement());
+            }
+      }; // class XMLParser
+   }; // namespace XML
+
+};// namespace XMLIOSERVER
+
+
+#endif // __XMLIO_XML_PARSER__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp	(revision 111)
+++ XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp	(revision 112)
@@ -21,10 +21,10 @@
 
 /// EntÃªtes crÃ©Ã©s dans le cadre du projet XMLIOSERVER. ///
-#include "xmlio_exception.hpp"
-#include "xmlio_logger.hpp"
-#include "xmlio_container.hpp"
-#include "xmlio_object.hpp"
-#include "xmlio_xml_node.hpp"
-#include "xmlio_object_template.hpp"
+#include "exception.hpp"
+#include "logger.hpp"
+#include "container.hpp"
+#include "abstract_object.hpp"
+#include "xml_node.hpp"
+#include "object_template.hpp"
 
 // Gestion des attributs des objets.
@@ -34,21 +34,18 @@
 #include "file_attribut.hpp"
 
-#include "xmlio_group_template.hpp"
+#include "group_template.hpp"
+#include "declare_group.hpp"
 
 // Prise en charge des champs...
 #include "field.hpp"
-#include "field_group.hpp"
 // Prise en charge des fichiers ...
 #include "file.hpp"
-#include "file_group.hpp"
 // Prise en charge des axes ...
 #include "axis.hpp"
-#include "axis_group.hpp"
 // Prise en charge des grilles ...
 #include "grid.hpp"
-#include "grid_group.hpp"
 
 #include "context.hpp"
-#include "xmlio_xml_parser.hpp"
+#include "xml_parser.hpp"
 
 #endif // __XMLIO__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_c_interface.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_c_interface.cpp	(revision 111)
+++ 	(revision )
@@ -1,13 +1,0 @@
-/*using namespace XMLIOSERVER;
-using namespace XMLIOSERVER::XML;
-using namespace std;
-
-extern "C"
-{ // DÃ©but du code C
-   
-   typedef void *XMLIOhandle;
-   
-   // VIDE TEMPORAIREMENT
-   
-}*/
-
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_container.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_container.hpp	(revision 111)
+++ 	(revision )
@@ -1,102 +1,0 @@
-#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["+kval+"] invalide.");
-            return (find(kval)->second);
-         }
-
-         bool hasMappedValue(const Key& kval) {return (find(kval) != this->end());}
-
-         const vector<Mapped*>& getVector(void) const { 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) // Non testÃ©
-         { Mapped* element = find(kval)->second; removeValue(element); this->erase(kval); }
-
-         void removeValue(const Mapped* element) // Non testÃ©
-         {
-            for (int i = 0; i < this->_elemList.size(); i++)
-               if (*this->_elemList[i] == element )
-                  this->_elemList.erase(this->_elemList.begin()+i);
-
-            delete element;
-         }
-
-      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 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 */}
-
-   }; // class StrHashMap
-
-}; // namespace XMLIOSERVER
-
-#endif // __XMLIO_CONTAINER__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_exception.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_exception.hpp	(revision 111)
+++ 	(revision )
@@ -1,79 +1,0 @@
-#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 XMLIOIncompatibleTypeException : public XMLIOException
-   {
-      public :
-         XMLIOIncompatibleTypeException(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/src/XMLIO/xmlio_group_template.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_group_template.hpp	(revision 111)
+++ 	(revision )
@@ -1,160 +1,0 @@
-#ifndef __XMLIO_GROUP_TEMPLATE__
-#define __XMLIO_GROUP_TEMPLATE__
-
-namespace XMLIOSERVER
-{
-   template <class T, class U>
-      class GroupTemplate : public ObjectTemplate<GroupTemplate<T, U> >, public U
-   {
-      public:
-
-         GroupTemplate(void) : ObjectTemplate<GroupTemplate<T, U> >(),  U(), childList(), groupList()
-         {/* Ne rien faire de plus */}
-         GroupTemplate(const string& _id) : ObjectTemplate<GroupTemplate<T, U> >(_id), U(), childList(), groupList()
-         {/* Ne rien faire de plus */}
-
-         /// Pour les groupes d'objets enfants ///
-
-         static string GetName(void) {return (T::GetName().append("_group")); }
-         static string GetDefName(void) {return (T::GetName().append("_definition")); }
-
-         virtual bool hasChild(void) const { return ((getNbGroup() + getNbChild())>0); }
-         virtual void printChild(ostream& out) const
-         {
-            // Ecriture des sous-groupes.
-            for(unsigned int i = 0; i < groupList.getVector().size() ; i++)
-               out << *(groupList.getVector()[i])  << std::endl;
-            // Ecriture des enfants.
-            for(unsigned int i = 0; i < childList.getVector().size() ; i++)
-               out << *(childList.getVector()[i]) << std::endl;
-         }
-
-         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0)
-         {
-            const vector<T*>&  childvect = childList.getVector();
-            const vector<GroupTemplate<T, U>*>& groupvect = groupList.getVector();
-
-            // On complÃšte les propres attributs du groupe.
-            if (_parent!= NULL) AttributRegistrar::addAttributes(*_parent);
-
-            for(unsigned int i = 0; i < childvect.size() ; i++)
-            // 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.
-               groupvect[i] -> resolveDescInheritance(this);
-         }
-
-         GroupTemplate<T, U>& createGroup(const string _id) throw (XMLIOUndefinedValueException)
-         {
-            GroupTemplate<T, U> &obj = GroupTemplate<T, U>::CreateObject(_id);
-            groupList.addObject(&obj);
-
-            return (obj);
-         }
-
-         GroupTemplate<T, U>& createGroup(void)
-         {
-            GroupTemplate<T, U>& obj = GroupTemplate<T, U>::CreateObject();
-            groupList.addObject(&obj);
-
-            return (obj);
-         }
-
-         GroupTemplate<T, U>& getGroup(const string _id) throw (XMLIOUndefinedValueException) { return (*groupList[_id]); }
-         bool hasGroup(const string _id) { return (groupList.hasMappedValue(_id)); }
-
-         const StrHashMap<GroupTemplate<T, U>* >& getGroupList(void) { return (groupList); }
-
-         size_t getNbGroup() const {return (groupList.getVectorSize()); }
-
-         /// Pour les objets enfants ///
-
-         T& createChild(const string _id) throw (XMLIOUndefinedValueException)
-         {
-            T& obj = ObjectTemplate<T>::CreateObject(_id);
-            childList.addObject(&obj);
-            return (obj);
-         }
-
-         T& createChild(void)
-         {
-            T& obj = ObjectTemplate<T>::CreateObject();
-            childList.addObject(&obj);
-            return (obj);
-         }
-
-         T& getChild(const string _id) throw (XMLIOUndefinedValueException) { return (*childList[_id]); }
-         bool hasChild(const string _id) { return (childList.hasMappedValue(_id)); }
-
-         const StrHashMap<T*>& getCurrentListChild(void) { return (childList); }
-         const vector<T*>& getCurrentVectorChild(void) { return (childList.getVector()); }
-
-         size_t getNbChild() const {return (childList.getVectorSize()); }
-
-         void getAllChildren(std::vector<T*>& _allc )
-         {
-            const vector<GroupTemplate<T, U>*>& groupvect = groupList.getVector();
-            _allc.insert (_allc.end(), getCurrentVectorChild().begin(), getCurrentVectorChild().end());
-
-            for(unsigned int i = 0; i < groupvect.size() ; i++)
-               groupvect[i] -> getAllChildren(_allc);
-         }
-
-         virtual ~GroupTemplate()
-         {
-            for (unsigned int i = 0; i < childList.getVector().size(); i++)
-               delete childList.getVector()[i];
-            for (unsigned int i = 0; i < groupList.getVector().size(); i++)
-               delete groupList.getVector()[i];
-         }
-
-      protected:
-
-         template <class V> V* createGroupAndParse(THashAttributes& attributes, XMLNode& _node)
-         {
-            V* instance_ptr = NULL;
-            if (attributes.end() != attributes.find("id"))
-            {// Si l'identifiant est dÃ©fini.
-               if (V::HasObject(attributes["id"]))
-                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommÃ©e \""+attributes["id"]+"\" existe dÃ©jÃ , le second fera rÃ©fÃ©rence au premier par dÃ©faut !"); // TODO TODO
-               instance_ptr = (V*)(&createGroup(attributes["id"]));
-               instance_ptr->parse(_node);
-            }
-            else
-            {// Si l'identifiant n'est pas dÃ©fini.
-               instance_ptr = (V*)(&createGroup());
-               instance_ptr->parse(_node);
-            }
-            return (instance_ptr);
-         }
-
-         template <class V> V* createChildAndParse(THashAttributes& attributes, XMLNode& _node)
-         {
-            V* instance_ptr = NULL;
-            if (attributes.end() != attributes.find("id"))
-            {// Si l'identifiant est dÃ©fini.
-               if (V::HasObject(attributes["id"]))
-                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommÃ©e \""+attributes["id"]+"\" existe dÃ©jÃ , le second fera rÃ©fÃ©rence au premier par dÃ©faut !"); // TODO TODO
-               instance_ptr = (V*)(&createChild(attributes["id"]));
-               instance_ptr->parse(_node);
-            }
-            else
-            {// Si l'identifiant n'est pas dÃ©fini.
-               instance_ptr = (V*)(&createChild());
-               instance_ptr->parse(_node);
-            }
-            return (instance_ptr);
-         }
-
-         StrHashMap<T> childList;
-         StrHashMap<GroupTemplate<T, U> > groupList;
-
-   }; // class GroupTemplate
-
-
-
-}// namespace XMLIOSERVER
-
-
-#endif // __XMLIO_GROUP_TEMPLATE__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_logger.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_logger.hpp	(revision 111)
+++ 	(revision )
@@ -1,123 +1,0 @@
-#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>
-
-#include <Poco/AutoPtr.h>
-
-#include <csignal>
-
-#ifdef __GNUC__
-#include <execinfo.h>
-#include <cxxabi.h>
-#endif // __GNUC__
-
-// Classes utilisÃ©es issues de Poco
-using Poco::Logger;
-using Poco::PatternFormatter;
-using Poco::FormattingChannel;
-using Poco::ConsoleChannel;
-using Poco::FileChannel;
-using Poco::Message;
-
-using Poco::AutoPtr;
-
-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.
-            AutoPtr<PatternFormatter> pf = new PatternFormatter("[%Y-%m-%d %H:%M:%S] %t");
-            AutoPtr<ConsoleChannel> cc = new ConsoleChannel();
-            AutoPtr<FormattingChannel> pFCConsole = new FormattingChannel(pf);
-            pFCConsole->setChannel(cc);
-            pFCConsole->open();
-            Logger::create("ConsoleLogger", pFCConsole, Message::PRIO_INFORMATION);
-
-            signal(SIGSEGV, SigHandler);
-         }
-
-
-         static void ShowBTrace(std::ostream& out = std::clog)
-         {
-#ifdef __GNUC__
-            int status = 0;
-            string value;
-            void *stack_addrs[20] = {NULL};
-            size_t stack_depth = backtrace(stack_addrs, 20);
-            char **stack_strings = backtrace_symbols(stack_addrs, stack_depth);
-
-            out << "Trace : " << std::endl;
-            for (size_t i = 2, j = 0; i < stack_depth; i++)
-            {
-               value.assign(stack_strings[i]);
-               size_t bpos = value.find ('('), epos = value.find ('+');
-               if ((bpos != string::npos) and (epos != string::npos))
-               {
-                  char* demangled_name = abi::__cxa_demangle(value.substr(bpos+1, epos-bpos-1).c_str(), 0, 0, &status);
-                  if (status == 0) out << "   "  << ++j << " -> "  << (demangled_name) << std::endl;
-                  else out << "   "  << ++j << " -> "  << value.substr(bpos+1, epos-bpos-1) << std::endl;
-                  free(demangled_name);
-               }
-            }
-
-            free(stack_strings);
-#endif // __GNUC__
-         }
-
-         static void SigHandler(int _sigValue)
-         {
-            std::cerr << "============= Erreur =============" << std::endl;
-            std::cerr << "Signal " << _sigValue << " reÃ§u !" << std::endl;
-            ShowBTrace(std::cerr);
-            std::cerr << "==================================" << std::endl;
-            exit(EXIT_FAILURE);
-         }
-
-
-         static Logger & GetConsoleLogger(void) {return (Logger::get("ConsoleLogger"));}
-
-         ~ILogger(void)
-         { /* Ne rien faire de plus */ }
-
-   }; // class XMLIOLogger
-
-   // Initialisation de la classe de Logging
-   static ILogger LOGGER("xmlio.log");
-
-   /////////////////////////////////////////////////////////////////////
-   static unsigned int Indent = 0;
-   static const char*  Increm = "   ";
-
-   std::ostream& NIndent(std::ostream& out)
-   {
-      static unsigned int LineNB = 1;
-      out<< LineNB++ << ". ";
-      for(unsigned int i = 0;i < Indent; i++) out << Increm;
-      return(out);
-   }
-
-   std::ostream& IncIndent(std::ostream& out) { Indent++; return (NIndent(out)); }
-   std::ostream& DecEndl(std::ostream& out) { Indent--; return (out); }
-   /////////////////////////////////////////////////////////////////////
-
-}; // namespace XMLIOSERVER
-
-#define   ERROR(MSG)   (XMLIOSERVER::ILogger::GetConsoleLogger().error(MSG))
-#define   WARNING(MSG) (XMLIOSERVER::ILogger::GetConsoleLogger().warning(MSG))
-#define   INFO(MSG)    (XMLIOSERVER::ILogger::GetConsoleLogger().information(MSG))
-// A complÃ©ter.
-
-#endif // __XMLIO_LOGGER__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_object.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_object.hpp	(revision 111)
+++ 	(revision )
@@ -1,58 +1,0 @@
-#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) 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)
-         {/* Ne rien faire de plus */}
-      
-      protected :
-
-            
-      private :
-      
-         string id ;
-         bool IdDefined ;
-      
-   };// class AbstractObject
-   
-}// namespace XMLIOSERVER
-
-#endif // __XMLIO_OBJECT__   
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_object_template.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_object_template.hpp	(revision 111)
+++ 	(revision )
@@ -1,155 +1,0 @@
-#ifndef __XMLIO_OBJECT_TEMPLATE__
-#define __XMLIO_OBJECT_TEMPLATE__
-
-#include "declare_attribut.hpp"
-#include "attribut_registrar.hpp"
-
-// Classes utilisÃ©es issues de la STL
-using std::pair;
-using std::string;
-using std::ostream;
-
-using XMLIOSERVER::StrHashMap;
-
-using XMLIOSERVER::XML::XMLNode;
-using XMLIOSERVER::XML::THashAttributes;
-
-namespace XMLIOSERVER
-{
-   template <class T>
-      class ObjectTemplate : public AbstractObject, public virtual AttributRegistrar
-   {
-      public :
-
-         friend ostream& operator<< (ostream& out, const T& c)
-         {
-            const AttributRegistrar &ar = c;
-
-            if (c.baseObject != NULL)
-               out <<  IncIndent << "<-- Reference resolved for the following "+ T::GetName() +" : \"" << c.baseObject->getId() << "\" -->" << DecEndl << std::endl;
-
-            if (c.hasChild())
-            {
-               out << IncIndent  << "<" << c.getName()   << c.printId() << ar << ">" << std::endl;
-               c.printChild(out); // << Ecriture des objets enfants ici.
-               out << NIndent    << "</" << c.getName()  << ">" << DecEndl;
-            }
-            else out << IncIndent << "<" << c.getName()  << c.printId() << ar << "/>" << DecEndl;
-
-            return (out);
-         }
-
-         string getName(void) const {return (T::GetName()); }
-
-         virtual T* getReference(void) const { return (NULL); }
-
-         virtual bool hasChild(void) const { return (false); }
-         virtual void printChild(ostream& out) const { /* Ne rien faire de plus */ }
-
-         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0) { addAttributes(*_parent); }
-         virtual void resolveRefInheritance(void)
-         {
-            std::set<T*> sset;
-            T* refer = (T*)this;
-            // On remonte le fil des hÃ©ritages par rÃ©fÃ©rence (Boucle infinie).
-            while((refer = refer->getReference()) != NULL)
-            {
-               if(sset.end() != sset.find(refer))
-               { WARNING ("DÃ©pendance circulaire stoppÃ©e pour l'objet de type "+T::GetName()+" sur \""+refer->getId()+"\" !"); break; }
-               addAttributes(*refer);
-               sset.insert(baseObject = refer);
-            }
-         }
-
-         virtual void parse (XMLNode& _node)
-         {
-            string name = _node.getElementName();
-            THashAttributes attributes;
-
-            /// PARSING GESTION DES ATTRIBUTS ///
-            _node.getAttributes(attributes);
-            this->setAttributes(attributes);
-            attributes.clear();
-
-            /// PARSING POUR GESION DES ENFANTS ///
-            // Rien Ã  faire.
-         }
-
-         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Ã©.
-            ObjectTemplate<T>::AllListObj[CurrContext].addObject(new T(_id));
-
-            return (ObjectTemplate<T>::GetObject(_id));
-         }
-
-         static T& CreateObject(void)
-         {
-            T* value = new T;
-            ObjectTemplate<T>::AllListObj[CurrContext].addObject(value);
-            return (*value);
-         }
-
-         static T& GetObject(const string _id) throw (XMLIOUndefinedValueException)
-         { return (*ObjectTemplate<T>::AllListObj[CurrContext][_id]); }
-
-         static bool HasObject(const string _id)
-         {
-            if(ObjectTemplate<T>::AllListObj.find(CurrContext) == ObjectTemplate<T>::AllListObj.end()) return false;
-            return (ObjectTemplate<T>::AllListObj[CurrContext].hasMappedValue(_id));
-         }
-
-         static const StrHashMap<T>& GetCurrentListObject(void) { return (AllListObj[CurrContext]); }
-         static HashMap<string, StrHashMap<T> >& GetAllListObject(void) { return (AllListObj); }
-
-         static void SetContext(const string& id){ ObjectTemplate<T>::CurrContext = id; }
-
-         static string& GetCurrentContextId(void) { return (CurrContext); }
-
-         virtual ~ObjectTemplate(void)
-         {/* Ne rien faire de plus */}
-
-      protected :
-
-         ObjectTemplate(void) : AbstractObject(), baseObject(NULL)
-         {/* Ne rien faire de plus */}
-         ObjectTemplate(const string& _id) : AbstractObject(_id), baseObject(NULL)
-         {/* Ne rien faire de plus */}
-
-         XML::XMLNode getNodeIncludedFile(const string& path, const string& _rootName)
-         {
-            ifstream istr( path.c_str() , ifstream::in );
-            return XML::XMLNode::CreateNode(istr, _rootName);
-         }
-
-         template <class V> static V* CreateInstanceAndParse( THashAttributes& attributes, XMLNode& _node, const char* defaultId, bool parseAttr = true )
-         {
-            V* instance_ptr = NULL; string did(defaultId);
-            if (defaultId != NULL)
-            {
-               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->parse(_node, parseAttr);
-            }
-            return (instance_ptr);
-         }
-
-      private :
-         T* baseObject;
-
-         static string CurrContext;
-         static HashMap<string, StrHashMap<T> > AllListObj;
-
-   };// class ObjectTemplate
-
-   template <class T> string ObjectTemplate<T>::CurrContext ;
-   template <class T> HashMap<string, StrHashMap<T> > ObjectTemplate<T>::AllListObj;
-
-}// namespace XMLIOSERVER
-
-#endif // __XMLIO_OBJECT_TEMPLATE__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_xml_node.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_xml_node.hpp	(revision 111)
+++ 	(revision )
@@ -1,170 +1,0 @@
-#ifndef __XMLIO_XML_NODE__
-#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
-{
-   namespace XML
-   {
-
-      typedef HashMap<string, string> THashAttributes;
-
-      class XMLNode
-      {
-         public :
-
-            XMLNode(const string& _rootName) : rootName(_rootName)
-            { /* Ne rien faire de plus */}
-
-            static XMLNode CreateNode(istream& _istr, const string& _rootName)
-            {
-               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.
-                  node.pDoc = parser.parse(&src);
-                  node.setCNode(node.pDoc->documentElement());
-                  if (node.getElementName().compare(_rootName) != 0)
-                     throw XMLParsingException("L'Ã©lÃ©ment racine doit avoir pour valeur <" + _rootName + "> (\"" + node.getElementName() + "\" lue)");
-               }
-               else
-                  throw XMLIOStreamException("Impossible de lire le flux en entrÃ©e pour le parsing XML !");
-
-               return (node);
-            }
-
-            string getElementName(void) const
-            { string _str(this->getCNode()->nodeName()); return (_toLower(_str)); }
-
-            bool goToNextElement(void)
-            {
-               Node* nextElement = this->getCNode()->nextSibling();
-
-               // On parcourt la liste des "siblings" jusqu'Ã  trouver un Ã©lÃ©ment quelconque.
-               for(; ; nextElement = nextElement->nextSibling())
-                  if (IsPtrNull(nextElement)) break;
-                  else if (nextElement->nodeType() == 1)
-                  {// Si l'un des noeuds est un Ã©lÃ©ment...
-                     this->setCNode(nextElement) ;
-                     return (true);
-                  }
-               return (false);
-            }
-
-            bool goToChildElement(void)
-            {
-               Node* nextElement = this->getCNode()->firstChild();
-
-               // On parcourt la liste des enfants jusqu'Ã  trouver un Ã©lÃ©ment quelconque.
-               if (!IsPtrNull(nextElement))
-               {
-                  for(; ; nextElement = nextElement->nextSibling())
-                     if (IsPtrNull(nextElement)) break;
-                     else if (nextElement->nodeType() == 1)
-                     {// Si l'un des noeuds est un Ã©lÃ©ment...
-                        this->setCNode(nextElement) ;
-                        return (true);
-                     }
-                  return (false);
-               }
-
-               return (false);
-            }
-
-            bool goToParentElement(void)
-            {
-               // Pas de retour au parent si on est Ã  la racine.
-               if (!(this->getElementName().compare(rootName))) return (false);
-               this->setCNode(this->getCNode()->parentNode());
-               return (true);
-            }
-
-            bool getAttributes(THashAttributes& attributes) const
-            {
-
-               if(!this->getCNode()->hasAttributes()) return (false);
-               AutoPtr<NamedNodeMap> map = this->getCNode()->attributes();
-
-               for(unsigned int i = 0; i< map->length(); i++)
-               {
-                  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);
-               }
-
-               return (true);
-            }
-
-            ~XMLNode()
-            { /* Ne rien faire de plus */ }
-
-         protected :
-
-            Node* getCNode(void) const {return (this->cNode); }
-            void setCNode(Node* other) { this->cNode = other; }
-
-            static bool IsPtrNull(Node* ptr) {return (ptr==NULL);}
-
-         private :
-
-            string& _toLower(string& _str) const
-            {
-               for (unsigned int i = 0; i < _str.size(); i++)
-                  _str[i] = tolower(_str[i]);
-               return (_str);
-            }
-
-            AutoPtr<Document> pDoc;
-            Node*  cNode;
-
-            string rootName;
-
-      };// class XMLNode
-
-         }; // namespace XML
-
-};// namespace XMLIOSERVER
-
-
-#endif // __XMLIO_XML_NODE__
Index: XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_xml_parser.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_xml_parser.hpp	(revision 111)
+++ 	(revision )
@@ -1,50 +1,0 @@
-#ifndef __XMLIO_XML_PARSER__
-#define __XMLIO_XML_PARSER__
-
-#include <stdlib.h>
-
-// Utilisation de la STL
-using std::string;
-
-namespace XMLIOSERVER
-{
-   namespace XML
-   {
-      using XMLIOSERVER::Context;
-
-      class XMLParser
-      {
-         public :
-
-            static void Parse(XMLNode& _node)
-            {
-               THashAttributes attributes;
-
-               _node.goToChildElement(); // On se place sur le premier Ã©lÃ©ment enfant du noeud racine.
-               atexit (&Context::FreeMemory); // Pour supprimer la mÃ©moire liÃ©e Ã  l'allocation dynamique en fin d'exÃ©cution du programme.
-
-               do {
-                 // Traitement de l'identifiant
-                  _node.getAttributes(attributes);
-
-                  if (attributes.end() == attributes.find("id"))
-                  { WARNING("Le context ne sera pas traitÃ© car il n'est pas identifiÃ© !"); continue; }
-
-                  if( Context::GetAllListObject().find(attributes["id"]) != Context::GetAllListObject().end())
-                  { WARNING("Le context ne sera pas traitÃ© car il existe dÃ©jÃ  un autre context possÃ©dant le mÃªme nom !"); continue; }
-
-                  Context::SetCurrentContext(attributes["id"]);
-                  Context& context = Context::CreateObject(attributes["id"]);
-
-                  context.parse(_node);
-                  attributes.clear();
-
-               } while (_node.goToNextElement());
-            }
-      }; // class XMLParser
-   }; // namespace XML
-
-};// namespace XMLIOSERVER
-
-
-#endif // __XMLIO_XML_PARSER__
