source: XMLIO_V2/dev/dev_rv/src/XMLIO/object_template.hpp @ 125

#ifndef __XMLIO_OBJECT_TEMPLATE__
#define __XMLIO_OBJECT_TEMPLATE__

#include "declare_attribut.hpp"
#include "attribut_registrar.hpp"

// Classes utilisées issues de la STL
using std::pair;
using std::string;
using std::ostream;

using XMLIOSERVER::StrHashMap;

using XMLIOSERVER::XML::XMLNode;
using XMLIOSERVER::XML::THashAttributes;

namespace XMLIOSERVER
{
   template <class T>
      class ObjectTemplate : public AbstractObject, public virtual AttributRegistrar
   {
      public :

         friend ostream& operator<< (ostream& out, const T& c)
         {
            const AttributRegistrar &ar = c;

            if (c.baseObject != NULL)
               out <<  IncIndent << "<-- Reference resolved for the following "+ T::GetName() +
                       " : \"" << c.baseObject->getId() << "\" -->" << DecEndl << std::endl;

            if (c.hasChild())
            {
               out << IncIndent  << "<" << c.getName()   << c.printId() << ar << ">" << std::endl;
               c.printChild(out); // << Ecriture des objets enfants ici.
               out << NIndent    << "</" << c.getName()  << ">" << DecEndl;
            }
            else out << IncIndent << "<" << c.getName()  << c.printId() << ar << "/>" << DecEndl;

            return (out);
         }

         string getName(void) const
         {
            if (hasId())
               if (T::GetDefName().compare(getId()) == 0)
                  return T::GetDefName();
            return (T::GetName());
         }

         T* getBaseObject(void) const { return (baseObject); }

         virtual T* getReference(void) const { return (NULL); }

         const vector<T*>& getVectRefObject(void) const { return (refObject); }

         bool hasRefObject(void) { return (!refObject.empty()); }

         const T* addRefObject(T* obj)
         { refObject.push_back (obj); return (obj); }

         virtual bool hasChild(void) const { return (false); }
         virtual void printChild(ostream& out) const { out << NIndent << "<!-- No child -->" << std::endl; }

         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0) { addAttributes(*_parent); }
         virtual void resolveRefInheritance (void)
         {
            std::set<T*> sset;
            T* refer = (T*)this;
            // On remonte le fil des héritages par référence.
            while((refer = refer->getReference()) != NULL)
            {
               if(sset.end() != sset.find(refer))
               { WARNING ("Dépendance circulaire stoppée pour l'objet de type "+T::GetName()+" sur \""+refer->getId()+"\" !"); break; }
               addAttributes(*refer);
               sset.insert(baseObject = refer);
            }
         }

         virtual void parse (XMLNode& _node)
         {
            string name = _node.getElementName();
            THashAttributes attributes;

            /// PARSING GESTION DES ATTRIBUTS ///
            _node.getAttributes(attributes);
            this->setAttributes(attributes);
            attributes.clear();

            /// PARSING POUR GESION DES ENFANTS ///
            // Rien à faire.
         }

      public : /* static */

         static T* CreateObject(const string& _id) throw (XMLIOUndefinedValueException)
         {
            // Si l'identifiant est répertorié, on retourne l'élément existant.
            if(ObjectTemplate<T>::HasObject(_id))
               return (ObjectTemplate<T>::GetObject(_id));

            // Ajout d'un nouvel objet si l'identifiant n'est pas répertorié.
            ObjectTemplate<T>::AllListObj[CurrContext].addObject(new T(_id));

            return (ObjectTemplate<T>::GetObject(_id));
         }

         static T* CreateObject(void)
         {
            T* value = new T;
            ObjectTemplate<T>::AllListObj[CurrContext].addObject(value);
            return (value);
         }

         static T* GetObject(const string& _id) throw (XMLIOUndefinedValueException)
         { return (ObjectTemplate<T>::AllListObj[CurrContext][_id]); }

         static bool HasObject(const string& _id)
         {
            if(ObjectTemplate<T>::AllListObj.find(CurrContext) == ObjectTemplate<T>::AllListObj.end()) return false;
            return (ObjectTemplate<T>::AllListObj[CurrContext].hasMappedValue(_id));
         }

         static const StrHashMap<T>& GetCurrentListObject(void) { return (AllListObj[CurrContext]); }
         static Poco::HashMap<string, StrHashMap<T> >& GetAllListObject(void) { return (AllListObj); }

         static void SetContext(const string& id){ ObjectTemplate<T>::CurrContext = id; }

         static string& GetCurrentContextId(void) { return (CurrContext); }

         virtual ~ObjectTemplate(void)
         {/* Ne rien faire de plus */}

      protected :

         ObjectTemplate(void) : AbstractObject(), baseObject(NULL), refObject()
         {/* Ne rien faire de plus */}
         ObjectTemplate(const string& _id) : AbstractObject(_id), baseObject(NULL), refObject()
         {/* Ne rien faire de plus */}

         XML::XMLNode getNodeIncludedFile(const string& path, const string& _rootName)
         {
            ifstream istr( path.c_str() , ifstream::in );
            return XML::XMLNode::CreateNode(istr, _rootName);
         }

         template <class V> static V* CreateInstanceAndParse(XMLNode& _node, const char* defaultId, bool parseAttr = true )
         {
            V* instance_ptr = NULL; string did(defaultId);
            if (defaultId != NULL)
            {
               if (V::HasObject(did))
                  WARNING("Le noeud nommé \""+ did +"\" existe déjà pour les instances de type "+V::GetName()+", le dernier défini complétera le premier dans le context actuel!");
               instance_ptr = (V*)V::CreateObject(did);
               instance_ptr->parse(_node, parseAttr);
            }
            return (instance_ptr);
         }

      private :
         T* baseObject;
         vector<T*> refObject;

         static string CurrContext;
         static Poco::HashMap<string, StrHashMap<T> > AllListObj;

   };// class ObjectTemplate

   template <class T> string ObjectTemplate<T>::CurrContext ;
   template <class T> Poco::HashMap<string, StrHashMap<T> > ObjectTemplate<T>::AllListObj;

}// namespace XMLIOSERVER

#endif // __XMLIO_OBJECT_TEMPLATE__