Index: /XMLIO_V2/dev/dev_rv/old/attribut.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/attribut.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/attribut.hpp	(revision 90)
@@ -0,0 +1,91 @@
+#ifndef ATTRIBUT_HPP
+#define ATTRIBUT_HPP
+
+#include "base_attribut.hpp"
+#include "xmlio_std.hpp"
+
+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;
+};
+
+
+template <class Ctype>
+   class CAttribut : public CBaseAttribut
+{
+  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 ; 
+  } ;
+  
+  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) 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<< 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)  error("void CAttribut<Ctype>::getValue")<<"access to undefined value of attribut <<"
+                                                               <<this->getName()<<">>"<<endl;
+    value_=value ;
+  }
+
+} ;
+
+
+  
+#endif
Index: /XMLIO_V2/dev/dev_rv/old/attribut_registrar.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/attribut_registrar.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/attribut_registrar.hpp	(revision 90)
@@ -0,0 +1,75 @@
+#ifndef ATTRIBUT_REGISTRAR_HPP
+#define ATTRIBUT_REGISTRAR_HPP
+
+#include "base_attribut.hpp"
+#include "xmlio_std.hpp"
+
+using Poco::HashMap;
+
+class CAttributRegistrar
+{
+  public :
+  
+  
+  void RegisterAttribut(CBaseAttribut & attribut) ;
+  ostream & PrintAttribut(ostream & o) ;
+
+  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 ;
+  }
+  
+  void setSAttribut(const string& att_name, const std::string& value)
+  {
+    unordered_map<string,CBaseAttribut *>::iterator it ;
+    
+    
+    std::cout << "lol" << std::endl;
+    it=attrMap.find(att_name) ;
+    std::cout << "lol" << std::endl;
+    if (it!=attrMap.end()) (*it).second->setFromString(value) ;
+    else error("CAttributRegistrar::setAttribut<ValueType>")
+         <<"Could not find <<"<<att_name<<">> attribut in registred list"<<endl ;
+    
+  }
+  
+  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 ;
+}
+
+
+#endif
Index: /XMLIO_V2/dev/dev_rv/old/base_attribut.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/base_attribut.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/base_attribut.hpp	(revision 90)
@@ -0,0 +1,87 @@
+#ifndef BASE_ATTRIBUT_HPP
+#define BASE_ATTRIBUT_HPP
+#include "xmlio_std.hpp"
+
+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 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)
+  {
+     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: /XMLIO_V2/dev/dev_rv/old/base_object.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/base_object.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/base_object.hpp	(revision 90)
@@ -0,0 +1,31 @@
+#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/dev_rv/old/context.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/context.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/context.hpp	(revision 90)
@@ -0,0 +1,182 @@
+#ifndef __CONTEXT__
+#define __CONTEXT__
+
+#include "xmlio_std.hpp"
+#include "xml_parser.hpp"
+
+// Gestion des attributs
+#include "attribut_registrar.hpp"
+#include "attribut.hpp"
+#include "declare_attribut.hpp"
+#include "base_object.hpp"
+
+// Pour les champs
+#include "field.hpp"
+
+/// HISTORIQUE ///
+// <RV> 26/04/10- 27/04/10  : Nouvelle implÃ©mentation classes Simulation (racine) et Context sÃ©parÃ©es.
+// <RV> 30/04/10            : VÃ©rification de la classe avec XmlIOServer::XML::XMLClassTest comme enfant >> OK.
+
+/**
+ * \file  context.hpp
+ * \brief Ce fichier contient le code source permettant d'analyser diffÃ©rents contexts de sortie.
+ * \author Ozdoba HervÃ© (contact: herve.ozdoba@glsce.ipsl.fr)
+ * \author Meurdesoif Yann (contact Yann.Meurdesoif@cea.fr)
+ * \version 0.1.0
+ * \date Avril - Mai  2010
+ */
+
+// Utilisation de la biliothÃšque XmlIOServer
+using XmlIOServer::XML::XMLElement;
+using XmlIOServer::XML::TNodeType;
+using XmlIOServer::XML::THashAttributes;
+using XmlIOServer::XML::TListElements;
+
+// Utilisation de la STL
+using std::string;
+
+// Utilisation de la biliothÃšque POCO
+using Poco::HashMap;
+
+namespace XmlIOServer
+{
+	class Simulation : public XMLElement
+	{
+		public:
+			Simulation()
+			{ /*std::cout << "[simulation]" << std::endl;*/ } // sortie pour test uniquement.
+			
+			virtual XMLElement* addChild(TNodeType type, TListElements& path, THashAttributes& attr);
+				
+			virtual XMLElement* getPReference(void) {return (NULL);}
+			
+			friend ostream& operator<< (ostream& out, const Simulation& c)
+			{ out << "[simulation]";	return out;	}
+						
+		protected:
+		
+		private:			
+	
+	}; // class Simulation
+	
+	// Pas nÃ©cessaire de crÃ©er cette classe mais utile pour vÃ©rification.
+	class ContextAttribut : public virtual CBase_object
+	{
+		public :
+		
+			/*DECLARE_ATTR(id, string) ; */
+			// DÃ©claration des autres attributs de la classe Context ici.
+
+			ContextAttribut()
+			{ /*RegisterAttribut(id);*/ }
+	  
+	}; // class ContextAttribut
+	
+	class Context : public XMLElement, public ContextAttribut
+	{
+		public:
+		
+			typedef HashMap<string, Context*> THashContext;
+			
+			Context()
+				: field_definition(NULL, true), file_definition(this), grid_definition(this), axis_definition(this)
+			{std::cerr << "Context() > Ne devrait pas Ãªtre appelÃ©" << std::endl;}
+			
+			Context(TNodeType type, THashAttributes& attr)
+				: field_definition(this, true), file_definition(this), grid_definition(this), axis_definition(this)
+			{
+				// Ajout des attributs ...
+				AllContext[attr["id"]] = this;
+				
+				// TODO VÃ©rifier l'existence de l'identifiant.	
+				this->setId(attr["id"])	;
+				Context::SetCurrentContext(attr["id"]);
+			}
+			
+			static Simulation* GetRootElement() {return (Context::Root);}
+			static const THashContext& GetAllContext() {return (Context::AllContext);}
+			
+			static bool SetCurrentContext(const string& id)
+			{
+				if(Context::AllContext.end() == Context::AllContext.find(id))return (false);
+				CurrentContextID = id;
+				
+				return (true);
+			}
+			static Context* GetCurrentContext(void) { return(Context::AllContext[CurrentContextID]);}
+			static string& GetCurrentContextID(void){ return(Context::CurrentContextID); }
+			
+			/// POUR PARSING ///
+			virtual XMLElement* addChild(TNodeType type, TListElements& path, THashAttributes& attr)
+			{				
+				switch (type)
+				{
+					case (TNodeType::FIELD_GROUP): // FIELD_GROUP
+					// Autres actions Ã  effectuer ici... //
+						if (attr.end() != attr.find("id")) this->field_definition.setId(attr["id"]); // l'id est-il utile ici?
+						this->field_definition.setAttributes(attr);
+						std::cout << "    " << this->field_definition << std::endl;
+						return (&field_definition);
+						
+					case (TNodeType::FILE_GROUP): // FILE_GROUP
+					// Autres actions Ã  effectuer ici... //
+						return (&file_definition);
+						
+					case (TNodeType::AXIS_GROUP): // AXIS_GROUP
+					// Autres actions Ã  effectuer ici... //
+						return (&axis_definition);	
+						
+					case (TNodeType::GRID_GROUP): // GRID_GROUP
+					// Autres actions Ã  effectuer ici... //
+						return (&grid_definition);	
+					default :
+						std::cerr << "Balise inconnue sur context"<< std::endl;
+						return (NULL);
+				}
+			}
+			
+			friend ostream& operator<< (ostream& out, const Context& c)
+			{ out << "  [context id=\'" << c.id << "\']"; return out; }
+				
+			virtual XMLElement* getPReference(void) {return (Context::GetRootElement());}
+			
+			FieldGroup& getFieldDefinition(void) {return (this->field_definition);}
+			
+			const XmlIOServer::XML::XMLClassTest& getFileDefinition (void) {return (this->file_definition);}
+			const XmlIOServer::XML::XMLClassTest& getGridDefinition (void) {return (this->grid_definition);}
+			const XmlIOServer::XML::XMLClassTest& getAxisDefinition (void) {return (this->axis_definition);}
+			
+			~Context()
+			{/* Ne rien faire de plus pour le moment */ }
+			
+		protected:
+		
+		private:
+		
+			FieldGroup field_definition;
+			
+			XmlIOServer::XML::XMLClassTest  file_definition, grid_definition, axis_definition;
+		
+			static string CurrentContextID;
+			static Simulation* Root;
+			static THashContext AllContext;
+		
+	}; //class Context
+	
+	// Variables statiques
+	Simulation* Context::Root = new Simulation();	
+	Context::THashContext Context::AllContext;	
+	string Context::CurrentContextID;
+	
+	// DÃ©finition de Simulation::addChild reportÃ©e ici car Class Context non dÃ©finie prÃ©cÃ©demment.
+	XMLElement* Simulation::addChild(TNodeType type, TListElements& path, THashAttributes& attr)
+	{ 
+		if (type != 1) std::cerr << "Type reÃ§u sur Simulation invalide" << std::endl;
+		Context *ct = new Context(type, attr);
+		std::cout << *ct << std::endl;
+		return (ct);
+	}
+	
+}// namespace XmlIOServer
+
+#endif //__CONTEXT__
Index: /XMLIO_V2/dev/dev_rv/old/declare_attribut.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/declare_attribut.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/declare_attribut.hpp	(revision 90)
@@ -0,0 +1,16 @@
+#ifndef DECLARE_ATTRIBUT_HPP
+#define DECLARE_ATTRIBUT_HPP
+#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 ;} ; \
+    virtual const char * getType(void) const { return #att_type ;} ; \
+    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
+
+#endif
Index: /XMLIO_V2/dev/dev_rv/old/field.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/field.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/field.hpp	(revision 90)
@@ -0,0 +1,214 @@
+#ifndef FIELD_HPP
+#define FIELD_HPP
+
+#include "xmlio_std.hpp"
+#include "xml_parser.hpp"
+
+#include "base_object.hpp"
+#include "object_template.hpp"
+#include "group_template.hpp"
+
+#include "field_attribut.hpp"
+
+// Utilisation de la biliothÃšque XmlIOServer
+using XmlIOServer::XML::XMLElement;
+using XmlIOServer::XML::TNodeType;
+using XmlIOServer::XML::THashAttributes;
+using XmlIOServer::XML::TListElements;
+
+using XmlIOServer::XML::XMLParser;
+
+// Utilisation de la STL
+using std::string;
+using std::pair;
+
+
+class FieldGroup : public group<CBase_object>, public XMLElement,public CFieldGroupAttribut
+{
+	public :
+			
+		FieldGroup(XMLElement* pgr, bool fd = false) : group<CBase_object>(), CFieldGroupAttribut()	
+		{ this->pgroup = pgr; this->fdefinition = fd; }
+			
+		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;
+		}
+		
+		bool isFieldDefinition(void) { return (this->fdefinition); }
+		
+		void parseIncludedFile(const string& path, const TListElements& tpath)
+		{
+			std::cout << "^^^^^^^^^^^^^^^^^^^^^^^^^" << std::endl;
+			string elname;			
+			if (fdefinition) elname.assign("field_definition");
+			else elname.assign("field_group");
+			
+			{// PARSING	DE FICHIER INCLU
+				XMLParser parser(path, elname);	
+				parser.setTreePath(tpath);
+				parser.parse(this);
+			}
+			std::cout << "^^^^^^^^^^^^^^^^^^^^^^^^^" << std::endl;
+		}
+		
+		friend ostream& operator<< (ostream& out, const FieldGroup& c)
+		{ 
+			if (c.fdefinition) out << "[field_definition " ;
+			else out << "[field_group" ;
+			if(c.hasId) out << " id=\'" << c.id << "\'"; 
+			for (unordered_map<string,CBaseAttribut *>::const_iterator it = c.attrMap.begin(); it != c.attrMap.end(); it++)
+				out << " " <<(*it).first << "=\'" << *((*it).second) << "\'"; 
+			out << "]";
+			return out; 		
+		}
+				
+		FieldGroup* getFieldGroupChild(const string & Id) {return ((FieldGroup*)getGroup(Id)); }
+		
+		template <typename T>
+			T getFieldChild(const string & Id) {return ((T)getChild(Id)); }
+			
+		/// IMPORTANT POUR PARSING ///
+		virtual XMLElement* addChild(TNodeType type, TListElements& path, THashAttributes& attr);
+		virtual XMLElement* getPReference(void){ return (this->pgroup);}
+		
+		~FieldGroup() {/* Ne rien faire de plus */}
+		
+	protected :
+	
+		// Vide pour le moment.
+	
+	private :
+	
+		XMLElement* pgroup;
+		bool fdefinition;
+		
+}; // class FieldGroup
+
+class Field : public XMLElement, public CObjectTemplate<Field>, public CFieldAttribut
+{
+	public:
+			
+		Field(void) : CObjectTemplate<Field>(), CFieldAttribut() {} ;
+		Field(const string & Id) : CObjectTemplate<Field>(Id), CFieldAttribut() {} ;
+		
+		void setAttributes(const THashAttributes& attr, const TListElements& path)
+		{
+			// Mise en place des attributs hÃ©ritÃ©s
+			for(unsigned int i = 1; i < path.size()-1; i++)
+				for (THashAttributes::ConstIterator it = path[i].list.begin(); it != path[i].list.end(); it++)
+					if ((*it).first.compare(string("id")) 
+					and (*it).first.compare(string("name"))
+					and (*it).first.compare(string("description"))
+					and (*it).first.compare(string("src")))
+						this->setSAttribut((*it).first, (*it).second);
+		
+			// Mise en place des attributs locaux
+			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;
+		}		
+		
+		// IMPORTANT : constructeur pour parsing
+		Field(FieldGroup* pgr) : CObjectTemplate<Field>(), CFieldAttribut(){ this->pgroup = pgr; }		
+		Field(FieldGroup* pgr, const string & Id) : CObjectTemplate<Field>(Id), CFieldAttribut() { this->pgroup = pgr; }	
+		
+		// getName est-elle vraiment nÃ©cessaire?
+		static const char * getName(void) { return ("field") ; }
+    
+		/// IMPORTANT POUR PARSING ///
+		virtual XMLElement* addChild(TNodeType type, TListElements& path, THashAttributes& attr) { return (NULL); } // Aucun retour car Ã©lÃ©ment en fin d'arbre.    
+		virtual XMLElement* getPReference(void){ return (this->pgroup);}
+		
+		friend ostream& operator<< (ostream& out, const Field& c)
+		{ 
+			out << "[field" ;	
+			if(c.hasId) out << " id=\'" << c.id << "\'"; 	
+			for (unordered_map<string,CBaseAttribut *>::const_iterator it = c.attrMap.begin(); it != c.attrMap.end(); it++)
+				out << " " <<(*it).first << "=\'" << *((*it).second) << "\'"; 
+			out << "]";
+			return out; 		
+		}
+		
+		~Field()
+		{/* Ne rien faire de plus */}
+
+	protected :
+	
+		// Vide pour le moment.
+		
+	private :
+	
+		FieldGroup* pgroup;
+		
+}; // class Field
+
+XMLElement* FieldGroup::addChild(TNodeType type, TListElements& path, THashAttributes& attr)
+{
+	FieldGroup* childgroup = NULL;
+	Field* childfield = NULL;
+		
+	switch (type)
+	{
+		case (TNodeType::FIELD_GROUP): // FIELD_GROUP
+		{
+			// Autres actions Ã  effectuer ici... //
+			childgroup = new FieldGroup(this);
+			this->groupList->push_back(childgroup) ;
+			
+			
+			if (attr.end() != attr.find("id"))
+			{
+				pair<string,FieldGroup*> value(attr["id"], childgroup) ;
+				this->groupListId->insert(value);
+				childgroup->setId(attr["id"]);
+			}
+			childgroup->setAttributes(attr);
+			
+			for(int i = 0; i<path.size(); i++) std::cout << "  ";
+			std::cout << *childgroup << std::endl;
+			
+			// Gestion de l'inclusion de fichier.
+			if (attr.end() != attr.find("src")) 
+				childgroup->parseIncludedFile(attr["src"], path);
+			
+			return (childgroup);
+		}
+			
+		case (TNodeType::FIELD): // FIELD
+		{
+			// Autres actions Ã  effectuer ici... //
+			childfield = new Field(this);
+			this->childList->push_back(childfield) ;							
+			
+			if (attr.end() != attr.find("id"))
+			{
+				pair<string,Field*> value(attr["id"], childfield) ;
+				this->childListId->insert(value);
+				childfield->setId(attr["id"]);
+			}
+			childfield->setAttributes(attr, path);
+			
+			for(int i = 0; i<path.size(); i++) std::cout << "  ";
+			std::cout << *childfield << std::endl;
+				
+			return (childfield);
+		}						
+		
+		default :
+		
+			std::cerr << "Balise inconnue sur FieldGroup"<< std::endl;
+			return (NULL);
+	}
+};// MÃ©thode FieldGroup::addChild
+
+#endif
+
+
+
Index: /XMLIO_V2/dev/dev_rv/old/field_attribut.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/field_attribut.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/field_attribut.hpp	(revision 90)
@@ -0,0 +1,60 @@
+#ifndef FIELD_ATTRIBUT_HPP
+#define FIELD_ATTRIBUT_HPP
+
+#include "attribut_registrar.hpp"
+#include "attribut.hpp"
+#include "declare_attribut.hpp"
+
+class CFieldAttribut : public virtual CAttributRegistrar
+{
+	public :
+   
+		DECLARE_ATTR(name, string) ;
+		DECLARE_ATTR(description, string) ; 
+		DECLARE_ATTR(unit, string) ;
+		DECLARE_ATTR(operation, string);
+   
+		DECLARE_ATTR(freq_op, int) ;
+		DECLARE_ATTR(level, int) ;
+		DECLARE_ATTR(prec, int) ;
+   
+		DECLARE_ATTR(enabled, bool);
+   
+		DECLARE_ATTR(axis_ref, string);
+		DECLARE_ATTR(grid_ref, string);		
+		DECLARE_ATTR(zoom_ref, string);
+		DECLARE_ATTR(field_ref, string);
+   
+		CFieldAttribut(void)
+		{
+			RegisterAttribut(name) ;
+			RegisterAttribut(description) ; 
+			RegisterAttribut(unit) ;
+			RegisterAttribut(operation);
+   
+			RegisterAttribut(freq_op) ;
+			RegisterAttribut(level) ;
+			RegisterAttribut(prec) ;
+   
+			RegisterAttribut(enabled);
+   
+			RegisterAttribut(axis_ref);
+			RegisterAttribut(grid_ref);
+			RegisterAttribut(zoom_ref);
+			RegisterAttribut(field_ref);
+		}
+  
+} ; // class CFieldAttribut
+
+class CFieldGroupAttribut : public CFieldAttribut
+{
+	public :
+  
+		DECLARE_ATTR(src, string) ;
+      
+		CFieldGroupAttribut(void):CFieldAttribut()
+		{ RegisterAttribut(src) ; }
+  
+} ; //class CFieldGroupAttribut
+
+#endif //FIELD_ATTRIBUT_HPP
Index: /XMLIO_V2/dev/dev_rv/old/group_template.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/group_template.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/group_template.hpp	(revision 90)
@@ -0,0 +1,186 @@
+#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/dev_rv/old/main_cpp.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/main_cpp.cpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/main_cpp.cpp	(revision 90)
@@ -0,0 +1,68 @@
+/*#include "field_attribut.hpp"
+#include "field.hpp"
+#include "group_template.hpp"*/
+
+#include "context.hpp"
+
+//g++ -std=c++0x  -g  -I ../../../external/include/ -L/local/tools/svn/external/lib main_cpp.cpp stdout.cpp stdout_indent.cpp 
+// ... -lPOCO_XML -lPOCO_Foundation -lpthread;
+
+using namespace XmlIOServer;
+using namespace XmlIOServer::XML;
+
+//extern "C" void main_c_(void) ;
+
+////////////////////////////////////////////////////////////////////
+
+//void main_c_(void)
+int main(void)
+{
+	//XMLParser::ClassTest(XMLTEST_PATH);
+
+	try
+	{
+		XMLParser parser("/local/testsuite/iodef_test.xml");	
+		std::cout << *Context::GetRootElement() << std::endl;
+		parser.parse(Context::GetRootElement());	
+		
+		std::cout << "=============================================" << std::endl;
+		
+		Context::SetCurrentContext("nemo");
+		
+		std::cout << "ID CONTEXT 1 : "
+				<< Context::GetCurrentContext()->id << std::endl;
+		std::cout << "LEVEL CONTEXT 1>FieldDefinition : " 
+				<< Context::GetCurrentContext()->getFieldDefinition().level.value << std::endl;
+		std::cout << "FREQ_OP CONTEXT 1>FieldDefinition : " 
+				<< Context::GetCurrentContext()->getFieldDefinition().freq_op.value << std::endl;
+		std::cout << "AXIS_REF CONTEXT 1>FieldDefinition>grid_T : "
+				<< Context::GetCurrentContext()->getFieldDefinition().getFieldGroupChild(string("grid_T"))->axis_ref.value << std::endl;
+		std::cout << "DESCRIPTION CONTEXT 1>FieldDefinition>grid_T>sowaflup : "	
+				<< Context::GetCurrentContext()->getFieldDefinition().getFieldGroupChild(string("grid_T"))->getFieldChild<Field*>(string("sowaflup"))->description.value << std::endl;
+				
+		std::cout << std::endl << "VÃ©rification inclusion de fichier : " << std::endl;			
+		
+		std::cout << "UNIT CONTEXT 1>FieldDefinition>grid_U>sozotaux : "	
+				<< Context::GetCurrentContext()->getFieldDefinition().getFieldGroupChild(string("grid_U"))->getFieldChild<Field*>(string("sozotaux"))->unit.value << std::endl;
+		std::cout << "AXIS_REF CONTEXT 1>FieldDefinition>grid_U>vozocrtx : "	
+				<< Context::GetCurrentContext()->getFieldDefinition().getFieldGroupChild(string("grid_U"))->getFieldChild<Field*>(string("vozocrtx"))->axis_ref.value << std::endl;
+		
+		std::cout << std::endl << "VÃ©rification changement de context : " << std::endl;
+		
+		Context::SetCurrentContext("nemo_bis");
+		std::cout << "ID CONTEXT 2 : "
+				<< Context::GetCurrentContext()->id << std::endl;
+				
+		std::cout << "=============================================" << std::endl;
+
+	}
+	catch(ex_error err)
+	{ std::cerr << err.what << std::endl; }
+	catch (Poco::Exception& exc)
+	{ std::cerr << (exc.displayText()) << std::endl; }
+	
+	return (0); // EXIT_SUCCESS
+};
+////////////////////////////////////////////////////////////////////
+  
+
Index: /XMLIO_V2/dev/dev_rv/old/object_template.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/object_template.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/object_template.hpp	(revision 90)
@@ -0,0 +1,96 @@
+#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: /XMLIO_V2/dev/dev_rv/old/stdout.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/stdout.cpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/stdout.cpp	(revision 90)
@@ -0,0 +1,54 @@
+#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: /XMLIO_V2/dev/dev_rv/old/stdout.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/stdout.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/stdout.hpp	(revision 90)
@@ -0,0 +1,47 @@
+#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: /XMLIO_V2/dev/dev_rv/old/stdout_indent.cpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/stdout_indent.cpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/stdout_indent.cpp	(revision 90)
@@ -0,0 +1,16 @@
+#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: /XMLIO_V2/dev/dev_rv/old/stdout_indent.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/stdout_indent.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/stdout_indent.hpp	(revision 90)
@@ -0,0 +1,54 @@
+#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: /XMLIO_V2/dev/dev_rv/old/xml_parser.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/xml_parser.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/xml_parser.hpp	(revision 90)
@@ -0,0 +1,462 @@
+#ifndef __XML_PARSER__
+#define __XML_PARSER__
+
+#include "xmlio_std.hpp"
+
+/// HISTORIQUE ///
+// <RV> 20/04/10 - 23/04/10 : Nouvelle implÃ©mentation parsing, crÃ©ation de la classe principale XmlIOServer::XML::XMLParser.
+// <RV> 23/04/10            : CrÃ©ation de la classe abstraite XmlIOServer::XML::XMLElement + ajout de quelques commentaires.
+// <RV> 26/04/10            : Ajout de la gestion simplifiÃ©e des hÃ©ritages descendants + gestion des flux de sortie.
+// <RV> 29/04/10            : Ajout de la gestion simplifiÃ©e des attributs par dÃ©faut.
+// <RV> 30/04/10            : CrÃ©ation et VÃ©rification de la classe de test XML XmlIOServer::XML::XMLClassTest.
+// <RV> 03/05/10            : Nouvelle implÃ©mentation classe de test + ajout de tous les commentaires.
+// <RV> 04/05/10            : Suppression documentation excessive + correction de 2 problÃšmes de parsing sur situations particuliÃšres non gÃ©rÃ©es.
+
+/**
+ * \file  XMLParser.hpp
+ * \brief Ce fichier contient le code source permettant de parser un fichier de configuration xml pour le serveur d'E/S.
+ * \author Ozdoba HervÃ© (contact: herve.ozdoba@glsce.ipsl.fr)
+ * \author Meurdesoif Yann (contact Yann.Meurdesoif@cea.fr)
+ * \version 0.1.0
+ * \date Avril - Mai  2010
+ */
+
+// Utilisation de la STL
+using std::string;
+
+using std::pair;
+using std::vector;
+using std::deque;
+
+using std::ifstream;
+using std::ostream;
+
+// 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::XML::AutoPtr;
+
+using Poco::Exception;
+using Poco::HashMap;
+
+/**
+ * \namespace XmlIOServer
+ * \brief Cet espace de nommage regroupe l'intÃ©gralitÃ© des classes du serveur des E/S.
+ * \see XmlIOServer::XML
+ *
+ * Espace de nommage gÃ©nÃ©ral qui regroupe toutes les classes dont dÃ©pend le serveur de gestion des entrÃ©es/sorties
+ * parallÃšles avec configuration par fichier de donnÃ©es xml.
+ */
+namespace XmlIOServer
+{
+	/**
+	 * \namespace XmlIOServer::XML
+	 * \brief Cet espace de nommage contient les classes permettant de parser le fichier de configuration XML.
+	 */
+	namespace XML
+	{
+		/**
+		 * \typedef pair<string, string> TAttribute
+		 * \brief DÃ©finition d'un type pair associant un nom d'attribut Ã  sa valeur.
+		 * \see TListAttributes
+		 *
+		 * Ce type permet de rÃ©cupÃ©rer une pair contenant :
+		 * \li Le nom de l'attribut;
+		 * \li La valeur associÃ©e Ã  l'attribut sous forme de chaÃ®ne de caractÃšres.
+		 */
+		typedef pair<string, string> TAttribute;
+
+		/**
+		 * \typedef HashMap<string, string> THashAttributes
+		 * \brief DÃ©finition d'une HashMap de TAttribute.
+		 * \see TAttribute
+		 */
+		typedef HashMap<string, string> THashAttributes;
+		
+		/**
+		 * \enum TNodeType
+		 * \brief DÃ©finition d'un type de noeud xml.
+		 */
+		typedef enum 
+		{
+			UNKNOWN = 0, CONTEXT = 1,
+			FIELD_GROUP = 2, FILE_GROUP = 3, AXIS_GROUP = 4, GRID_GROUP = 5,
+			FIELD = 6, FILE = 7, AXIS = 8, GRID = 9
+			
+		} TNodeType;
+		
+		/**
+		 * \struct XmlIOServer::XML::_element
+		 * \brief  Association d'un type de noeud avec un HashMap des attributs qui lui sont associÃ©s.
+		 */
+		
+		/**
+		 * \typedef struct XmlIOServer::XML::_element TElement
+		 * \brief RedÃ©finition du type _element pour simplification d'Ã©criture.
+		 * \see _element
+		 */
+		typedef struct _element
+		{
+			/**
+			 * \fn _element(TNodeType t, THashAttributes& l)
+			 * \brief Simple constructeur du structure.
+			 * \param t Un type d'Ã©lÃ©ment.
+			 * \param l Une HashMap d'attributs associÃ©  Ã  l'Ã©lÃ©ment.
+			 */
+			_element(TNodeType t, THashAttributes& l) : type(t),list(l)
+			 { /* Ne rien faire de plus */};
+			
+			/**
+			 * \var TNodeType type
+			 * \brief Type d'Ã©lÃ©ment.
+			 */
+			TNodeType type; 
+			
+			/**
+			 * \var THashAttributes list
+			 * \brief HashMap d'attributs.
+			 */			
+			THashAttributes list; //< HashMap d'attributs.
+			
+		} TElement;
+		
+	
+		/**
+		 * \typedef deque<TElement> TListElements
+		 * \brief Liste de TElement utilisÃ©e comme pile pour la gestion (optionnelle) 
+		 * 	de l'hÃ©ritage descendant dans la classe de parsing xml.
+		 * \see XmlIOServer::XML::XMLParser::path
+		 */
+		typedef deque<TElement> TListElements;
+
+		/**
+		 * \typedef Document* PDocument
+		 * \brief RedÃ©finition du pointeur sur document xml pour simplification d'Ã©criture.
+		 */
+		typedef Document*	PDocument;
+		
+		/**
+		 * \typedef Node* PNode
+		 * \brief RedÃ©finition du pointeur sur noeud xml pour simplification d'Ã©criture.
+		 * \see XmlIOServer::XML::cNode
+		 */
+		typedef Node*		PNode;
+		
+		/**
+		 * \class XMLElement
+		 * \brief Classe abstraite pour parsing xml.
+		 * \see XmlIOServer::XML::XMLParser
+		 * 
+		 * Les classes susceptibles d'Ãªtre instanciÃ©es par parsing Xml doivent hÃ©riter des fonctions de celle-ci pour Ãªtre
+		 * traoter par la classe XMLParser.
+		 */
+		class XMLElement
+		{
+			public :
+			
+				// TODO ? Enlever le param. name serait une bonne chose ?
+				/**
+				 * \fn XMLElement* addChild(TNodeType type, string name, THashAttributes& attr)
+				 * \brief Fonction appelÃ©e par XMLParser signifiant l'ajout d'un fils Ã  l'Ã©lÃ©ment actuel.
+				 * \param type le type du noeud Ã  ajouter.
+				 * \param name le nom du noeud Ã  ajouter (liÃ© au paramÃªtre <i>type</i>)
+				 * \param attr une HashMap des attributs associÃ©s Ã  l'Ã©lÃ©ment Ã  ajouter.
+				 * \return Un pointeur sur l'Ã©lÃ©ment fils nouvellement crÃ©Ã©. 
+				 */
+				virtual XMLElement* addChild(TNodeType type, TListElements& path, THashAttributes& attr) = 0;
+				
+						
+				/**
+				 * \fn XMLElement* getPReference(void)
+				 * \brief Renvoie la rÃ©fÃ©rence au noeud parent e l'Ã©lÃ©ment actuel.
+				 * \return la rÃ©fÃ©rence au noeud parent.
+				 * 
+				 */
+				virtual XMLElement* getPReference(void) = 0;
+							
+		}; // class XMLElement
+		
+		/**
+		 * \class XMLClassTest
+		 * \brief Une classe de test pour le parsing xml.
+		 *  
+		 * Une simple classe de test qui Ã©crit les arguments reÃ§us lors du parsing vers la console.
+		 */		
+		class XMLClassTest : public XMLElement
+		{
+			public:
+			
+				/**
+				 * \fn XMLClassTest()
+				 * \brief Simple constructeur d'initialisation d'un Ã©lÃ©ment racine.
+				 */
+				XMLClassTest(XMLElement* ref = NULL)
+				{
+					this->pref = ref;
+					//std::cout << "[simulation]" << std::endl;
+				}
+			
+				/**
+				 * \fn XMLClassTest(XMLClassTest* ref, TNodeType type, string& name, THashAttributes& attr)
+				 * \brief Constructeur pour tout autre Ã©lÃ©ment que celui de la racine.
+				 * \param ref RÃ©fÃ©rence Ã  l'Ã©lement parent (thÃ©orique, celui qui appelle le constructeur via la mÃ©thode addChild).
+				 * \param type Le type du noeud Ã  instancier.
+				 * \param name Le nom du noeud Ã  instancier.
+				 * \param attr Une HashMap des attributs liÃ©s au noeud Ã  instancier.
+				 */
+				XMLClassTest(XMLClassTest* ref, TNodeType type, THashAttributes& attr)
+				{
+					this->pref = ref;
+					//for(int i = 0; i<INC; i++) std::cout << "  ";
+					/*std::cout << "[" << type;
+					
+					for (THashAttributes::Iterator it = attr.begin(); it != attr.end(); it++)
+						std::cout << " "<< (*it).first<< "=\"" << (*it).second << "\"";
+						
+					std::cout << "]" << std::endl;*/
+				}
+				
+				friend ostream& operator<< (ostream& out, const XMLClassTest& c)
+				{ out << "[Non implÃ©mentÃ©e]" << std::endl; return out; }
+				
+				virtual XMLClassTest* addChild(TNodeType type, TListElements& path, THashAttributes& attr) 
+				{ INC++; return (new XMLClassTest(this, type, attr)); }
+				
+				virtual XMLElement* getPReference(void) { INC--; return (this->pref); }
+				
+				/**
+				 * \fn ~XMLClassTest() 
+				 * \brief Simple destructeur.
+				 */
+				~XMLClassTest() { /* Ne rien faire de plus */ }
+				
+			protected:
+			
+			private:
+			
+				/**
+				 * \var XMLClassTest* pref
+				 * \brief RÃ©fÃ©rence au parent de l'Ã©lÃšment actuel (NULL si on se trouve Ã  la racine).
+				 */
+				XMLElement* pref; // TODO VÃ©rifier la gestion de la mÃ©moire.
+				
+				/**
+				 * \var int INC
+				 * \brief Entier permettant de connaÃ®tre le niveau d'incrÃ©mentation pour l'Ã©criture sur la sortie standard.
+				 */
+				static int INC;
+				
+		}; // class XMLClassTest
+		
+		int XMLClassTest::INC = 0;
+
+		/**
+		 * \class XMLParser
+		 * \brief Classe qui initie le parsing d'un fichier de configuration Xml.
+		 *
+		 * Cette classe permet de parser un document XML afin de configurer le serveur des E/S.\n
+		 * Cette mÃ©thode de rÃ©cupÃ©ration des paramÃštres est statique puisque le traitement est effectuÃ© une fois au
+		 * dÃ©marrage du serveur.\n Elle est complÃ©mentaire d'une seconde mÃ©thode, dynamique cette fois, consistant Ã  paramÃ©trer
+		 * l'application par remoting client-serveur Ã  travers MPI.
+		 */
+		class XMLParser
+		{
+			public :
+
+				XMLParser(const string& filename, const string& rootName = string("simulation"))
+				{ 
+					XMLParser();
+					ifstream istr( filename.data() , ifstream::in );
+					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)))
+						{
+							this->cNode = pDoc->documentElement();
+							this->goToChildElement();
+						}
+						else
+							std::cout 	<< "L'Ã©lÃ©ment racine doit avoir pour valeur <"<< rootName <<"> (\""
+										<<  (pDoc->documentElement()->nodeName()) <<"\" lue)"<< std::endl;
+	
+					}
+					else
+						std::cout << "Impossible de lire le flux du fichier en entrÃ©e !" << std::endl;
+				}
+
+				
+				void parse(XMLElement* const root, ostream& log = std::cout)
+				{
+					XMLElement* current = root;
+					THashAttributes attr;
+					bool start = true;
+					
+					do{
+						if(!start)path.pop_back();
+						while((start) ? start : this->goToNextElement()) // PARCOURS SUR ELEMENT SUIVANT
+						{
+							// APPEL ADD PARENT
+							if(!start)path.pop_back();
+							
+							this->getAttributes(attr);
+							path.push_back(TElement(this->getElementType(), attr));
+							current = current->addChild(this->getElementType(),this->getTreePath(), attr);
+							attr.clear();
+							
+							while (this->goToChildElement()) // PARCOURS SUR ELEMENT ENFANT
+							{
+								// APPEL ADD LOCAL
+								this->getAttributes(attr); // ou getGlobalAttributes pour gestion de l'hÃ©ritage descendant.
+								path.push_back(TElement(this->getElementType(), attr));
+								current = current->addChild(this->getElementType(),this->getTreePath(), attr);
+								attr.clear();
+							}
+
+							current = current->getPReference();
+
+							if (start) start = false;			
+						}
+						
+						if(current == root ) break; 
+						else current = current->getPReference();
+									
+					} while(this->goToParentElement()); // PARCOURS SUR ELEMENT PARENT
+					
+					return;
+				}
+		
+				~XMLParser()
+				{ /* Ne rien faire pour le moment*/ }
+				
+				static void ClassTest(const char* path)
+				{
+					try
+					{					
+						// Instanciation du parseur.
+						XMLParser parser(path);											
+						// Instanciation de l'objet racine.
+						XMLClassTest root ; 
+					
+						// DÃ©but du parsing XML ...
+						parser.parse(&root);
+					}
+					catch (Exception& exc)
+					{
+						// TODO : Remplacer sorties vers cerr et cout par exception
+						std::cerr << (exc.displayText()) << std::endl;
+					}
+										
+					return;
+				}
+				
+				TListElements& getTreePath() { return (this->path); }
+				void setTreePath(const TListElements& p) { this->path = p; }
+
+			protected :
+				
+				TNodeType getElementType(void) const 
+				{
+					if(this->isElementName("context"))return (CONTEXT);
+					
+					// les groupes, quels qu'ils soient.
+					if(this->isElementName("field_definition") or this->isElementName("field_group"))return (FIELD_GROUP);
+					if(this->isElementName("file_definition")  or this->isElementName("file_group")) return (FILE_GROUP);
+					if(this->isElementName("axis_definition")  or this->isElementName("axis_group")) return (AXIS_GROUP);
+					if(this->isElementName("grid_definition")  or this->isElementName("grid_group")) return (GRID_GROUP);
+					
+					// les Ã©lÃ©ments finaux (hormis "file").
+					if(this->isElementName("field"))return (FIELD);
+					if(this->isElementName("file")) return (FILE);
+					if(this->isElementName("axis")) return (AXIS);
+					if(this->isElementName("grid")) return (GRID);
+					
+					return (UNKNOWN);
+				}
+				
+				//////////////////////// PARSING //////////////////////////////
+
+				// TODO voir pour rÃ©cupÃ©rer une rÃ©fÃ©rence.
+				string getElementName(void) const {return (this->cNode->nodeName());}
+				
+				bool isElementName(const char* val) const {return !(this->getElementName().compare(string(val)));}
+				
+				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->setCurrentNode(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(string("simulation")))) return (false);
+					this->setCurrentNode(this->cNode->parentNode());
+					return (true);
+				}
+				
+				bool getAttributes(THashAttributes& attributes)
+				{
+					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);
+				}
+				
+			private :
+			
+				XMLParser() : path() //pDoc(), cNode() << Ancien
+				{ /* Ne rien faire de plus */ }
+			
+				bool setCurrentNode(PNode node){ if (!node) return false; this->cNode = node; return (true);}				
+				PNode getCurrentNode(void){return (this->cNode);}
+
+				/** 
+				 * \var AElement cNode
+				 * \brief Pointeur sur l'objet reprÃ©sentant l'Ã©lÃ©ment courant.
+				 */
+				PNode  cNode;
+				
+				TListElements path;
+						
+		};// class XMLParser
+		
+	};// namespace XML
+	
+};// namespace XmlIOServer
+
+#endif //__XML_PARSER__
+
Index: /XMLIO_V2/dev/dev_rv/old/xmlio_exception.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/xmlio_exception.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/xmlio_exception.hpp	(revision 90)
@@ -0,0 +1,92 @@
+#ifndef XMLIO_EXCEPTION_HPP
+#define XMLIO_EXCEPTION_HPP
+
+#include <sstream>
+//#include "xmlio_std.hpp"
+using namespace std ;
+
+class ex_error
+{
+  public :
+  string what ;
+  ex_error(const string & what_ ) : what(what_) {} ;
+} ;
+
+//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()
+    {
+      std::cerr<< 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
Index: /XMLIO_V2/dev/dev_rv/old/xmlio_std.hpp
===================================================================
--- /XMLIO_V2/dev/dev_rv/old/xmlio_std.hpp	(revision 90)
+++ /XMLIO_V2/dev/dev_rv/old/xmlio_std.hpp	(revision 90)
@@ -0,0 +1,43 @@
+#ifndef XMLIO_STD_HPP
+#define XMLIO_STD_HPP
+
+// EntÃªtes STL
+#include <utility>
+#include <string>
+
+#include <vector>
+#include <deque>
+
+#include <iostream>
+#include <fstream>
+
+// EntÃªtes Poco DOM
+#include <Poco/DOM/DOMParser.h>
+#include <Poco/DOM/Document.h>
+#include <Poco/DOM/Element.h>
+
+#include <Poco/DOM/NamedNodeMap.h>
+
+//#include <Poco/DOM/AutoPtr.h>
+
+// EntÃªtes Poco SAX
+#include <Poco/SAX/InputSource.h>
+
+// EntÃªtes Poco
+#include <Poco/Exception.h>
+#include <Poco/HashMap.h>
+
+
+/////////////////////////
+#include <blitz/array.h>
+#include <map>
+#include <unordered_map>
+
+using namespace blitz ;
+using namespace std ;
+
+#include "stdout.hpp"
+#include "stdout_indent.hpp"
+#include "xmlio_exception.hpp"
+
+#endif
