Index: XMLIO_V2/dev/dev_rv/README
===================================================================
--- XMLIO_V2/dev/dev_rv/README	(revision 90)
+++ XMLIO_V2/dev/dev_rv/README	(revision 91)
@@ -2,8 +2,2 @@
 
 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/context.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/context.hpp	(revision 90)
+++ XMLIO_V2/dev/dev_rv/context.hpp	(revision 91)
@@ -12,5 +12,12 @@
          {/* Ne rien faire de plus */}               
          Context(const string& _id) : ObjectTemplate<Context>(_id)
-         {/* Ne rien faire de plus */}   
+         {/* Ne rien faire de plus */}
+         
+         static void SetCurrentContext(const string& id)
+         {
+            // On modifie le context courrant pour tout les ObjectTemplate
+            FieldGroup::SetContext(id);
+            Field::SetContext(id);
+         }
          
          void parse (XMLNode& _node)
@@ -30,5 +37,4 @@
                             
                   string name = _node.getElementName();
-                  std::cout << name << std::endl;
                   attributes.clear();
                   _node.getAttributes(attributes);   
Index: XMLIO_V2/dev/dev_rv/field.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/field.hpp	(revision 90)
+++ XMLIO_V2/dev/dev_rv/field.hpp	(revision 91)
@@ -1,4 +1,6 @@
 #ifndef __FIELD__
 #define __FIELD__
+
+using XMLIOSERVER::XML::XMLNode;
 
 namespace XMLIOSERVER
Index: XMLIO_V2/dev/dev_rv/field_attribut.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/field_attribut.hpp	(revision 90)
+++ XMLIO_V2/dev/dev_rv/field_attribut.hpp	(revision 91)
@@ -30,5 +30,5 @@
          { /* Ne rien faire de plus */ }
                  
-         // TODO DÃ©finir un constructeur par copie au lieu de registerAllAttributes (Ã©ventuellement)
+         // TODO Peut-Ãªtre dÃ©finir un constructeur par copie au lieu de registerAllAttributes (Ã©ventuellement)
          
          virtual void registerAllAttributes(void)
Index: XMLIO_V2/dev/dev_rv/field_group.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/field_group.hpp	(revision 90)
+++ XMLIO_V2/dev/dev_rv/field_group.hpp	(revision 91)
@@ -2,13 +2,16 @@
 #define __FIELD_GROUP__
 
+
+using XMLIOSERVER::XML::THashAttributes;
+
 namespace XMLIOSERVER
 {   
-   class FieldGroup : public GroupTemplate<Field>, public FieldAttribut
+   class FieldGroup : public GroupTemplate<Field, FieldAttribut>
    {
       public:
       
-         FieldGroup(void) : GroupTemplate<Field>(), FieldAttribut()
+         FieldGroup(void) : GroupTemplate<Field, FieldAttribut>()
          {/* Ne rien faire de plus */}               
-         FieldGroup(const string& _id) : GroupTemplate<Field>(_id), FieldAttribut()
+         FieldGroup(const string& _id) : GroupTemplate<Field, FieldAttribut>(_id)
          {/* Ne rien faire de plus */}
          
Index: XMLIO_V2/dev/dev_rv/main.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/main.cpp	(revision 90)
+++ XMLIO_V2/dev/dev_rv/main.cpp	(revision 91)
@@ -9,11 +9,5 @@
 	try
 	{
-		// Tests de la classe StrHashMap :
-		//StrHashMap<AbstractObject>::CLASS_TEST();
-		//ObjectTemplate<AbstractObject>::CLASS_TEST();
-		//GroupTemplate<AbstractObject>::CLASS_TEST();
-		XMLParser::CLASS_TEST();
-
-            
+		XMLParser::CLASS_TEST();            
 		// Code Ã  executer ici
 	}
Index: XMLIO_V2/dev/dev_rv/xmlio.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/xmlio.hpp	(revision 90)
+++ XMLIO_V2/dev/dev_rv/xmlio.hpp	(revision 91)
@@ -27,18 +27,14 @@
 // Concernant les attributs ...
 #include "field_attribut.hpp"
-
 #include "xmlio_object.hpp"
+#include "xmlio_xml_node.hpp"
+#include "xmlio_object_template.hpp"
+#include "field.hpp"      
+#include "xmlio_group_template.hpp"      
+#include "field_group.hpp"      
+#include "context.hpp"
+#include "xmlio_xml_parser.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" 
 
 
Index: XMLIO_V2/dev/dev_rv/xmlio_container.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/xmlio_container.hpp	(revision 90)
+++ XMLIO_V2/dev/dev_rv/xmlio_container.hpp	(revision 91)
@@ -81,8 +81,8 @@
          
          bool addObject(Mapped& element)
-         { if(element.hasId()) return(addValue(element.getId(), element));   return(addValue(element));   }
+         { if(element.hasId()) return(addValue(element.getId(), element));   return(addValue(element)); }
          
          bool addPtrObject(Mapped element)
-         { if(element->hasId()) return(addValue(element->getId(), element));   return(addValue(element));   }
+         { if(element->hasId()) return(addValue(element->getId(), element));   return(addValue(element)); }
          
          bool removeObject(const string& kval)
@@ -95,30 +95,4 @@
          {/* 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
             
Index: XMLIO_V2/dev/dev_rv/xmlio_group_template.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/xmlio_group_template.hpp	(revision 90)
+++ XMLIO_V2/dev/dev_rv/xmlio_group_template.hpp	(revision 91)
@@ -4,12 +4,12 @@
 namespace XMLIOSERVER
 {
-   template <class T>
-      class GroupTemplate : public ObjectTemplate<GroupTemplate<T> >
+   template <class T, class U>
+      class GroupTemplate : public ObjectTemplate<GroupTemplate<T, U> >, public U
    {
       public:
             
-         GroupTemplate(void) : ObjectTemplate<GroupTemplate<T> >(), childList(), groupList()
+         GroupTemplate(void) : ObjectTemplate<GroupTemplate<T, U> >(), childList(), groupList(), U()
          {/* Ne rien faire de plus */}               
-         GroupTemplate(const string& _id) : ObjectTemplate<GroupTemplate<T> >(_id), childList(), groupList()
+         GroupTemplate(const string& _id) : ObjectTemplate<GroupTemplate<T, U> >(_id), childList(), groupList(), U()
          {/* Ne rien faire de plus */}            
       
@@ -18,22 +18,22 @@
          /// Pour les groupes d'objets enfants ///
          
-         GroupTemplate<T>& createGroup(const string _id) throw (XMLIOUndefinedValueException) 
+         GroupTemplate<T, U>& createGroup(const string _id) throw (XMLIOUndefinedValueException) 
          {
-            GroupTemplate<T>& obj = GroupTemplate<T>::CreateObject(_id);
+            GroupTemplate<T, U>& obj = GroupTemplate<T, U>::CreateObject(_id);
             groupList.addPtrObject(&obj);
             return (obj);
          }
          
-         GroupTemplate<T>& createGroup(void)
+         GroupTemplate<T, U>& createGroup(void)
          {
-            GroupTemplate<T>& obj = GroupTemplate<T>::CreateObject();
+            GroupTemplate<T, U>& obj = GroupTemplate<T, U>::CreateObject();
             groupList.addPtrObject(&obj);            
             return (obj);
          }
          
-         GroupTemplate<T>& getGroup(const string _id) throw (XMLIOUndefinedValueException) { return (*groupList[_id]); }
+         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>* >& getGroupList(void) { return (groupList); }
+         const StrHashMap<GroupTemplate<T, U>* >& getGroupList(void) { return (groupList); }
          
          size_t getNbGroup() const {return (groupList.getVectorSize()); }
@@ -62,18 +62,4 @@
          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()
@@ -84,5 +70,5 @@
       private:
          StrHashMap<T*> childList;
-         StrHashMap<GroupTemplate<T>* > groupList;
+         StrHashMap<GroupTemplate<T, U>* > groupList;
 
    }; // class GroupTemplate
Index: XMLIO_V2/dev/dev_rv/xmlio_object_template.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/xmlio_object_template.hpp	(revision 90)
+++ XMLIO_V2/dev/dev_rv/xmlio_object_template.hpp	(revision 91)
@@ -24,5 +24,5 @@
             // 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>::AllListObj[CurrContext].addObject(identified_object);
             ObjectTemplate<T>::GetObject(_id).registerAllAttributes();
             return (ObjectTemplate<T>::GetObject(_id));
@@ -35,36 +35,16 @@
          }
          
-         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 T& GetObject(const string _id) throw (XMLIOUndefinedValueException)
+         { return (ObjectTemplate<T>::AllListObj[CurrContext][_id]); }
          
-         static const StrHashMap<T> GetCurrentListObject(void) { return (CurrListObj); }
+         static bool HasObject(const string _id)
+         { return (ObjectTemplate<T>::AllListObj[CurrContext].hasMappedValue(_id)); }
          
-         virtual void registerAllAttributes(void) {};
+         static const StrHashMap<T> GetCurrentListObject(void) { return (AllListObj[CurrContext]); }
+                
+         static void SetContext(const string& id)
+         { ObjectTemplate<T>::CurrContext = id; } 
          
          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)
@@ -79,9 +59,12 @@
          
       private :
-         static StrHashMap<T> CurrListObj;
+         
+         static string CurrContext;
+         static HashMap<string, StrHashMap<T> > AllListObj;
       
    };// class ObjectTemplate
    
-   template <class T> StrHashMap<T> ObjectTemplate<T>::CurrListObj ;
+   template <class T> string ObjectTemplate<T>::CurrContext ;
+   template <class T> HashMap<string, StrHashMap<T> > ObjectTemplate<T>::AllListObj;
    
 }// namespace XMLIOSERVER
Index: XMLIO_V2/dev/dev_rv/xmlio_xml_node.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/xmlio_xml_node.hpp	(revision 91)
+++ XMLIO_V2/dev/dev_rv/xmlio_xml_node.hpp	(revision 91)
@@ -0,0 +1,150 @@
+#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::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
+      
+         }; // namespace XML
+
+};// namespace XMLIOSERVER
+
+
+#endif // __XMLIO_XML_NODE__ 
Index: XMLIO_V2/dev/dev_rv/xmlio_xml_parser.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/xmlio_xml_parser.hpp	(revision 90)
+++ XMLIO_V2/dev/dev_rv/xmlio_xml_parser.hpp	(revision 91)
@@ -1,153 +1,12 @@
 #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;
       
@@ -155,4 +14,5 @@
       {
          public : 
+         
             static void Parse(XMLNode& _node)
             {
@@ -161,8 +21,15 @@
               do {                
                  // Traitement de l'identifiant
-                  _node.getAttributes(attributes);            
+                  _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; }
+                  { WARNING("Le context ne sera pas traitÃ© car il n'est pas identifiÃ© !"); continue; }
+                  
+                  if( Context::HasObject(attributes["id"]))
+                  { WARNING("Le context ne sera pas traitÃ© car il existe dÃ©jÃ  !"); continue; }
+                  
+                  Context::SetCurrentContext(attributes["id"]);
                   Context& context = Context::CreateObject(attributes["id"]);
+                  
                   context.parse(_node);
                   attributes.clear();
@@ -171,7 +38,7 @@
             }    
             
-            static bool CLASS_TEST(ostream& log = std::clog)
+            static bool CLASS_TEST(const string& file = string("/local/testsuite/iodef_test.xml"), ostream& log = std::clog)
             {
-               ifstream istr( "/local/testsuite/iodef_test.xml" , ifstream::in ); // Modifier le rÃ©pertoire de test ici
+               ifstream istr( file.c_str() , ifstream::in );
                XMLNode node = XMLNode::CreateNode(istr);
                XMLParser::Parse(node);
