Index: LIO_V2/dev/trunk/src/XMLIO/attribut.cpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/attribut.cpp	(revision 97)
+++ 	(revision )
@@ -1,1 +1,0 @@
-
Index: /XMLIO_V2/dev/trunk/src/XMLIO/attribut.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/attribut.hpp	(revision 97)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/attribut.hpp	(revision 98)
@@ -1,62 +1,103 @@
-#ifndef ATTRIBUT_HPP
-#define ATTRIBUT_HPP
+#ifndef __ATTRIBUT__
+#define __ATTRIBUT__
 
 #include "base_attribut.hpp"
-#include "xmlio_std.hpp"
 
-template <class Ctype>
-class CAttribut : public CBaseAttribut
+using XMLIOSERVER::BaseAttribut;
+using XMLIOSERVER::XMLIOUndefinedValueException;
+using std::ostringstream;
+
+namespace XMLIOSERVER
 {
-  public :
-  
-  bool hasValue ;
-  Ctype value ;
-
-  virtual const char * getName(void) const = 0 ;
-  CAttribut(void) : hasValue(false) {} ;
-  CAttribut(const Ctype& value_) : value(value_), hasValue(true) {} ;
-  CAttribut(const CAttribut& attr) : hasValue(attr.hasValue) 
-  {
-     if (hasValue) value=attr.value ;
-  } ;
-
-  CAttribut& operator = (const CAttribut & attr)
-  { 
-     hasValue=attr.hasValue ;
-     if (hasValue) value=attr.value ;
-     return *this ; 
-  } ;
-
-  operator Ctype()
-  {
-    if (!hasValue) error("CAttribut& CAttribut<Ctype>::operator Ctype")<<"access to undefined value of attribut <<"
-                                                                       <<this->getName()<<">>"<<endl;
-    return value ;
-  } ;
-
-  virtual ostream& print(ostream & o) const
-  {
-    o<<"Attribut : "<<getName()<<"  ---->" ;
-    if (hasValue) o<<" value = "<<value ;
-    else o<<" undefined value" ;
-    return o ;
-  }
-
-  virtual void setValue(const Ctype & value_)
-  {
-     hasValue=true ;
-     value=value_ ;
-  }
-
-  virtual void getValue(Ctype & value_) const
-  {
-    if (!hasValue)  error("void CAttribut<Ctype>::getValue")<<"access to undefined value of attribut <<"
-                                                               <<this->getName()<<">>"<<endl;
-    value_=value ;
-  }
-
-} ;
+   class IStringStream_alt
+   {
+      public : 
+         IStringStream_alt(const std::string& str) : iss(str)
+         { /* Ne rien faire de plus */}
+         
+         istream& operator>> (std::string& s) {s.assign(this->iss.str()); return (this->iss);}
+         istream& operator>> (int& s) { return (iss>>s); }
+         istream& operator>> (bool& s)
+         {
+            if(!this->iss.str().compare(string(".TRUE."))) s =  true;
+            else s = false;
+            return (this->iss);
+         }
+         
+      private : 
+         istringstream iss;
+         
+   }; // class IStringStream_alt
 
 
+   template <class Ctype>
+      class Attribut : public BaseAttribut
+   {
+      public :
+     
+         bool hasValue ;
+         Ctype value ;
+
+         virtual const char * getName(void) const = 0 ;
+      
+         Attribut(void) : hasValue(false) {} ;
+         Attribut(const Ctype& value_) : hasValue(true), value(value_) {} ;
+         
+         Attribut(const Attribut& attr) : hasValue(attr.hasValue) 
+         {  if (hasValue) value=attr.value ; }
+
+         Attribut& operator = (const Attribut & attr)
+         { 
+            hasValue=attr.hasValue ;
+            if (hasValue) value=attr.value ;
+            return *this ; 
+         }
+     
+         virtual const char * getType(void) const = 0;
+     
+         virtual void setFromString(const std::string str) 
+         {    
+            IStringStream_alt iss(str); Ctype val;
+            iss >> val;
+            this->setValue(val);
+         }   
+
+         operator Ctype()
+         {
+            if (!hasValue)
+            {
+               ostringstream oss;
+               oss << "CAttribut& CAttribut<Ctype>::operator Ctype , access to undefined value of attribut <<" << this->getName() <<">>";
+                                                                          
+               throw XMLIOUndefinedValueException(oss.str());
+            }
+            return value ;
+         }
+
+         virtual ostream& print(ostream & o) const
+         {
+            o<<"Attribut : "<<getName()<<"  ---->" ;
+            if (hasValue) o<< boolalpha <<" value = "<< value ;
+            else o<< "/" ;
+            return o ;
+         }
+
+         virtual void setValue(const Ctype & value_)
+         { hasValue=true ; value=value_ ; }
+
+         virtual void getValue(Ctype & value_) const
+         {
+            if (!hasValue)
+            {
+               ostringstream oss;
+               oss << "CAttribut& CAttribut<Ctype>::operator Ctype , access to undefined value of attribut <<" << this->getName() <<">>";
+                                                                          
+               throw XMLIOUndefinedValueException(oss.str());
+            }
+            value_=value ;
+         }
+
+   }; // class Attribut 
+}; // namespace XMLIOSERVER
   
-#endif
+#endif //__ATTRIBUT__
Index: /XMLIO_V2/dev/trunk/src/XMLIO/attribut_registrar.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/attribut_registrar.hpp	(revision 97)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/attribut_registrar.hpp	(revision 98)
@@ -1,58 +1,60 @@
-#ifndef ATTRIBUT_REGISTRAR_HPP
-#define ATTRIBUT_REGISTRAR_HPP
+#ifndef __ATTRIBUT_REGISTRAR__
+#define __ATTRIBUT_REGISTRAR__
 
-#include "base_attribut.hpp"
-#include "xmlio_std.hpp"
+#include "attribut.hpp"
 
-class CAttributRegistrar
+namespace XMLIOSERVER
 {
-  public :
-  
-  
-  void RegisterAttribut(CBaseAttribut & attribut) ;
-  ostream & PrintAttribut(ostream & o) ;
+   class AttributRegistrar
+   {
+      public :
+        
+         AttributRegistrar():attrList()
+         {/* Ne rien faire de plus */}
+      
+         void RegisterAttribut(BaseAttribut* attribut){ attrList.addObject(attribut); }         
+         StrHashMap<BaseAttribut>& getAttributList(void) { return (attrList); }         
+         size_t getNbAttributes() const {return (attrList.getSize()); }
+         bool hasAttribut(const string _id) { return (attrList.hasMappedValue(_id)); }
+         
+         BaseAttribut* getAttribut(const string _id) throw (XMLIOUndefinedValueException) { return (attrList[_id]); }
+        
+         void setSAttribut(const string& att_name, const std::string& value)
+         {
+            //std::cout << "Attribut :" <<  att_name<< ", " << value<< std::endl;
 
-  unordered_map<string,CBaseAttribut *> attrMap ;
-  vector<CBaseAttribut *> attrVector ;
-
-  bool hasAttribut(const string& att_name)
-  {
-    if (attrMap.find(att_name)!=attrMap.end()) return true ;
-    else return false ;
-  }
-  
-  template <class ValueType>
-  void setAttribut(const string& att_name, ValueType value)
-  {
-    unordered_map<string,CBaseAttribut *>::iterator it ;
-    
-    it=attrMap.find(att_name) ;
-    if (it!=attrMap.end()) (*it).second->setValue(value) ;
-    else error("CAttributRegistrar::setAttribut<ValueType>")
-         <<"Could not find <<"<<att_name<<">> attribut in registred list"<<endl ;
-    
-  }
-  
-} ;
-
-inline void CAttributRegistrar::RegisterAttribut(CBaseAttribut& Attribut)
-{
-  attrMap.insert(make_pair(Attribut.getName(),&Attribut)) ;
-  attrVector.push_back(&Attribut) ;
-}
-
-inline ostream & CAttributRegistrar::PrintAttribut(ostream& o)
-{
-  vector<CBaseAttribut *>::iterator it ;
-  o<<"List of attribut"<<IncIndent ;
-  for(it=attrVector.begin(); it!=attrVector.end();it++)
-  {
-    o<<iendl ;
-    (*it)->print(o) ;
-  }
-  o<<DecIndent ;
-  return o ;
-}
+            if (hasAttribut(att_name))
+            { getAttribut(att_name)->setFromString(value) ; }
+            else
+            {
+               ostringstream oss;
+               oss << "CAttributRegistrar::setAttribut<ValueType>, could not find <<" << att_name <<">> attribut in registred list" <<">>";
+               throw XMLIOUndefinedValueException(oss.str());
+            }         
+         }
+         
+         friend ostream& operator<< (ostream& out, const AttributRegistrar& c) 
+         { out << c.toString(); return (out);}   
+               
+      protected :
+      
+         string toString(void) const
+         {
+            ostringstream st("A rÃ©implÃ©menter");
+            // A complÃ©ter
+            return (st.str());
+         }
+         
+      public :
+         
+        ~AttributRegistrar(void)
+        {/* Ne rien faire de plus */}
+        
+      private :
+         StrHashMap<BaseAttribut> attrList;
+        
+   }; // class AttributRegistrar  
+}; // namespace XMLIOSERVER
 
 
-#endif
+#endif //__ATTRIBUT_REGISTRAR__
Index: /XMLIO_V2/dev/trunk/src/XMLIO/base_attribut.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/base_attribut.hpp	(revision 97)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/base_attribut.hpp	(revision 98)
@@ -1,86 +1,94 @@
-#ifndef BASE_ATTRIBUT_HPP
-#define BASE_ATTRIBUT_HPP
-#include "xmlio_std.hpp"
+#ifndef __BASE_ATTRIBUT__
+#define __BASE_ATTRIBUT__
 
-class CBaseAttribut
-{
-  public:
-  
-  virtual const char * getName(void) const = 0  ;
-     
-  virtual ostream & print(ostream& o) const = 0  ;
-  
-  friend ostream& operator <<(ostream& o,const CBaseAttribut& Attr)
-  {
-    return Attr.print(o) ;
-  }
-
-  
-  virtual void setValue(const int & value)          { error_set() ; }
-  virtual void setValue(const Array<int,1>& value)  { error_set() ; }
-  virtual void setValue(const Array<int,2>& value)  { error_set() ; }
-  virtual void setValue(const Array<int,3>& value)  { error_set() ; }
-  
-  virtual void setValue(const double & value)          { error_set() ; }
-  virtual void setValue(const Array<double,1>& value)  { error_set() ; }
-  virtual void setValue(const Array<double,2>& value)  { error_set() ; }
-  virtual void setValue(const Array<double,3>& value)  { error_set() ; }
-  
-  virtual void setValue(const bool & value)          { error_set() ; }
-  virtual void setValue(const Array<bool,1>& value)  { error_set() ; }
-  virtual void setValue(const Array<bool,2>& value)  { error_set() ; }
-  virtual void setValue(const Array<bool,3>& value)  { error_set() ; }
-  
-  virtual void setValue(const char * value)            { error_set() ; }
-  virtual void setValue(const string & value)          { error_set() ; }
-  virtual void setValue(const Array<string,1>& value)  { error_set() ; }
-  virtual void setValue(const Array<string,2>& value)  { error_set() ; }
-  virtual void setValue(const Array<string,3>& value)  { error_set() ; }
-  
-  virtual void setValue(const char & value)          { error_set() ; }
-  virtual void setValue(const Array<char,1>& value)  { error_set() ; }
-  virtual void setValue(const Array<char,2>& value)  { error_set() ; }
-  virtual void setValue(const Array<char,3>& value)  { error_set() ; }
+using std::ostream;
+using namespace blitz ;
 
 
-  virtual void getValue(int & value) const        { error_get() ; }
-  virtual void getValue(Array<int,1>& value) const  { error_get() ; }
-  virtual void getValue(Array<int,2>& value) const  { error_get() ; }
-  virtual void getValue(Array<int,3>& value) const  { error_get() ; }
+using XMLIOSERVER::XMLIOIncompatibeTypeException;
+
+namespace XMLIOSERVER
+{
+   class BaseAttribut
+   {
+     public:
+     
+     virtual const char * getName(void) const = 0  ;
+        
+     virtual ostream & print(ostream& o) const = 0  ;
+     
+     friend ostream& operator <<(ostream& o,const BaseAttribut& Attr)
+     {return Attr.print(o) ; }
+     
+     virtual const char * getId(void) {return getName();} ;
+     bool hasId(void){return (true);}
+
+     virtual void setFromString(const std::string str) = 0;
+      
+     virtual void setValue(const int & value)          { error_set() ; }
+     virtual void setValue(const Array<int,1>& value)  { error_set() ; }
+     virtual void setValue(const Array<int,2>& value)  { error_set() ; }
+     virtual void setValue(const Array<int,3>& value)  { error_set() ; }
+     
+     virtual void setValue(const double & value)          { error_set() ; }
+     virtual void setValue(const Array<double,1>& value)  { error_set() ; }
+     virtual void setValue(const Array<double,2>& value)  { error_set() ; }
+     virtual void setValue(const Array<double,3>& value)  { error_set() ; }
+     
+     virtual void setValue(const bool & value)          { error_set() ; }
+     virtual void setValue(const Array<bool,1>& value)  { error_set() ; }
+     virtual void setValue(const Array<bool,2>& value)  { error_set() ; }
+     virtual void setValue(const Array<bool,3>& value)  { error_set() ; }
+     
+     virtual void setValue(const char * value)            { error_set() ; }
+     virtual void setValue(const string & value)          { error_set() ; }
+     virtual void setValue(const Array<string,1>& value)  { error_set() ; }
+     virtual void setValue(const Array<string,2>& value)  { error_set() ; }
+     virtual void setValue(const Array<string,3>& value)  { error_set() ; }
+     
+     virtual void setValue(const char & value)          { error_set() ; }
+     virtual void setValue(const Array<char,1>& value)  { error_set() ; }
+     virtual void setValue(const Array<char,2>& value)  { error_set() ; }
+     virtual void setValue(const Array<char,3>& value)  { error_set() ; }
+
+
+     virtual void getValue(int & value) const        { error_get() ; }
+     virtual void getValue(Array<int,1>& value) const  { error_get() ; }
+     virtual void getValue(Array<int,2>& value) const  { error_get() ; }
+     virtual void getValue(Array<int,3>& value) const  { error_get() ; }
+     
+     virtual void getValue(double & value) const          { error_get() ; }
+     virtual void getValue(Array<double,1>& value) const  { error_get() ; }
+     virtual void getValue(Array<double,2>& value) const  { error_get() ; }
+     virtual void getValue(Array<double,3>& value) const  { error_get() ; }
+     
+     virtual void getValue(bool & value) const          { error_get() ; }
+     virtual void getValue(Array<bool,1>& value) const  { error_get() ; }
+     virtual void getValue(Array<bool,2>& value) const  { error_get() ; }
+     virtual void getValue(Array<bool,3>& value) const  { error_get() ; }
+     
+     virtual void getValue(char * value) const            { error_get() ; }
+     virtual void getValue(string & value) const          { error_get() ; }
+     virtual void getValue(Array<string,1>& value) const  { error_get() ; }
+     virtual void getValue(Array<string,2>& value) const  { error_get() ; }
+     virtual void getValue(Array<string,3>& value) const  { error_get() ; }
+     
+     virtual void getValue(char & value) const          { error_get() ; }
+     virtual void getValue(Array<char,1>& value) const  { error_get() ; }
+     virtual void getValue(Array<char,2>& value) const  { error_get() ; }
+     virtual void getValue(Array<char,3>& value) const  { error_get() ; }
+
+     static void error_set(void)
+     {
+        throw XMLIOIncompatibeTypeException("BaseAttribut::set<type> > Setting value type is incompatible with attribut type");
+     }
+
+     static void error_get(void)
+     {
+        throw XMLIOIncompatibeTypeException("BaseAttribut::set<type> >Getting value type is incompatible with attribut type");
+     }
+   }; //class BaseAttribut
+} // namespace XMLIOSERVER
+
+#endif //__BASE_ATTRIBUT__
   
-  virtual void getValue(double & value) const          { error_get() ; }
-  virtual void getValue(Array<double,1>& value) const  { error_get() ; }
-  virtual void getValue(Array<double,2>& value) const  { error_get() ; }
-  virtual void getValue(Array<double,3>& value) const  { error_get() ; }
-  
-  virtual void getValue(bool & value) const          { error_get() ; }
-  virtual void getValue(Array<bool,1>& value) const  { error_get() ; }
-  virtual void getValue(Array<bool,2>& value) const  { error_get() ; }
-  virtual void getValue(Array<bool,3>& value) const  { error_get() ; }
-  
-  virtual void getValue(char * value) const            { error_get() ; }
-  virtual void getValue(string & value) const          { error_get() ; }
-  virtual void getValue(Array<string,1>& value) const  { error_get() ; }
-  virtual void getValue(Array<string,2>& value) const  { error_get() ; }
-  virtual void getValue(Array<string,3>& value) const  { error_get() ; }
-  
-  virtual void getValue(char & value) const          { error_get() ; }
-  virtual void getValue(Array<char,1>& value) const  { error_get() ; }
-  virtual void getValue(Array<char,2>& value) const  { error_get() ; }
-  virtual void getValue(Array<char,3>& value) const  { error_get() ; }
-
-  static void error_set(void)
-  {
-     error("CBaseAttribut::set<type>")<<"Setting value type is incompatible"
-                                      <<" with attribut type"<<endl ;
-  }
-
-  static void error_get(void)
-  {
-     error("CBaseAttribut::set<type>")<<"Getting value type is incompatible"
-                                      <<" with attribut type"<<endl ;
-  }
-} ;
-
-#endif 
-  
Index: LIO_V2/dev/trunk/src/XMLIO/base_object.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/base_object.hpp	(revision 97)
+++ 	(revision )
@@ -1,31 +1,0 @@
-#ifndef BASE_OBJECT_HPP
-#define BASE_OBJECT_HPP
-
-#include "xmlio_std.hpp"
-
-
-class CBase_object : public virtual CAttributRegistrar
-{
- public :
-  string id ;
-  bool hasId ;
-
-  CBase_object(void) : hasId(false) {}
-  CBase_object(const string& Id) : id(Id), hasId(true) {}
-  
-  void setId(const string& Id)
-  {
-    id=Id ;
-    hasId=true ;
-  }
-
-  ostream & PrintId(ostream& o)
-  {
-    if (hasId) o<<" ---> Id = "<<id ;
-    else o<<" ---> No Id " ;
-    return o ;
-  }
-
-} ;
-
-#endif
Index: /XMLIO_V2/dev/trunk/src/XMLIO/context.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/context.hpp	(revision 97)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/context.hpp	(revision 98)
@@ -1,14 +1,102 @@
-#ifndef CONTEXT_HPP
-#define CONTEXT_HPP
+#ifndef __CONTEXT__
+#define __CONTEXT__ 
 
+      
+namespace XMLIOSERVER
+{ 
+   class Context : public ObjectTemplate<Context>
+   {
+      public:
+            
+         Context(void) : ObjectTemplate<Context>()
+         {/* Ne rien faire de plus */}               
+         Context(const string& _id) : ObjectTemplate<Context>(_id)
+         {/* Ne rien faire de plus */}
+         
+         static void SetCurrentContext(const string& id)
+         {
+            // On modifie le context courrant pour tout les ObjectTemplate
+            Context::SetContext(id);
+            FieldGroup::SetContext(id);
+            Field::SetContext(id);
+         }
+         
+         void parse (XMLNode& _node)
+         {
+            THashAttributes attributes;
+           
+            /// PARSING POUR GESTION DES ENFANTS
+            if (_node.getElementName().compare(string("context")))
+               WARNING("Le noeud est mal nommÃ© mais sera traitÃ© comme un context !");
+            
+            if (!(_node.goToChildElement()))
+               WARNING("Le context ne contient pas d'enfant !"); 
+            else
+            {
+               //////////////////////////////////////
+              do { // Parcours des contexts pour traitement.        
+                            
+                  string name = _node.getElementName();
+                  attributes.clear();
+                  _node.getAttributes(attributes);   
+                  
+                  if (attributes.end() != attributes.find("id"))
+                  { WARNING("Le noeud de dÃ©finition possÃšde un identifiant, ce dernier ne sera pas pris en compte lors du traitement !"); }
+                  
+                  if (name.compare("field_definition") == 0)
+                  { // Parsing pour la dÃ©finition des champs.
+                  
+                     if (FieldDefinition::HasObject("field_definition")) 
+                        WARNING("Le context possÃšde dÃ©jÃ  un noeud de dÃ©finition de champs, le dernier dÃ©fini complÃ©tera le premier !");
+                     
+                     fieldDef = (FieldDefinition*)&FieldDefinition::CreateObject("field_definition"); // << Conversion possible car la classe Field n'a pas de propriÃ©tÃ©s.
+                     fieldDef->parse(_node);
 
+                     continue;
+                  }
+                  else if (name.compare("file_definition") == 0)
+                  { // Parsing pour la dÃ©finition des fichiers.                  
+                     INFO("Le parsing des dÃ©finitions de fichiers n'est pas encore implÃ©mentÃ©");
+                  } 
+                  else if (name.compare("axis_definition") == 0)
+                  { // Parsing pour la dÃ©finition des axes.
+                     INFO("Le parsing des dÃ©finitions d'axes n'est pas encore implÃ©mentÃ©");
+                  }
+                  else if (name.compare("grid_definition") == 0)
+                  { // Parsing pour la dÃ©finition des grilles.
+                     INFO("Le parsing des dÃ©finitions de grilles n'est pas encore implÃ©mentÃ©");
+                  } 
+                  else
+                     WARNING("La dÃ©finition est invalide, seules les champs, grilles, axes et fichiers peuvent Ãªtre dÃ©finis !");
+                     
+                     
+                  // Traitement file, grid et axis Ã  complÃ©ter.
+               } while (_node.goToNextElement());
+               //////////////////////////////////////
+               _node.goToParentElement(); // Retour au parent
+            }
+            
+            return;
+         }
+         
+         virtual const char* getName(void) const {return ("Context"); }
+         
+         FieldDefinition* getFieldDefinition(void) { return (this->fieldDef); }
+                  
+         ~Context()
+         { delete fieldDef; }
+         
+      protected:
+      
+      private:
+      
+         FieldDefinition*  fieldDef;
+         /*FileDefinition* fileDef;
+         AxisDefinition*   axisDef;
+         GridDefinition*   gridDef;*/
 
+      
+   }; //class Context
+}// namespace XMLIOSERVER
 
-
-
-
-
-
-
-
-#endif
+#endif  // __CONTEXT__
Index: /XMLIO_V2/dev/trunk/src/XMLIO/declare_attribut.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/declare_attribut.hpp	(revision 97)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/declare_attribut.hpp	(revision 98)
@@ -1,15 +1,17 @@
-#ifndef DECLARE_ATTRIBUT_HPP
-#define DECLARE_ATTRIBUT_HPP
+#ifndef __DECLARE_ATTRIBUT__
+#define __DECLARE_ATTRIBUT__
+
 #include "attribut.hpp"
 
-#define DECLARE_ATTR(att_name,att_type)                      \
-  class attr_##att_name : public CAttribut<att_type>                         \
-  {                                                          \
-    public:                                                  \
-    const char * getName(void) const { return #att_name ;} ; \
-    attr_##att_name(void) : CAttribut<att_type>() {} ; \
-    attr_##att_name(const att_type& value_) : CAttribut<att_type>(value_) {} ; \
-    attr_##att_name(const attr_##att_name & att) : CAttribut<att_type>(att) {} ; \
-  } att_name
+#define DECLARE_ATTR(att_name,att_type)               \
+   class attr_##att_name : public Attribut<att_type>  \
+   {                                                  \
+      public:                                         \
+         const char * getName(void) const { return #att_name ;}                     \
+         virtual const char * getType(void) const { return #att_type ;}             \
+         attr_##att_name(void) : Attribut<att_type>() {}                            \
+         attr_##att_name(const att_type& value_) : Attribut<att_type>(value_) {}    \
+         attr_##att_name(const attr_##att_name & att) : Attribut<att_type>(att) {}  \
+   } att_name
 
-#endif
+#endif // __DECLARE_ATTRIBUT__
Index: /XMLIO_V2/dev/trunk/src/XMLIO/field.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/field.hpp	(revision 97)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/field.hpp	(revision 98)
@@ -1,19 +1,51 @@
-#ifndef FIELD_HPP
-#define FIELD_HPP
+#ifndef __FIELD__
+#define __FIELD__
 
-#include "base_object.hpp"
-#include "object_template.hpp"
-#include "xmlio_std.hpp"
+using XMLIOSERVER::XML::XMLNode;
+using XMLIOSERVER::XML::THashAttributes;
 
+namespace XMLIOSERVER
+{
+   class Field : public ObjectTemplate<Field>, public FieldAttribut
+   {
+      public:
+         Field(void) : ObjectTemplate<Field>(), FieldAttribut()
+			{/* Ne rien faire de plus */}	         	
+			Field(const string& _id) : ObjectTemplate<Field>(_id), FieldAttribut()
+         {/* Ne rien faire de plus */}	
+         
+         void setAttributes(const THashAttributes& attr)
+         {
+            for (THashAttributes::ConstIterator it = attr.begin(); it != attr.end(); it++)
+               if ((*it).first.compare(string("id"))) // Non prise en compte de l'identifiant lors de l'affectation des attributs.
+                  this->setSAttribut((*it).first, (*it).second);
+            
+            return;
+         }
+         
+         virtual const char* getName(void) const {return ("Field"); }   
 
-class Field : public CObjectTemplate<Field>, public CFieldAttribut
-{
-  public:
-
-    Field(void) : CObjectTemplate<Field>() {} ;
-    Field(const string & Id) : CObjectTemplate<Field>(Id) {} ;
-    static const char * getName(void) { return "field" ; }
-};
-
-
-#endif
+			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.
+            
+            return;
+         }
+         
+         ~Field(void) 
+         { /* Ne rien faire de plus */ }    
+      
+   }; // class Field 
+      
+}; // namespace XMLIOSERVER
+   
+#endif // __FIELD__
Index: /XMLIO_V2/dev/trunk/src/XMLIO/field_attribut.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/field_attribut.hpp	(revision 97)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/field_attribut.hpp	(revision 98)
@@ -1,23 +1,58 @@
-#ifndef FIELD_ATTRIBUT_HPP
-#define FIELD_ATTRIBUT_HPP
+#ifndef __FIELD_ATTRIBUT__
+#define __FIELD_ATTRIBUT__
 
+#include "declare_attribut.hpp"
 #include "attribut_registrar.hpp"
-#include "attribut.hpp"
-#include "declare_attribut.hpp"
 
-class CFieldAttribut : public virtual CAttributRegistrar
+namespace XMLIOSERVER
 {
-  public :
+   class FieldAttribut : public virtual AttributRegistrar
+   {
+      public :
+      
+         DECLARE_ATTR(name, string) ;
+         DECLARE_ATTR(description, string) ; 
+         DECLARE_ATTR(unit, string) ;
+         DECLARE_ATTR(operation, string);
+      
+         DECLARE_ATTR(freq_op, int) ;
+         DECLARE_ATTR(level, int) ;
+         DECLARE_ATTR(prec, int) ;
+         
+         DECLARE_ATTR(src, string) ; // TEMPORAIRE, pour fieldgroup uniquement
+      
+         DECLARE_ATTR(enabled, bool);
+      
+         DECLARE_ATTR(axis_ref, string);
+         DECLARE_ATTR(grid_ref, string);
+         DECLARE_ATTR(zoom_ref, string);
+         DECLARE_ATTR(field_ref, string);
+      
+         FieldAttribut(void)
+         { registerAllAttributes(); }
+                         
+         void registerAllAttributes(void)
+         {
+            RegisterAttribut(&name) ;
+            RegisterAttribut(&description) ; 
+            RegisterAttribut(&unit) ;
+            RegisterAttribut(&operation);
+            
+            RegisterAttribut(&src);// TEMPORAIRE, pour fieldgroup uniquement
+      
+            RegisterAttribut(&freq_op) ;
+            RegisterAttribut(&level) ;
+            RegisterAttribut(&prec) ;
+            RegisterAttribut(&enabled);
+      
+            RegisterAttribut(&axis_ref);
+            RegisterAttribut(&grid_ref);
+            RegisterAttribut(&zoom_ref);
+            RegisterAttribut(&field_ref);
+         }
+     
+   } ; // class CFieldAttribut
    
-   DECLARE_ATTR(name,string) ; 
-   DECLARE_ATTR(level,int) ;
-   
-  CFieldAttribut(void)
-  {
-    RegisterAttribut(name) ;
-    RegisterAttribut(level) ;
-  }
-  
-} ;
+}// namespace XMLIOSERVER
 
-#endif
+#endif //__FIELD_ATTRIBUT__
Index: /XMLIO_V2/dev/trunk/src/XMLIO/field_group.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/field_group.hpp	(revision 98)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/field_group.hpp	(revision 98)
@@ -0,0 +1,113 @@
+#ifndef __FIELD_GROUP__
+#define __FIELD_GROUP__
+
+
+using XMLIOSERVER::XML::THashAttributes;
+
+namespace XMLIOSERVER
+{   
+   class FieldGroup : public GroupTemplate<Field, FieldAttribut>
+   {
+      public:
+      
+         FieldGroup(void) : GroupTemplate<Field, FieldAttribut>()
+         {/* Ne rien faire de plus */}               
+         FieldGroup(const string& _id) : GroupTemplate<Field, FieldAttribut>(_id)
+         {/* Ne rien faire de plus */}
+         
+         void setAttributes(const THashAttributes& attr)
+         {
+            for (THashAttributes::ConstIterator it = attr.begin(); it != attr.end(); it++)
+               if ((*it).first.compare(string("id"))) // Non prise en compte de l'identifiant lors de l'affectation des attributs.
+                  this->setSAttribut((*it).first, (*it).second);
+            
+            return;
+         }
+                 
+         virtual const char* getName(void) const {return ("FieldGroup"); }  
+         
+         void parse (XMLNode& _node)
+         {
+            string name = _node.getElementName();            
+            THashAttributes attributes;
+            
+            /// PARSING GESTION DES ATTRIBUTS ///
+            _node.getAttributes(attributes);  
+            this->setAttributes(attributes);
+            attributes.clear();
+               
+            /// PARSING POUR GESION DES ENFANTS
+            if (!(_node.goToChildElement()))
+               WARNING("Le groupe de champ ne contient pas d'enfant !");
+            else
+            {
+               //////////////////////////////////////
+               do { // Parcours des contexts pour traitement. 
+                            
+                  string name = _node.getElementName();
+                  attributes.clear();
+                  _node.getAttributes(attributes);  
+                                 
+                  if (name.compare("field_group") == 0)
+                  { // Parsing pour les groupes de champs
+                  
+                     FieldGroup* fgroup = NULL;
+                        
+                     if (attributes.end() != attributes.find("id"))
+                     {// Si l'identifiant est dÃ©fini.
+                        if (FieldGroup::HasObject(attributes["id"]))
+                           WARNING("Dans le context actuel, un groupe de champ du mÃªme nom existe dÃ©jÃ , le second fera rÃ©fÃ©rence au premier par dÃ©faut !"); // TODO TODO
+                        fgroup =(FieldGroup*)&createGroup(attributes["id"]);
+                        fgroup->parse(_node);
+                     }
+                     else
+                     {// Si l'identifiant n'est pas dÃ©fini.
+                        fgroup = (FieldGroup*)&createGroup();
+                        fgroup->parse(_node);
+                     }
+                        
+                     continue;
+                        
+                  }
+                  else if (name.compare("field") == 0)
+                  { // Parsing pour les champs
+                  
+                     Field* field = NULL;
+                  
+                     if (attributes.end() != attributes.find("id"))
+                     {// Si l'identifiant est dÃ©fini.
+                        if (Field::HasObject(attributes["id"]))
+                           WARNING("Dans le context actuel, un champ du mÃªme nom existe dÃ©jÃ , le second fera rÃ©fÃ©rence au premier par dÃ©faut !");  // TODO TODO
+                        field =(Field*)&createChild(attributes["id"]);
+                        field->parse(_node);
+                     }
+                     else
+                     {// Si l'identifiant n'est pas dÃ©fini.
+                        field = (Field*)&createChild();
+                        field->parse(_node);
+                     }         
+                    
+                     continue;
+                  } 
+                  else
+                     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  
+            }
+                                       
+            return;
+         }
+         
+         virtual ~FieldGroup(void) 
+         {/* Ne rien faire de plus */}   
+         
+   }; // class FieldGroup
+     
+   typedef FieldGroup FieldDefinition ;
+   
+}; // namespace XMLIOSERVER
+   
+#endif // __FIELD_GROUP__
+
Index: LIO_V2/dev/trunk/src/XMLIO/group_template.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/group_template.hpp	(revision 97)
+++ 	(revision )
@@ -1,184 +1,0 @@
-#ifndef GROUP_TEMPLATE_HPP
-#define GROUP_TEMPLATE_HPP
-
-#include "object_template.hpp"
-#include "xmlio_std.hpp"
-
-template<typename CObject>
-class group  : public CObjectTemplate<group<CObject> >
-{
-  public :
-
-  CObject * defaultAttribut ;
-  
-  unordered_map<string,CObject *>* childListId ;
-  vector<CObject *>* childList ;
-  unordered_map<string,group<CObject> *>* groupListId ;
-  vector<group<CObject> *>* groupList ;
-  
-  group(void) : CObjectTemplate< group<CObject> >() 
-  {
-    defaultAttribut=new CObject ;
-    childListId=new unordered_map<string,CObject *> ;
-    childList=new vector<CObject *> ;
-    groupListId=new unordered_map<string,group<CObject> *> ;
-    groupList=new vector<group<CObject> *> ;
-  }
-
-  group(const string Id) : CObjectTemplate< group<CObject> >(Id) 
-  {
-    defaultAttribut=new CObject ;
-    childListId=new unordered_map<string,CObject *> ;
-    childList=new vector<CObject *> ;
-    groupListId=new unordered_map<string,group<CObject> *> ;
-    groupList=new vector<group<CObject>*> ;
-  }
-
-  CObject * getDefaultAttribut(void) {return defaultAttribut ;}
-  
-  bool foundChild(const string & Id) const 
-  {
-    if (childListId->find(Id)==childListId->end()) return false ;
-    else return true ;
-  }
-
-  CObject * getChild(const string & Id)
-  {
-    typename unordered_map<string,CObject*>::iterator It ;
-
-    It=childListId->find(Id) ;
-    if (It==childListId->end())
-    {
-      error("group<object>::getChild(const string & Id)")<<"Child <<"<<Id<<">> does not exist"<<endl ;
-      return 0 ;
-    }
-    else return It->second ;
-  }
-
-  CObject * getNewChild(void)
-  {
-    CObject * newChild=new CObject ;
-    childList->push_back(newChild) ;
-    return newChild ;
-  }
-
-
-  CObject* getNewChild(const string & Id)
-  {
-    CObject* newChild=new CObject(Id) ;
-    
-    pair<string,CObject *> value(Id,newChild) ;
-    if (childListId->insert(value).second) 
-    {
-      childList->push_back(newChild) ;
-      return newChild ;
-    }
-    else
-    {
-      error("group<object>::getNewChild(const string & Id)")<<"Child <<"<<Id<<">> is already present"<<endl ;
-      return 0 ;
-    }
-  }
-
-
-  CObject * getOrAppendChild(const string & Id)
-  {
-    if (foundChild(Id)) return getChild(Id) ;
-    else return getNewChild(Id) ;
-  }
-
-  
-  bool foundGroup(const string & Id) const
-  {
-    if (groupListId->find(Id)==groupListId->end()) return false ;
-    else return true ;
-  }
-  
-  group<CObject> * getGroup(const string & Id)
-  {
-    typename unordered_map<string,group<CObject>*>::iterator It ;
-
-    It=groupListId->find(Id) ;
-    if (It==groupListId->end())
-    {
-      error("group<object>::getGroup(const string & Id)")<<"Group <<"<<Id<<">> does not exist"<<endl ;
-      return 0 ;
-    }
-    else return It->second ;
-  }
-
-  group<CObject>* getNewGroup(void)
-  {
-    group<CObject> * newGroup=new group<CObject> ;
-    groupList->push_back(newGroup) ;
-    return newGroup ;
-  }
-
-
-  group<CObject>* getNewGroup(const string & Id)
-  {
-    group<CObject>* newGroup=new group<CObject>(Id) ;
-    
-    pair<string,group<CObject>*> value(Id,newGroup) ;
-    if (groupListId->insert(value).second)
-    {
-      groupList->push_back(newGroup) ;
-      return newGroup ;
-    }
-    else
-    {
-      error("group<object>::getNewGroup(const string & Id)")<<"Group <<"<<Id<<">> is already present"<<endl ;
-      return 0 ;
-    }
-  }
-
-
-  group<CObject> * getOrAppendGroup(const string & Id)
-  {
-    if (foundGroup(Id)) return getGroup(Id) ;
-    else return getNewGroup(Id) ;
-  }
-
-  static const char* getName(void) 
-  {
-    return (string("group_")+string(CObject::getName())).c_str() ;
-  }
-
-
-  ostream& Print(ostream& o)
-  {
-    typename vector<CObject *>::iterator it1 ;
-    typename vector<group<CObject> *>::iterator it2 ;
-    
-    o<<"Object :"<<getName()<<" : " ;
-    this->PrintId(o)<<inc_endl ;
-    this->PrintAttribut(o)<<iendl ;
-    o<<"Default Attribut"<<inc_endl ;
-    defaultAttribut->Print(o)<<dec_endl ;
-    o<<"Group "<<getName()<<IncIndent ;
-    for(it2=groupList->begin();it2!=groupList->end();it2++) 
-    {
-      o<<iendl ;
-      (*it2)->Print(o) ;
-    }
-    o<<DecIndent<<iendl ;
-    o<<"Child "<<CObject::getName()<<IncIndent ;
-    for(it1=childList->begin();it1!=childList->end();it1++) 
-    {
-      o<<iendl;
-      (*it1)->Print(o) ;
-    }
-    o<<DecIndent<<DecIndent ;
-    return o ;
-  }
-  
-  void Print(void)
-  {
-    Print(StdOut) ;
-  }
-
-} ;
-
-
-
-#endif
Index: /XMLIO_V2/dev/trunk/src/XMLIO/main.cpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/main.cpp	(revision 98)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/main.cpp	(revision 98)
@@ -0,0 +1,8 @@
+
+extern "C" void main_c_(void) ;
+
+int main (void)
+{
+   main_c_()  ;      
+   return (0) ;
+} 
Index: /XMLIO_V2/dev/trunk/src/XMLIO/main_cpp.cpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/main_cpp.cpp	(revision 97)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/main_cpp.cpp	(revision 98)
@@ -1,40 +1,24 @@
-#include "field_attribut.hpp"
-#include "field.hpp"
-#include "group_template.hpp"
-#include "xmlio_std.hpp"
+#include "xmlio.hpp"
 
+using namespace XMLIOSERVER;
+using namespace XMLIOSERVER::XML;
+using namespace std;
 
 extern "C" void main_c_(void) ;
 
-  
-void main_c_(void)
+void main_c_ (void)
 {
-  try 
-  {
-    group<Field>* FirstGroup=new group<Field>("1") ;
-    group<Field> * MyGroup=FirstGroup->getNewGroup("group");
-    Field* MyField=MyGroup->getNewChild("toto") ;
-    MyField->setAttribut("name",string("titi")) ;
-    MyField->setAttribut("level",10) ;
-    
-    MyField=MyGroup->getNewChild("tata") ;
-    MyField->setAttribut("name",string("tutu")) ;
-    MyField->setAttribut("level",25) ;
-
-    MyField=MyGroup->getOrAppendChild("tete") ;
-    MyField->setAttribut("level",1) ;
-    
-    MyField=MyGroup->getChild("toto") ;
-    MyField->setAttribut("level",11) ;
-    
-    MyField->level=1 ;
-    
-    FirstGroup->Print() ;
-    StdOut<<iendl;
-    StdOut<<"This is the end"<<iendl ;
-  }
-  catch(ex_error x)
-  {
-    StdOut<<x.what<<endl ;
-  }
-}
+	try
+	{
+		XMLParser::CLASS_TEST();            
+		// Code Ã  executer ici
+	}
+	catch(const XMLIOException &exc)
+	{  // Pour tout type d'exceptions, on note les informations sur la sortie paramÃ©trÃ©e.
+		ERROR(exc.displayText()); 
+		// On retourne le code d'erreur en fin d'application pour traitements Ã©ventuels.
+//		return (exc.code());
+	}
+      
+//	return (0);
+} 
Index: LIO_V2/dev/trunk/src/XMLIO/object_template.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/object_template.hpp	(revision 97)
+++ 	(revision )
@@ -1,96 +1,0 @@
-#ifndef OBJECT_TEMPLATE_HPP
-#define OBJECT_TEMPLATE_HPP
-
-
-#include "base_object.hpp"
-#include "xmlio_std.hpp"
-
-template <typename CObject>
-class CObjectTemplate : public CBase_object
-{
-  public:
-  
-  static vector<CObject *> * List ;
-  static unordered_map<string,CObject *>* listId ;
-
-  CObjectTemplate(void) : CBase_object() {} ;
-  CObjectTemplate(const string & Id) : CBase_object(Id) {} ;
-
-  static void SwapContext(unordered_map<string,CObject *>* newListId,vector<CObject *> * newList)
-  {
-    listId=newListId ;
-    List=newList ;
-  }
-  
-  static bool found(const string & Id)
-  {
-    if (listId->find(Id)==listId->end()) return false ;
-    else return true ;
-  }
-  
-  static CObject* get(const string & Id)
-  {
-    typename unordered_map<string,CObject*>::iterator It ;
-
-    It=listId->find(Id) ;
-    if (It==listId->end())
-    {
-      error("CObjectTemplate<object>::get(const string & Id)")<<"Object <<"<<Id<<">> does not exist"<<endl ;
-      return 0 ;
-    }
-    else return It->second ;
-  }
-      
-  static CObject* getNew(void)
-  {
-    CObject * newObject=new CObject ;
-    List->push_back(newObject) ;
-    return newObject ;
-  }
-  
-  static CObject* getNew(const string & Id)
-  {
-    CObject* newField=new CObject(Id) ;
-    
-    pair<string,CObject *> value(Id,newField) ;
-    if (listId->insert(value).second) 
-    {
-      List->push_back(newField) ;
-      return newField ;
-    }
-    else
-    {
-      error("CObjectTemplate::getNew(const string & Id)")<<"Object <<"<<Id<<">> is already present"<<endl ;
-      return 0 ;
-    }
-  }
-  
-  static CObject* getOrAppend(const string & Id)
-  {
-    if (found(Id)) return get(Id) ;
-    else return getNew(Id) ;
-  }
-
-  ostream & Print(ostream& o)
-  {
-    o<<"Object : "<<CObject::getName()<<" : " ; 
-    PrintId(o)<<inc_endl ;
-    PrintAttribut(o) ;
-    o<<DecIndent ;
-    return o ;
-  }
-  
-  void Print(void)
-  {
-    Print(StdOut) ;
-  }
-
-   
-} ;
-
-template <typename CObject>
-vector<CObject *>* CObjectTemplate<CObject>::List=new vector<CObject*>  ;
-
-template <typename CObject>
-unordered_map<string,CObject *>* CObjectTemplate<CObject>::listId=new unordered_map<string,CObject *>  ;
-#endif
Index: LIO_V2/dev/trunk/src/XMLIO/stdout.cpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/stdout.cpp	(revision 97)
+++ 	(revision )
@@ -1,54 +1,0 @@
-#include <fstream>
-#include "xmlio_std.hpp"
-
-
-static const char file_stdout[]="xmlio.out" ;
-static const char file_stderr[]="xmlio.err" ;
-static const char file_stdlog[]="xmlio.log" ;
-
-
-// declaration of singleton for standard output 
-
-xmlio_stdout xmlio_stdout::FirstInstance ;
-xmlio_stdout & StdOut=xmlio_stdout::GetInstance() ;
-
-xmlio_stdout::xmlio_stdout(void) : std::ofstream(file_stdout)
-{
-  (*this)<<ResetIndent ;
-}
-  
-xmlio_stdout & xmlio_stdout::GetInstance(void)
-{
-  return FirstInstance ;
-}
-
-// declaration of singleton for standard error 
-
-xmlio_stderr xmlio_stderr::FirstInstance ;
-xmlio_stderr & StdErr=xmlio_stderr::GetInstance() ;
-
-xmlio_stderr::xmlio_stderr(void) : std::ofstream(file_stderr)
-{
-  (*this)<<ResetIndent ;
-}
-  
-xmlio_stderr & xmlio_stderr::GetInstance(void)
-{
-  return FirstInstance ;
-}
-  
-
-// declaration of singleton for standard error 
-
-xmlio_stdlog xmlio_stdlog::FirstInstance ;
-xmlio_stdlog & StdLog=xmlio_stdlog::GetInstance() ;
-
-xmlio_stdlog::xmlio_stdlog(void) : std::ofstream(file_stdlog)
-{
-  (*this)<<ResetIndent ;
-}
-  
-xmlio_stdlog & xmlio_stdlog::GetInstance(void)
-{
-  return FirstInstance ;
-}
Index: LIO_V2/dev/trunk/src/XMLIO/stdout.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/stdout.hpp	(revision 97)
+++ 	(revision )
@@ -1,47 +1,0 @@
-#ifndef STDOUT_HPP
-#define STDOUT_HPP
-
-#include <fstream>
-
-class xmlio_stdout : public std::ofstream
-{
-  public :
-  
-  static xmlio_stdout FirstInstance ;
-  static xmlio_stdout & GetInstance(void) ;
-  
-  private :
-  
-  xmlio_stdout(void) ;
-} ;
-
-extern xmlio_stdout & StdOut ;
-
-class xmlio_stderr : public std::ofstream
-{
-  public :
-  
-  static xmlio_stderr FirstInstance ;
-  static xmlio_stderr & GetInstance(void) ;
-  
-  private :
-  
-  xmlio_stderr(void) ;
-} ;
-extern xmlio_stderr & StdErr ;
-
-class xmlio_stdlog : public std::ofstream
-{
-  public :
-  
-  static xmlio_stdlog FirstInstance ;
-  static xmlio_stdlog & GetInstance(void) ;
-  
-  private :
-  
-  xmlio_stdlog(void) ;
-} ;
-extern xmlio_stdlog & StdLog ;
-
-#endif
-
Index: LIO_V2/dev/trunk/src/XMLIO/stdout_indent.cpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/stdout_indent.cpp	(revision 97)
+++ 	(revision )
@@ -1,16 +1,0 @@
-#include "xmlio_std.hpp"
-#include "stdout_indent.hpp"
-#include "stdout.hpp"
-
-int iostreamIndexIndent=ios::xalloc();
-
-
-static struct CInitStdOutIndent
-{
-  CInitStdOutIndent()
-  {
-    cout<<ResetIndent ;
-    cerr<<ResetIndent ;
-    clog<<ResetIndent ;
-  } ;
-} Init ;
Index: LIO_V2/dev/trunk/src/XMLIO/stdout_indent.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/stdout_indent.hpp	(revision 97)
+++ 	(revision )
@@ -1,54 +1,0 @@
-#ifndef STDOUT_INDENT_HPP
-#define STDOUT_INDENT_HPP
-#include "xmlio_std.hpp"
-
-extern int iostreamIndexIndent ;
-
-ostream& iendl(ostream& o) ;
-ostream& inc_endl(ostream& o) ;
-ostream& dec_endl(ostream& o) ;
-
-inline ostream& IncIndent(ostream& o)
-{
-  ++o.iword(iostreamIndexIndent) ;
-  return o ;
-}
-
-inline ostream& DecIndent(ostream& o)
-{
-  if (o.iword(iostreamIndexIndent)>0)
-    --o.iword(iostreamIndexIndent) ;
-  return o ;
-}
-
-inline ostream& ResetIndent(ostream& o)
-{
-  o.iword(iostreamIndexIndent)=0 ;
-  return o ;
-}
-
-inline ostream& iendl(ostream& o)
-{
-  o<<'\n' ;
-  int mem=o.width(o.iword(iostreamIndexIndent)*2) ;
-  o<<"";
-  o.width(mem) ;
-  return o ;
-}
-
-inline ostream& inc_endl(ostream& o)
-{
-  return o<<IncIndent<<iendl ;
-}
-
-inline ostream& dec_endl(ostream& o)
-{
-  return o<<DecIndent<<iendl ;
-}
-
-
-#endif
-
-
-
-
Index: LIO_V2/dev/trunk/src/XMLIO/test.cpp.old
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/test.cpp.old	(revision 97)
+++ 	(revision )
@@ -1,5 +1,0 @@
-void f(void)
-{
-  class { public : int n ;} toto ;
-  toto.n =1 ;
-}
Index: /XMLIO_V2/dev/trunk/src/XMLIO/xmlio.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/xmlio.hpp	(revision 98)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/xmlio.hpp	(revision 98)
@@ -0,0 +1,37 @@
+#ifndef __XMLIO__
+#define __XMLIO__
+
+/// EntÃªtes STL ///
+#include <utility>
+#include <string>
+
+#include <vector>
+#include <deque>
+
+#include <iostream>
+#include <fstream>
+
+/// EntÃªtes Poco ///
+#include <Poco/Exception.h>
+#include <Poco/HashMap.h>
+#include <Poco/Hash.h>
+
+/// EntÃªte Blitz array ///
+#include <blitz/array.h>
+
+/// EntÃªtes crÃ©Ã©s dans le cadre du projet XMLIOSERVER. ///
+#include "xmlio_exception.hpp"
+#include "xmlio_logger.hpp"
+#include "xmlio_container.hpp"
+#include "xmlio_object.hpp"
+#include "xmlio_xml_node.hpp"
+#include "xmlio_object_template.hpp"
+#include "field_attribut.hpp"
+#include "field.hpp"      
+#include "xmlio_group_template.hpp"      
+#include "field_group.hpp"      
+#include "context.hpp"
+#include "xmlio_xml_parser.hpp" 
+
+
+#endif // __XMLIO__ 
Index: /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_c_interface.cpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_c_interface.cpp	(revision 98)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_c_interface.cpp	(revision 98)
@@ -0,0 +1,14 @@
+/*
+extern "C"
+{ // DÃ©but du code C
+
+   using namespace XMLIOSERVER;
+   using namespace XMLIOSERVER::XML;
+   using namespace std;
+   
+   typedef void *XMLIOhandle;
+   
+   // VIDE TEMPORAIREMENT
+   
+}
+*/
Index: /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_container.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_container.hpp	(revision 98)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_container.hpp	(revision 98)
@@ -0,0 +1,101 @@
+#ifndef __XMLIO_CONTAINER__
+#define __XMLIO_CONTAINER__ 
+
+// Classes utilisÃ©es issues de Poco
+using Poco::HashMap;
+using Poco::Hash;
+
+// Classes utilisÃ©es issues de la STL
+using std::vector;
+using std::string;
+using std::pair;
+using std::ostream;
+
+// Classes XMLIOSERVER
+using XMLIOSERVER::XMLIOUndefinedValueException;
+
+namespace XMLIOSERVER
+{
+   template<class Key, class Mapped, class HashFunc = Hash<Key> >
+      class ExHashMap
+         : private HashMap<Key, Mapped*, Hash<Key> >
+   {
+      public :
+         ExHashMap() :  HashMap<Key, Mapped*, Hash<Key> >(), _elemList()
+         {/* Ne rien faire de plus */}
+               
+         Mapped* operator[] (const Key& kval) throw (XMLIOUndefinedValueException)
+         { 
+            if(!hasMappedValue(kval))
+               throw XMLIOUndefinedValueException("Appel de la mÃ©thode ExHashMap::operator[] invalide.");
+            return (find(kval)->second); 
+         }
+          
+         bool hasMappedValue(const Key& kval) {return (find(kval) != this->end());}
+          
+         const vector<Mapped*> getVector(void) { return (this->_elemList); }         
+
+         size_t getVectorSize(void) const {return (this->_elemList.size());}
+         size_t getSize(void) const {return (this->size());}
+         
+         virtual ~ExHashMap()
+         {/* Ne rien faire de plus */}
+         
+      protected :
+      
+         bool addValue(const Key& kval, Mapped* element)
+         {
+            pair<typename ExHashMap::Iterator,bool> p = this->insert(make_pair (kval,element));
+            if(!p.second) return (false);
+            return (this->addValue(element));
+         }
+         
+         bool addValue(Mapped* element)
+         {   this->_elemList.insert(this->_elemList.end(), element);   return (true);   }   
+         
+         
+         void removeValue(const Key& kval) // 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/trunk/src/XMLIO/xmlio_exception.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_exception.hpp	(revision 97)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_exception.hpp	(revision 98)
@@ -1,92 +1,79 @@
-#ifndef XMLIO_EXCEPTION_HPP
-#define XMLIO_EXCEPTION_HPP
+#ifndef __XMLIO_EXCEPTION__
+#define __XMLIO_EXCEPTION__ 
 
-#include <sstream>
-#include "xmlio_std.hpp"
-using namespace std ;
+// Classes utilisÃ©es issues de la STL
+using std::string;
 
-class ex_error
+// Classes utilisÃ©es issues de Poco
+using Poco::Exception;
+
+namespace XMLIOSERVER
 {
-  public :
-  string what ;
-  ex_error(const string & what_ ) : what(what_) {} ;
-} ;
+   class XMLIOException : public Exception
+   {
+      public :
+            
+         XMLIOException(int _code): Exception(_code)                                                   
+         { /* Ne rien faire de plus */ }                                                                     
+         XMLIOException(const std::string& _msg, int _code): Exception(_msg, _code)                              
+         { /* Ne rien faire de plus */ }                                                                        
+         XMLIOException(const std::string& _msg, const std::string& _arg, int _code): Exception(_msg, _arg, _code)      
+         { /* Ne rien faire de plus */ }                                                                        
+         XMLIOException(const std::string& _msg, const Poco::Exception& _exc, int _code): Exception(_msg, _exc, _code)   
+         { /* Ne rien faire de plus */ }   
+         
+                                                                              
+         XMLIOException(const XMLIOException& _exc): Exception(_exc)                                                
+         { /* Ne rien faire de plus */ }
+         
+         ~XMLIOException() throw()
+         { /* Ne rien faire de plus */ }
+         
+         XMLIOException& operator = (const XMLIOException& _exc)                                             
+         { Exception::operator = (_exc); return *this; }   
+                                                                           
+         virtual const char* name(void) const throw() { return ("XMLIO>XMLIOException"); }                                                                     
+         virtual const char* className(void) const throw() { return (typeid(*this).name()); }      
+                                                                     
+         virtual Exception* clone(void) const {   return new XMLIOException(*this); }                                                                     
+         virtual void rethrow(void) const { throw *this; }
+               
+   };// class XMLIOException
+   
+   class XMLIOUndefinedValueException : public XMLIOException
+   {
+      public :
+         XMLIOUndefinedValueException(const std::string& _msg): XMLIOException(_msg, 1001) {}
+         const char* name(void) const throw() { return ("XMLIO>UndefinedValueException"); }
+            
+   }; //class XMLIOUndefinedException
+   
+   class XMLIOStreamException : public XMLIOException
+   {
+      public :
+         XMLIOStreamException(const std::string& _msg): XMLIOException(_msg, 1002) {}
+         const char* name(void) const throw() { return ("XMLIO>StreamException"); }
+            
+   }; //class XMLIOStreamException
+   
+   class XMLParsingException : public XMLIOException
+   {
+      public :
+         XMLParsingException(const std::string& _msg): XMLIOException(_msg, 1003) {}
+         const char* name(void) const throw() { return ("XMLIO>XMLParsingException"); }
+            
+   }; //class XMLParsingException
+   
+   class XMLIOIncompatibeTypeException : public XMLIOException
+   {
+      public :
+         XMLIOIncompatibeTypeException(const std::string& _msg): XMLIOException(_msg, 1003) {}
+         const char* name(void) const throw() { return ("XMLIO>XMLIOIncompatibeTypeException"); }
+            
+   }; //class XMLIOIncompatibeTypeException
+   
+   // A complÃ©ter.
+   
+};// namespace XMLIOSERVER
 
-//class error;
-//ostringstream & operator << (const error & err,char const * str) ;
-//ostringstream & operator << (const error & err,const string & str) ;
-
-
-class error : public ostringstream
-{
-  public :
-    
-    error(const string & where) : ostringstream()
-    {
-      *this<<"*** Error **** in function : "<<where<<endl<<"------> "<<string("toto") ;
-    } ;
-    
-    error(const char * where) : ostringstream()
-    {
-      *this<<"Error in function : "<<where<<endl<<"------> " ;
-    } ;
-
-    ~error()
-    {
-      StdErr<< this->str() <<endl ;
-      throw(ex_error(this->str())) ;
-    } ;
-
-   ostringstream & operator << (char const * str) const
-   {
-     ostringstream * tmp=const_cast <error *>(this) ;
-     *tmp<<str ;
-     return *tmp ;
-   } ;
-
-   ostringstream & operator << (const string& str) const
-   {
-     ostringstream * tmp=const_cast <error *>(this) ;
-     *tmp<<str ;
-     return *tmp ;
-   } ; 
-
-} ;
-
-class warning : public ostringstream
-{
-  public :
-    
-    warning(const string & where) : ostringstream()
-    {
-      *this<<"*** Warning **** in function : "<<where<<endl<<"------> ";
-    } ;
-    
-    warning(const char * where) : ostringstream()
-    {
-      *this<<"Error in function : "<<where<<endl<<"------> " ;
-    } ;
-
-    ~warning()
-    {
-      StdErr<< this->str() <<endl ;
-    } ;
-
-   ostringstream & operator << (char const * str) const
-   {
-     ostringstream * tmp=const_cast <warning *>(this) ;
-     *tmp<<str ;
-     return *tmp ;
-   } ;
-
-   ostringstream & operator << (const string& str) const
-   {
-     ostringstream * tmp=const_cast <warning *>(this) ;
-     *tmp<<str ;
-     return *tmp ;
-   } ; 
-
-} ;
-
-
-#endif
+#endif // __XMLIO_EXCEPTION__ 
Index: /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_group_template.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_group_template.hpp	(revision 98)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_group_template.hpp	(revision 98)
@@ -0,0 +1,88 @@
+#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 */}            
+      
+         virtual const char* getName(void) const {return ("GroupTemplate"); }
+                 
+         /// Pour les groupes d'objets enfants ///
+         
+         GroupTemplate<T, U>& createGroup(const string _id) throw (XMLIOUndefinedValueException) 
+         {
+            GroupTemplate<T, U> &obj = GroupTemplate<T, U>::CreateObject(_id);
+            groupList.addObject(&obj);
+              
+            return (GroupTemplate<T, U>::GetObject(_id));
+         }
+         
+         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); }
+         
+         size_t getNbChild() const {return (childList.getVectorSize()); }
+            
+        
+         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:
+      
+      private:
+         StrHashMap<T> childList;
+         StrHashMap<GroupTemplate<T, U> > groupList;
+
+   }; // class GroupTemplate
+   
+   
+   
+}// namespace XMLIOSERVER
+
+
+#endif // __XMLIO_GROUP_TEMPLATE__
Index: /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_logger.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_logger.hpp	(revision 98)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_logger.hpp	(revision 98)
@@ -0,0 +1,93 @@
+#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>
+
+
+// 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);
+         }
+
+         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");
+
+#define   ERROR(MSG)   (ILogger::GetConsoleLogger().error(MSG))
+#define   WARNING(MSG)   (ILogger::GetConsoleLogger().warning(MSG))
+#define   INFO(MSG)   (ILogger::GetConsoleLogger().information(MSG))
+// A complÃ©ter.
+
+
+
+/************* POUR MEMOIRE **********************
+#include <stdio.h> 
+#include <execinfo.h> 
+#include <signal.h> 
+#include <stdlib.h> 
+ 
+void handler(int sig) { 
+  void *array[10]; 
+  size_t size; 
+  // get void*'s for all entries on the stack 
+  size = backtrace(array, 10); 
+  // print out all the frames to stderr 
+  fprintf(stderr, "Error: signal %d:\n", sig); 
+  backtrace_symbols_fd(array, size, 2); 
+  exit(1); 
+} 
+void baz() { 
+ int *foo = (int*)-1; // make a bad pointer 
+  printf("%d\n", *foo);       // causes segfault 
+} 
+void bar() { baz(); } 
+void foo() { bar(); } 
+ 
+int main(int argc, char **argv) { 
+  signal(SIGSEGV, handler);   // install our handler 
+  foo(); // this will call foo, bar, and baz.  baz segfaults. 
+} 
+ 
+ ***************************************************************/
+   
+}; // namespace XMLIOSERVER
+
+#endif // __XMLIO_LOGGER__  
Index: /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_object.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_object.hpp	(revision 98)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_object.hpp	(revision 98)
@@ -0,0 +1,68 @@
+#ifndef __XMLIO_OBJECT__
+#define __XMLIO_OBJECT__ 
+
+// Classes utilisÃ©es issues de la STL
+using std::pair;
+using std::string;
+using std::ostream;
+using std::ostringstream;
+
+// Classes XMLIOSERVER
+using XMLIOSERVER::XMLIOException;
+using XMLIOSERVER::XMLIOUndefinedValueException;
+
+namespace XMLIOSERVER
+{
+   class AbstractObject 
+   {
+      public :
+      
+         AbstractObject(void) : IdDefined(false)
+         {/* Ne rien faire de plus */}
+         
+         AbstractObject(const string& _id) : id(_id), IdDefined(true)
+         {/* Ne rien faire de plus */}      
+   
+         const string& getId(void) throw (XMLIOUndefinedValueException)
+         { if (!IdDefined) throw XMLIOUndefinedValueException("Appel de la mÃ©thode AbstractObject::getId invalide."); return (id); }   
+         
+         bool hasId(void) const { return(IdDefined); }
+         void resetId(void) { IdDefined = false ;}
+         void setId(const string& _id) { id = _id ; IdDefined = true ;}
+         
+         bool operator==(const AbstractObject& other)
+         {
+            // Si l'un ou l'autre des objets n'a pas d'identifiant, les objets de ne sont pas "Ã©gaux".
+            if(!this->hasId() or !other.hasId()) return false;
+            return (id.compare(other.id) == 0);
+         }
+         
+         friend ostream& operator<< (ostream& out, const AbstractObject& c) 
+         { out << c.toString(); return (out);}   
+         
+         virtual ~AbstractObject(void)
+         {/* Ne rien faire de plus */}
+      
+      protected :
+      
+         virtual string toString(void) const
+         {
+            ostringstream st("[");
+            st << "[" << this->getName();
+            if (hasId()) st << " id=\"" <<  id << "\"";
+            st << "]" ;
+            return (st.str());
+         }
+         
+         virtual const char* getName(void) const {return ("AbstractObject"); }
+            
+      private :
+      
+         string id ;
+         bool IdDefined ;
+      
+   };// class AbstractObject
+   
+}// namespace XMLIOSERVER
+
+#endif // __XMLIO_OBJECT__   
Index: /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_object_template.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_object_template.hpp	(revision 98)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_object_template.hpp	(revision 98)
@@ -0,0 +1,74 @@
+#ifndef __XMLIO_OBJECT_TEMPLATE__
+#define __XMLIO_OBJECT_TEMPLATE__ 
+
+// Classes utilisÃ©es issues de la STL
+using std::pair;
+using std::string;
+using std::ostream;
+
+using XMLIOSERVER::StrHashMap;
+   
+namespace XMLIOSERVER
+{
+   template <class T>
+      class ObjectTemplate : public AbstractObject
+   {
+      public :
+         
+         static T& CreateObject(const string _id) throw (XMLIOUndefinedValueException) 
+         {
+            // Si l'identifiant est rÃ©pertoriÃ©, on retourne l'Ã©lÃ©ment existant.
+            if(ObjectTemplate<T>::HasObject(_id))
+               return (ObjectTemplate<T>::GetObject(_id));
+                              
+            // Ajout d'un nouvel objet si l'identifiant n'est pas rÃ©pertoriÃ©.           
+            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)// << Bug
+         { 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 const char* getName(void) const {return ("ObjectTemplate"); }
+         
+         virtual ~ObjectTemplate(void)
+         {/* Ne rien faire de plus */}
+         
+      protected :
+      
+         ObjectTemplate(void) : AbstractObject()
+         {/* Ne rien faire de plus */}         
+         ObjectTemplate(const string& _id) : AbstractObject(_id) 
+         {/* Ne rien faire de plus */}
+         
+      private :
+         
+         static 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: LIO_V2/dev/trunk/src/XMLIO/xmlio_std.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_std.hpp	(revision 97)
+++ 	(revision )
@@ -1,21 +1,0 @@
-#ifndef XMLIO_STD_HPP
-#define XMLIO_STD_HPP
-
-
-
-#include <blitz/array.h>
-#include <string>
-#include <iostream>
-#include <vector>
-#include <map>
-#include <unordered_map>
-using namespace blitz ;
-using namespace std ;
-//using namespace std::tr1 ;
-
-#include "stdout.hpp"
-#include "stdout_indent.hpp"
-#include "xmlio_exception.hpp"
-
-
-#endif
Index: /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_xml_node.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_xml_node.hpp	(revision 98)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_xml_node.hpp	(revision 98)
@@ -0,0 +1,168 @@
+#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;
+
+using Poco::XML::AutoPtr;
+
+namespace XMLIOSERVER
+{
+   namespace XML
+   {
+      
+      typedef HashMap<string, string> THashAttributes;
+         
+      // TODO Mettre des auto_ptr ici car gestion de la mÃ©moire lamentable sans.
+      typedef AutoPtr<Document> PDocument;
+      typedef Node*    PNode;
+         
+      class XMLNode
+      {
+         public :
+            
+            XMLNode(const string& _rootName) : rootName(_rootName) 
+            { /* Ne rien faire de plus */}          
+
+            static XMLNode& CreateNode(XMLNode& node, istream& _istr, const string& _rootName = string("simulation"))
+            {
+               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);
+                  if (!(node.pDoc->documentElement()->nodeName().compare(_rootName)))
+                  {
+                     node.setCNode(node.pDoc->documentElement());
+                     node.goToChildElement();
+                  }
+                  else
+                  {
+                     ostringstream oss;
+                     oss << "L'Ã©lÃ©ment racine doit avoir pour valeur <" << _rootName << "> (\"" <<  (node.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->getCNode()->nodeName());}
+                
+            bool goToNextElement(void) 
+            {
+               PNode 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)
+            {
+               PNode 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++)
+                  attributes[map->item(i)->nodeName()] = map->item(i)->nodeValue();
+
+               return (true);
+            }
+            
+            ~XMLNode() 
+            { /* Ne rien faire de plus */ }
+            
+         protected :
+         
+            PNode getCNode(void) const {return (this->cNode); }
+            void setCNode(PNode other) { this->cNode = other; }
+            
+            static bool IsPtrNull(PNode ptr) {return (ptr==NULL);}
+            
+         private :
+            PDocument pDoc; 
+            PNode  cNode;
+            
+            string rootName;      
+         
+      };// class XMLNode
+      
+         }; // namespace XML
+
+};// namespace XMLIOSERVER
+
+
+#endif // __XMLIO_XML_NODE__ 
Index: /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_xml_parser.hpp
===================================================================
--- /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_xml_parser.hpp	(revision 98)
+++ /XMLIO_V2/dev/trunk/src/XMLIO/xmlio_xml_parser.hpp	(revision 98)
@@ -0,0 +1,76 @@
+#ifndef __XMLIO_XML_PARSER__
+#define __XMLIO_XML_PARSER__ 
+
+// Utilisation de la STL
+using std::string;
+
+namespace XMLIOSERVER
+{
+   namespace XML
+   {          
+      using XMLIOSERVER::Context;
+      
+      class XMLParser
+      {
+         public : 
+         
+            static void Parse(XMLNode& _node)
+            {
+               THashAttributes attributes;
+                              
+               do {                
+                 // Traitement de l'identifiant
+                  _node.getAttributes(attributes);
+                            
+                  if (attributes.end() == attributes.find("id"))
+                  { WARNING("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Ã  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());               
+            } 
+            
+            static void FreeMemory(void)
+            {
+               HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
+               
+               for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
+               {
+                  string& id = (*it).first;
+                  StrHashMap<Context>& sc = (*it).second;
+                  // BUG AllListContext contient une StrHashMap<Context> liÃ©e Ã  l'identifiant "" d'oÃ¹ la vÃ©rification ci-dessous.
+                  if (id.size()>0) delete sc[id];
+               }
+            }
+            
+            static bool CLASS_TEST(const string& file = string("/local/testsuite/iodef_test.xml"), ostream& log = std::clog)
+            {
+               ifstream istr( file.c_str() , ifstream::in );
+               XMLNode node("simulation");
+               XMLNode::CreateNode(node, istr, "simulation");
+               XMLParser::Parse(node);
+               log << "Nombre de Contexts listÃ©s : " << Context::GetCurrentListObject().getSize() << " contre 1 attendus."<< std::endl;
+               log << "Nombre de FieldGroups listÃ©s : " << FieldGroup::GetCurrentListObject().getSize() << " contre 5 attendus."<< std::endl;
+               log << "Description du champs votkeavt : " << Field::GetObject("votkeavt").description << " contre \"Vertical Eddy Diffusivity\" attendus."<< std::endl;
+               
+               log << "Test  XMLParser ... ok !" << std::endl;
+               
+               FreeMemory(); // Pour supprimer la mÃ©moire liÃ©e Ã  l'allocation dynamique.
+               
+               return (true);
+            }
+                 
+      }; // class XMLParser     
+   }; // namespace XML
+
+};// namespace XMLIOSERVER
+
+
+#endif // __XMLIO_XML_PARSER__ 
