Index: XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute.cpp	(revision 257)
+++ XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute.cpp	(revision 257)
@@ -0,0 +1,70 @@
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, XMLIOServer, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
+
+/**
+ * \file    attribute.cpp
+ * \brief   Gestion des attributs des objets dans la hierarchie de la bibliothÃšque (implÃ©mentation).
+ * \author  HervÃ© Ozdoba
+ * \version 0.4
+ * \date    1er Juin 2011
+ */
+
+// XMLIOServer headers
+#include "xmlioserver_spl.hpp"
+#include "attribute.hpp"
+
+// /////////////////////////////// DÃ©finitions ////////////////////////////// //
+
+namespace xmlioserver {
+namespace tree {
+  
+   // ------------------------------ Constructeurs -----------------------------
+   CAttribute::CAttribute(const std::string & _id)
+      : CObject(_id), value()
+   { /* Ne rien faire de plus */ }
+
+   CAttribute::CAttribute(const CAttribute & _attribut_ref)
+      : CObject(_attribut_ref.getId())
+   { 
+      this->value = _attribut_ref.getAnyValue(); 
+   }
+   
+   // ------------------------------- Destructeur ------------------------------
+   
+   CAttribute::~CAttribute(void)
+   { /* Ne rien faire de plus */ }
+   
+   // ------------------------------- Accesseurs -------------------------------
+
+   const boost::any & CAttribute::getAnyValue(void) const
+   { 
+      return (this->value); 
+   }
+
+   const std::string & CAttribute::getName(void) const
+   { 
+      return (this->getId()); 
+   }
+   
+   // --------------------------- Tests sur l'objet ----------------------------
+
+   bool CAttribute::isEmpty(void) const
+   { 
+      return (this->value.empty()); 
+   }
+   
+   // ------------------------------- Mutateurs --------------------------------
+   
+   void CAttribute::setAnyValue(const boost::any & _value)
+   { 
+      this->value = _value; 
+   }
+      
+   void CAttribute::clear(void)
+   {
+      this->value = boost::any(); 
+   }
+   
+} // namespace tree
+} // namespace xmlioserver
Index: XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute.hpp	(revision 257)
+++ XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute.hpp	(revision 257)
@@ -0,0 +1,92 @@
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, XMLIOServer, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
+
+#ifndef __ATTRIBUTE_HPP__
+#define	__ATTRIBUTE_HPP__
+
+/**
+ * \file    attribute.hpp
+ * \brief   Gestion des attributs des objets dans la hierarchie de la bibliothÃšque (entÃªte).
+ * \author  HervÃ© Ozdoba
+ * \version 0.4
+ * \date    1er Juin 2011
+ */
+
+#ifndef __XIOS_NO_EXTERN
+
+// C++ standard headers
+#include <string>
+#include <iostream>
+
+// boost headers
+#include <boost/any.hpp>
+
+#endif // __XIOS_NO_EXTERN
+
+// XMLIOServer headers
+#include "object.hpp"
+
+// ////////////////////////////// DÃ©clarations ///////////////////////////// //
+
+namespace xmlioserver 
+{
+   namespace tree
+   {
+      /**
+      * \class CAttribute
+      * \brief Classe de gestion des attributs non-typÃ©s et optionnels
+      * pour les diffÃ©rents objets de la bibliothÃšque.
+      */
+      class CAttribute : public CObject
+      {
+            typedef CObject SuperClass;
+
+         public : // Constructeurs publics
+
+            explicit CAttribute(const std::string & _id);
+            CAttribute(const CAttribute & _attribut_ref);
+            CAttribute(const CAttribute * const _attribut_ptr); // Not implemented.
+
+        public : // Accesseurs
+
+            const std::string & getName(void) const;
+            const boost::any & getAnyValue(void) const;
+            template <typename T> inline T getValue(void) const;
+
+        public : // Mutateurs
+
+            template <typename T> inline void setValue(const T & _new_value);
+            void setAnyValue(const boost::any & _new_value);
+            void clear(void);
+
+        public : // Test ///
+
+            bool isEmpty(void) const;
+            template <typename T> inline bool isType(void);
+
+        public : // Destructeur ///
+
+            virtual ~CAttribute(void);
+
+        public : // Autres
+
+            virtual std::string toString(void) const          = 0;
+            virtual void fromString(const std::string & _str) = 0;
+
+            virtual void toBinary  (std::ostream & _os) const = 0;
+            virtual void fromBinary(std::istream & _is)       = 0;
+
+         protected :// Constructeur protÃ©gÃ©
+
+            CAttribute(void);  // Not implemented.
+
+         private : // PropriÃ©tÃ©
+
+            boost::any value;
+
+      }; // class CAttribute
+   } // namespace tree
+} // namespace xmlioserver
+
+#endif	// __ATTRIBUTE_HPP__
Index: XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_impl.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_impl.hpp	(revision 257)
+++ XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_impl.hpp	(revision 257)
@@ -0,0 +1,46 @@
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, XMLIOServer, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
+
+#ifndef __ATTRIBUTE_IMPL_HPP__
+#define	__ATTRIBUTE_IMPL_HPP__
+
+/**
+ * \file    attribute_impl.hpp
+ * \brief   Gestion des attributs des objets dans la hierarchie de la bibliothÃšque (implÃ©mentation template).
+ * \author  HervÃ© Ozdoba
+ * \version 0.4
+ * \date    1er Juin 2011
+ */
+
+// /////////////////////////////// DÃ©finitions ////////////////////////////// //
+
+namespace xmlioserver {
+namespace tree {
+  
+   // ------------------------------- Accesseurs -------------------------------
+   
+   template <typename T> T CAttribute::getValue(void) const
+   { 
+      return (boost::any_cast<T>(this->value)); 
+   }
+   
+   // ------------------------------- Mutateurs --------------------------------
+   
+   template <typename T> void CAttribute::setValue(const T & value)
+   { 
+      this->value = value; 
+   }
+   
+   // --------------------------- Tests sur l'objet ----------------------------
+   
+   template<typename T> bool CAttribute::isType(void)
+   { 
+      return (this->value.type() == typeid(T)); 
+   }
+  
+  
+} // namespace tree
+} // namespace xmlioserver
+
+#endif // __ATTRIBUTE_IMPL_HPP__
Index: XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_map.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_map.cpp	(revision 257)
+++ XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_map.cpp	(revision 257)
@@ -0,0 +1,196 @@
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, XMLIOServer, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
+
+/**
+ * \file    attribute_map.cpp
+ * \brief   Gestion des map d'attributs d'objets (implÃ©mentation).
+ * \author  HervÃ© Ozdoba
+ * \version 0.4
+ * \date    1er Juin 2011
+ */
+
+// XMLIOServer headers
+#include "xmlioserver_spl.hpp"
+#include "attribute_map.hpp"
+#include "attribute_impl.hpp"
+#include "attribute_template_impl.hpp"
+
+// /////////////////////////////// DÃ©finitions ////////////////////////////// //
+
+namespace xmlioserver {
+namespace tree {
+  
+   // -------------------------- PropriÃ©tÃ© statique ----------------------------
+  
+   CAttributeMap * CAttributeMap::Current = NULL;
+   
+   // ------------------------------ Constructeur ------------------------------
+   
+   CAttributeMap::CAttributeMap(void)
+      : xios_map<std::string, CAttribute*>()
+   { 
+      CAttributeMap::Current = this; 
+   }
+   
+   // ------------------------------- Destructeur -----------------------------
+   
+   CAttributeMap::~CAttributeMap(void)
+   { /* Ne rien faire de plus */ }
+   
+   // --------------------------- Tests sur l'objet ----------------------------
+   
+   bool CAttributeMap::hasAttribute(const std::string & _key) const
+   { 
+      return (this->find(_key) != this->end()); 
+   }
+   
+   // ------------------------------- Mutateurs --------------------------------
+   
+   void CAttributeMap::clearAllAttributes(void)
+   {
+      typedef std::pair<std::string, CAttribute*> StdStrAttPair;
+      SuperClassMap::const_iterator it = SuperClassMap::begin(), end = SuperClassMap::end();
+      for (; it != end; it++)
+      {
+         const StdStrAttPair & att = *it;
+         if (!att.second->isEmpty()) att.second->clear();
+      }
+   }
+       
+   void CAttributeMap::setAttribute(const std::string & _key, CAttribute * const _attribute) throw (CException)
+   {
+      if (!this->hasAttribute(_key))
+         XIOS_ERROR("CAttributeMap::setAttribute(key, attr)",
+                    << "[ key = " << _key << "] key not found !");
+      if (_attribute == NULL)
+         XIOS_ERROR("CAttributeMap::setAttribute(key, attr)",
+                     << "[ key = " << _key << "] attr is null !");
+      this->find(_key)->second->setAnyValue(_attribute->getAnyValue());
+   }
+   
+   void CAttributeMap::setAttributes(const std::map <std::string, std::string> & _attributes)
+   {
+      for (std::map <std::string, std::string>::const_iterator it  = _attributes.begin();
+                                                               it != _attributes.end();
+                                                               it ++)
+         if ((*it).first.compare(std::string("id")) != 0 &&
+             (*it).first.compare(std::string("src"))!= 0)
+         {
+            //if (CAttributeMap::operator[]((*it).first)->isEmpty())
+            CAttributeMap::operator[]((*it).first)->fromString((*it).second);
+         }
+   }
+   
+   void CAttributeMap::setAttributes(const CAttributeMap * const _parent)
+   {
+      typedef std::pair<std::string, CAttribute*> StdStrAttPair;
+      
+      SuperClassMap::const_iterator it = _parent->begin(), end = _parent->end();
+      for (; it != end; it++)
+      {
+         const StdStrAttPair & el = *it;
+         if (this->hasAttribute(el.first))
+         {
+            CAttribute * currAtt = CAttributeMap::operator[](el.first);
+            if (currAtt->isEmpty() && !el.second->isEmpty())
+            {
+               this->setAttribute(el.first, el.second);
+            }
+         }
+      }
+   }   
+   
+   // ------------------------------- OpÃ©rateur --------------------------------
+   
+   CAttribute * CAttributeMap::operator[](const std::string & _key) throw (CException)
+   {
+      if (!this->hasAttribute(_key))
+         XIOS_ERROR("CAttributeMap::operator[](const StdString & key)",
+                    << "[ key = " << _key << "] key not found !");
+      return (SuperClassMap::operator[](_key));
+   }
+   
+   // -------------------------- Conversion en chaÃ®ne --------------------------   
+   
+   std::string CAttributeMap::toString(void) const
+   {
+      typedef std::pair<std::string, CAttribute*> StdStrAttPair;
+      std::ostringstream oss;
+      
+      SuperClassMap::const_iterator it = SuperClassMap::begin(), end = SuperClassMap::end();
+      for (; it != end; it++)
+      {
+         const StdStrAttPair & att = *it;
+         if (!att.second->isEmpty())
+            oss << *att.second << " ";
+      }
+      return (oss.str());
+   }
+   
+   void CAttributeMap::fromString(const std::string & _str) throw (CException)
+   { 
+      XIOS_ERROR("CAttributeMap::fromString(const StdString & str)",
+                 << "[ str = " << _str << "] Not implemented yet !"); 
+   }
+
+   //StdOStream & operator << (StdOStream & os, const CAttributeMap & attributmap)
+   //{ os << attributmap.toString(); return (os); }
+   
+   // -------------------------- Conversion binaire ----------------------------
+   
+   void CAttributeMap::toBinary(std::ostream & _os) const
+   {
+      typedef std::pair<std::string, CAttribute*> StdStrAttPair;
+      SuperClassMap::const_iterator it = this->begin(), end = this->end();
+      
+      const std::size_t nbatt = SuperClassMap::size();
+      _os.write (reinterpret_cast<const char*>(&nbatt) , sizeof(std::size_t));
+      
+      for (; it != end; it++)
+      {
+         const std::string & key   = it->first;
+         const CAttribute  * value = it->second;            
+         const std::size_t   size  = key.size();
+         
+         _os.write (reinterpret_cast<const char*>(&size) , sizeof(std::size_t));
+         _os.write (key.data(), size * sizeof(char));
+         
+         if (!value->isEmpty())
+         {
+            bool b = true;
+            _os.write (reinterpret_cast<const char*>(&b) , sizeof(bool));
+            value->toBinary(_os);
+         }
+         else 
+         {
+            bool b = false;
+            _os.write (reinterpret_cast<const char*>(&b) , sizeof(bool));
+         }
+      }
+   }
+   
+   void CAttributeMap::fromBinary(std::istream & _is) throw (CException)
+   {
+      std::size_t nbatt = 0;
+      _is.read (reinterpret_cast<char*>(&nbatt), sizeof(std::size_t));
+      
+      for (std::size_t i = 0; i < nbatt; i++)
+      {
+         bool hasValue = false;
+         std::size_t size  = 0;
+         _is.read (reinterpret_cast<char*>(&size), sizeof(std::size_t));
+         std::string key(size, ' ');
+         _is.read (const_cast<char *>(key.data()), size * sizeof(char));
+         
+         if (!this->hasAttribute(key))
+            XIOS_ERROR("CAttributeMap::fromBinary(StdIStream & is)",
+                        << "[ key = " << key << "] key not found !");
+                                     
+         _is.read (reinterpret_cast<char*>(&hasValue), sizeof(bool));
+         if (hasValue) this->operator[](key)->fromBinary(_is);
+      }
+   }
+      
+} // namespace tree
+} // namespace xmlioserver
Index: XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_map.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_map.hpp	(revision 257)
+++ XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_map.hpp	(revision 257)
@@ -0,0 +1,79 @@
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, XMLIOServer, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
+
+#ifndef __ATTRIBUTE_MAP_HPP__
+#define	__ATTRIBUTE_MAP_HPP__
+
+/**
+ * \file    attribute_map.hpp
+ * \brief   Gestion des map d'attributs d'objets (entÃªte).
+ * \author  HervÃ© Ozdoba
+ * \version 0.4
+ * \date    1er Juin 2011
+ */
+
+// XMLIOServer headers
+#include "xmlioserver_spl.hpp"
+#include "attribute.hpp"
+#include "attribute_template.hpp"
+
+// ////////////////////////////// DÃ©clarations ///////////////////////////// //
+
+namespace xmlioserver {
+   namespace tree {
+     
+      class CAttributeMap
+         : public xios_map<std::string, CAttribute*>
+      {
+            typedef xios_map<std::string, CAttribute*> SuperClassMap;
+
+         public : // Test
+
+            inline bool hasAttribute(const std::string & _key) const;
+
+         public : // Accesseur
+
+            CAttribute * operator[](const std::string & _key) throw (CException);
+
+         public : // Mutateur
+
+            void setAttribute(const std::string & key, CAttribute * const _attribute) throw (CException);
+
+            void setAttributes(const std::map <std::string, std::string> & _attributes);
+            void setAttributes(const CAttributeMap * const _parent);
+
+            void clearAllAttributes(void);
+
+         public : // Destructeur
+
+            virtual ~CAttributeMap(void);
+
+         public : // Flux
+
+            // Debug only //
+            // friend StdOStream & operator << (StdOStream & os, const CAttributeMap & attributmap);
+
+         public : // Autres
+
+            virtual std::string toString(void) const;
+            virtual void fromString(const  std::string & _str) throw (CException);
+            
+            virtual void toBinary  (std::ostream & _os) const;
+            virtual void fromBinary(std::istream & _is) throw (CException);
+
+         protected : // Constructeurs
+
+            CAttributeMap(void);
+            CAttributeMap(const xios_map<std::string, CAttribute*> & _umap);       // Never implemented.
+            CAttributeMap(const xios_map<std::string, CAttribute*> * const _umap); // Not implemented.
+
+         protected : //  PropriÃ©tÃ© statique
+
+            static CAttributeMap * Current;
+
+      };  // class CAttributeMap
+   } // namespace tree
+} // namespace xmlioserver
+
+#endif	// __ATTRIBUTE_MAP_HPP__
Index: XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_template.cpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_template.cpp	(revision 257)
+++ XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_template.cpp	(revision 257)
@@ -0,0 +1,248 @@
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, XMLIOServer, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
+
+/**
+ * \file    attribute_template.cpp
+ * \brief   Gestion des attributs typÃ©s d'objet (implÃ©mentation).
+ * \author  HervÃ© Ozdoba
+ * \version 0.4
+ * \date    1er Juin 2011
+ */
+
+#ifndef __XIOS_NO_EXTERN
+
+// C++ standard headers
+#include <string>
+#include <iostream>
+#include <cfloat>
+
+// boost headers
+#include <boost/cstdint.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/multi_array.hpp>
+#include <boost/lexical_cast.hpp>
+
+#endif // __XIOS_NO_EXTERN
+
+// XMLIOServer headers
+#include "attribute_template.hpp"
+#include "attribute_template_impl.hpp"
+#include "attribute_impl.hpp"
+
+// /////////////////////////////// DÃ©finitions ////////////////////////////// //
+
+namespace xmlioserver {
+namespace tree {
+
+   //--------------------------------------------------------------------------
+   //-------- SpÃ©cialisations des templates pour la fonction [toString] -------
+   //--------------------------------------------------------------------------
+   
+   template <>
+      std::string CAttributeTemplate<bool>::toString(void) const
+   {
+      std::ostringstream oss;
+      if (!this->isEmpty() && this->hasId())
+      {
+         if (this->getValue())
+            oss << this->getName() << "=\".TRUE.\"";
+         else
+            oss << this->getName() << "=\".FALSE.\"";
+      }
+      return (oss.str());
+   }
+
+   //--------------------------------------------------------------------------
+   //------ SpÃ©cialisations des templates pour la fonction [fromString] -------
+   //--------------------------------------------------------------------------
+
+   template <> // ChaÃ®ne de caractÃšres.
+      void CAttributeTemplate<std::string>::fromString(const std::string & _str)
+   { 
+      this->setValue(_str); 
+   }
+
+   template <> // Entier
+      void CAttributeTemplate<int>::fromString(const std::string & _str)
+   {
+      try
+      {
+         this->setValue(boost::lexical_cast<int>(_str));
+      }
+      catch(boost::bad_lexical_cast &)
+      {
+         XIOS_ERROR("void CAttributeTemplate<int>::fromString(const StdString & _str)",
+                     << "[ str = " << _str << " ] Bad cast !");
+      }
+   }
+
+   template <> // Double
+      void CAttributeTemplate<double>::fromString(const std::string & _str)
+   {
+      if (_str.find("max") != std::string::npos)
+      {
+         this->setValue(DBL_MAX);
+         return;
+      }
+      if (_str.find("min") != std::string::npos)
+      {
+         this->setValue(DBL_MIN);
+         return;
+      }
+      
+      try
+      {
+         this->setValue(boost::lexical_cast<double>(_str));
+      }
+      catch(boost::bad_lexical_cast &)
+      {
+         XIOS_ERROR("void CAttributeTemplate<double>::fromString(const StdString & str)",
+                    << "[ str = " << _str << " ] Bad cast !");
+      }
+   }
+
+   template <> // BoolÃ©en
+      void CAttributeTemplate<bool>::fromString(const std::string & _str)
+   {
+      if (_str.find(".TRUE.") != std::string::npos)
+         this->setValue(true);
+      else
+         this->setValue(false);
+   }
+
+   //--------------------------------------------------------------------------
+
+   template<> // Tableau
+      void CAttributeTemplate<boost::shared_ptr<boost::multi_array<double, 1> > >
+	 ::fromString(const std::string & _str)
+   { 
+      boost::shared_ptr<boost::multi_array<double, 1> > array_sptr 
+	  (new boost::multi_array<double, 1>(boost::extents[1], boost::fortran_storage_order()));
+      
+      boost::multi_array<double, 1> & array = *array_sptr;
+      this->setValue(array_sptr);
+
+      std::istringstream iss(_str) ;
+      char c = '\0'; int size = 0;
+      double d = 0.,valsup = 0., valinf = 0.;
+      std::vector<double> vect;
+
+      iss >> d; vect.push_back(d);
+      if (!iss.eof ())
+      {
+         iss >> c;
+         switch (c)
+         {
+            case ',' : // Le tableau est gÃ©nÃ©rÃ© valeur par valeur.
+               iss.unget();
+               while(!iss.eof ())
+               { // On rÃ©cupÃšre chacune des valeurs une par une jusqu'Ã  ce que le buffer soit vide.
+                  iss >> c >> d;
+                  if (c != ',')
+                     XIOS_ERROR("CAttributeTemplate<ARRAY(...)>::fromString(const StdString & str)",
+                                << "[ str = " << _str << " ] bad definition of array !");
+                  vect.push_back(d);
+               }
+               size = vect.size();
+               break;
+            case '(' : // Le tableau est gÃ©nÃ©rÃ© automatiquement.
+               if (!iss.eof ())
+               { // on rÃ©cupÃšre la borne supÃ©rieure
+                  valinf = d;
+                  iss >> size >> c >> d;
+                  if ((c != ')') || (size <= 0))
+                     XIOS_ERROR("CAttributeTemplate<ARRAY(...)>::fromString(const StdString & str)",
+                                << "[ str = " << _str << " ] bad definition of array !");
+                  valsup = d;
+               }
+               d = (valsup - valinf) / (double)(size - 1);
+               for (int j = 1; j <= size; j++)
+                  vect.push_back(valinf + j * d);
+               break;
+            default :
+               XIOS_ERROR("CAttributeTemplate<ARRAY(...)>::fromString(const StdString & str)",
+                           << "[ str = " << _str << " ] bad definition of array !");
+         }
+      }
+
+      array.resize(boost::extents[size]);
+      for (int i = 0; i < size; i++)
+         array[i] = vect[i];
+
+   }
+
+   //--------------------------------------------------------------------------
+   //-------- SpÃ©cialisations des templates pour la fonction [toBinary] -------
+   //--------------------------------------------------------------------------
+
+   template <> // ChaÃ®ne de caractÃšres.
+      void CAttributeTemplate<std::string>::toBinary (std::ostream & _os) const
+   {
+      std::string str = this->getValue();
+      std::size_t size = str.size();
+      _os.write (reinterpret_cast<const char*>(&size) , sizeof(std::size_t));
+      _os.write (str.data(), size * sizeof(char));
+   }
+
+   template <> // Entier
+      void CAttributeTemplate<int>::toBinary(std::ostream & _os) const
+   {
+      int value = this->getValue();
+      _os.write (reinterpret_cast<const char*>(&value) , sizeof(int));
+   }
+
+   template <> // BoolÃ©en
+      void CAttributeTemplate<bool>::toBinary(std::ostream & _os) const
+   {
+      bool value = this->getValue();
+      _os.write (reinterpret_cast<const char*>(&value) , sizeof(bool));
+   }
+
+   template <> // Double
+      void CAttributeTemplate<double>::toBinary(std::ostream & _os) const
+   {
+      double value = this->getValue();
+      _os.write (reinterpret_cast<const char*>(&value) , sizeof(double));
+   }
+
+   //--------------------------------------------------------------------------
+   //------ SpÃ©cialisations des templates pour la fonction [fromBinary] -------
+   //--------------------------------------------------------------------------
+
+   template <> // ChaÃ®ne de caractÃšres.
+      void CAttributeTemplate<std::string>::fromBinary(std::istream & _is)
+   {
+      std::size_t size = 0;
+      _is.read (reinterpret_cast<char*>(&size), sizeof(std::size_t));
+      std::string value(size, ' ');
+      _is.read (const_cast<char *>(value.data()), size * sizeof(char));
+      this->setValue(value);
+   }
+
+   template <> // Entier
+      void CAttributeTemplate<int>::fromBinary(std::istream & _is)
+   {
+      int value = 0;
+      _is.read (reinterpret_cast<char*>(&value), sizeof(int));
+      this->setValue(value);
+   }
+
+   template <> // BoolÃ©en
+      void CAttributeTemplate<bool>::fromBinary(std::istream & _is)
+   {
+      bool value = false;
+      _is.read (reinterpret_cast<char*>(&value), sizeof(bool));
+      this->setValue(value);
+   }
+
+   template <> // Double
+      void CAttributeTemplate<double>::fromBinary(std::istream & _is)
+   {
+      double value = 0.;
+      _is.read (reinterpret_cast<char*>(&value), sizeof(double));
+      this->setValue(value);
+   }
+  
+} // namespace tree
+} // namespace xmlioserver
Index: XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_template.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_template.hpp	(revision 257)
+++ XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_template.hpp	(revision 257)
@@ -0,0 +1,84 @@
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, XMLIOServer, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
+
+#ifndef __ATTRIBUTE_TEMPLATE_HPP__
+#define	__ATTRIBUTE_TEMPLATE_HPP__
+
+/**
+ * \file    attribute_template.hpp
+ * \brief   Gestion des attributs typÃ©s d'objet (entÃªte).
+ * \author  HervÃ© Ozdoba
+ * \version 0.4
+ * \date    1er Juin 2011
+ */
+
+#ifndef __XIOS_NO_EXTERN
+
+// C++ standard headers
+#include <string>
+#include <iostream>
+
+#endif // __XIOS_NO_EXTERN
+
+// XMLIOServer headers
+#include "xmlioserver_spl.hpp"
+#include "attribute.hpp"
+
+// ////////////////////////////// DÃ©clarations ///////////////////////////// //
+
+namespace xmlioserver {
+   namespace tree {
+  
+      template <class ValueType>
+         class CAttributeTemplate : public CAttribute
+      {
+            typedef CAttribute SuperClass;
+
+         public : // Constructeurs
+
+            explicit CAttributeTemplate(const std::string & _id);
+            CAttributeTemplate(const std::string & _id,
+                               xios_map<std::string, CAttribute*> & _umap);
+            CAttributeTemplate(const std::string & _id, const ValueType & _value);
+            CAttributeTemplate(const std::string & _id, const ValueType & _value,
+                               xios_map<std::string, CAttribute*> & _umap);
+            CAttributeTemplate(const CAttribute & _attribut_ref) throw (CException);
+            CAttributeTemplate(const CAttribute * const _attribut_ptr); // Not implemented.
+
+          public : // Accesseur
+
+            inline ValueType getValue(void) const  throw (CException);
+
+          public : // Mutateur
+
+            inline void setValue(const ValueType & _value);
+
+          public : // Destructeur
+
+            virtual ~CAttributeTemplate(void);
+
+          public : // Operateur
+
+            ValueType operator=(const ValueType & _value);
+
+          public : // Autres
+
+            virtual std::string toString(void) const;
+            virtual void fromString(const std::string & _str);
+
+            virtual void toBinary  (std::ostream & _os) const;
+            virtual void fromBinary(std::istream & _is);            
+
+         protected : // Constructeurs
+
+            CAttributeTemplate(void); // Not implemented.
+
+      }; // class CAttribute  
+      
+      template <class T>  void FromBinary(std::istream & _is, T & _object);
+     
+   } // namespace tree
+} // namespace xmlioserver
+
+#endif	// __ATTRIBUTE_TEMPLATE_HPP__
Index: XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_template_impl.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_template_impl.hpp	(revision 257)
+++ XMLIO_V2/dev/dev_rv/src4/xmlio/attribute/attribute_template_impl.hpp	(revision 257)
@@ -0,0 +1,133 @@
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, XMLIOServer, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
+
+#ifndef __ATTRIBUTE_TEMPLATE_IMPL_HPP__
+#define	__ATTRIBUTE_TEMPLATE_IMPL_HPP__
+
+/**
+ * \file    attribute_template_impl.hpp
+ * \brief   Gestion des attributs typÃ©s d'objet (implÃ©mentation template).
+ * \author  HervÃ© Ozdoba
+ * \version 0.4
+ * \date    1er Juin 2011
+ */
+
+// /////////////////////////////// DÃ©finitions ////////////////////////////// //
+
+namespace xmlioserver {
+namespace tree {
+  
+   // ------------------------------ Constructeurs -----------------------------
+   
+   template <class ValueType>
+      CAttributeTemplate<ValueType>::CAttributeTemplate(const std::string & _id)
+         : CAttribute(_id)
+   { /* Ne rien faire de plus */ }
+
+   template <class ValueType>
+      CAttributeTemplate<ValueType>::CAttributeTemplate(const std::string & _id, const ValueType & _value)
+	 : CAttribute(_id)
+   {
+      this->setValue(_value);
+   }
+
+   template <class ValueType>
+      CAttributeTemplate<ValueType>::CAttributeTemplate(const CAttribute & _attribute_ref) throw (CException)
+         : CAttribute(_attribute_ref)
+   {
+      if (!_attribute_ref.isEmpty() && !_attribute_ref.isType<ValueType>())
+         XIOS_ERROR("CAttributeTemplate(_attribute_ref)", << "Invalid instantiation !");
+   }
+
+   template <class ValueType>
+      CAttributeTemplate<ValueType>::CAttributeTemplate
+	(const std::string & _id, xios_map<std::string, CAttribute*> & _umap)
+           : CAttribute(_id)
+   {
+      _umap.insert(_umap.end(), std::make_pair(_id, this));
+   }
+
+   template <class ValueType>
+      CAttributeTemplate<ValueType>::CAttributeTemplate
+         (const std::string & _id, const ValueType & _value, xios_map<std::string, CAttribute*> & _umap)
+            : CAttribute(_id)
+   {
+      this->setValue(_value);
+      _umap.insert(_umap.end(), std::make_pair(_id, this));
+   }
+   
+   // ------------------------------- Destructeur ------------------------------
+   
+   template <class ValueType>
+      CAttributeTemplate<ValueType>::~CAttributeTemplate(void)
+   { 
+      this->clear();
+   }
+  
+   // ------------------------------- Accesseur --------------------------------
+
+   template <class ValueType>
+      ValueType CAttributeTemplate<ValueType>::getValue(void) const  throw (CException)
+   {
+      if (SuperClass::isEmpty())
+         XIOS_ERROR("ValueType CAttributeTemplate<ValueType>::getValue(void) const",
+                     << "[ id = " << this->getId() << "]"
+                     << " L'attribut est requis mais n'est pas dÃ©fini !");
+      return (SuperClass::getValue<ValueType>());
+   }
+      
+   // ------------------------------- Mutateur ---------------------------------
+   
+   template <class ValueType>
+      void CAttributeTemplate<ValueType>::setValue(const ValueType & _value)
+   {
+      SuperClass::setValue<ValueType>(_value);
+   }
+
+   // ------------------------------- OpÃ©rateur --------------------------------
+
+   template <class ValueType>
+      ValueType CAttributeTemplate<ValueType>::operator=(const ValueType & _value)
+   {
+      this->setValue(_value);  return (this->getValue());
+   }
+
+   // -------------------------- Conversion en chaÃ®ne --------------------------
+
+   template <class ValueType>
+      std::string CAttributeTemplate<ValueType>::toString(void) const
+   {
+      std::ostringstream oss;
+      if (!this->isEmpty() && this->hasId())
+         oss << this->getName() << "=\"" << this->getValue() << "\"";
+      return (oss.str());
+   }
+
+   template <class ValueType>
+      void CAttributeTemplate<ValueType>::fromString(const std::string & _str)
+   {
+      XIOS_ERROR("CAttributeTemplate<ValueType>::fromString(const std::string & str)",
+                  << "[ str = " << _str << " ] Not implemented yet !");
+   }
+
+   // -------------------------- Conversion binaire ----------------------------
+
+   template <class ValueType>
+     void CAttributeTemplate<ValueType>::toBinary (std::ostream & _os) const
+   {
+      this->getValue()->toBinary(_os);
+   }
+
+   template <class ValueType>
+      void CAttributeTemplate<ValueType>::fromBinary(std::istream & _is)
+   {
+      ValueType value;
+      FromBinary(_is, value);
+      this->setValue(value);
+   }  
+      
+} // namespace tree
+} // namespace xmlioserver
+
+#endif	// __ATTRIBUTE_TEMPLATE_IMPL_HPP__
Index: XMLIO_V2/dev/dev_rv/src4/xmlio/xmlioserver_spl.hpp
===================================================================
--- XMLIO_V2/dev/dev_rv/src4/xmlio/xmlioserver_spl.hpp	(revision 256)
+++ XMLIO_V2/dev/dev_rv/src4/xmlio/xmlioserver_spl.hpp	(revision 257)
@@ -22,3 +22,7 @@
 #define XIOS_UNUSED(param)
 
+//! DÃ©finit le type des map.
+#include <map>
+#define xios_map std::map
+
 #endif //__XMLIO_SPL__
