source: XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp @ 138

#ifndef __XMLIO_GROUP_TEMPLATE__
#define __XMLIO_GROUP_TEMPLATE__

namespace XMLIOSERVER
{
   template <class T, class U>
      class GroupTemplate : public ObjectTemplate<GroupTemplate<T, U> >, public virtual U
   {
      public:

         // Attribut présent uniqument dans les groupes.
         DECLARE_ATTR(group_ref, string) ;

         GroupTemplate(void)
            : ObjectTemplate<GroupTemplate<T, U> >()/*,  U()*/, childList(), groupList()
         { RegisterAttribut(&group_ref) ; }

         GroupTemplate(const string& _id)
            : ObjectTemplate<GroupTemplate<T, U> >(_id)/*, U()*/, childList(), groupList()
         { RegisterAttribut(&group_ref) ; }

         /// Pour les groupes d'objets enfants ///

         GroupTemplate<T, U>& createGroup(const string& _id)

         {
            GroupTemplate<T, U> &obj = *GroupTemplate<T, U>::CreateObject(_id);
            groupList.addObject(&obj);

            return (obj);
         }

         GroupTemplate<T, U>& createGroup(void)
         {
            GroupTemplate<T, U>& obj = *(GroupTemplate<T, U>::CreateObject());
            groupList.addObject(&obj);

            return (obj);
         }

         GroupTemplate<T, U>& getGroup(const string& _id) const

         { return (*groupList[_id]); }

         bool hasGroup(const string& _id) const
         { return (groupList.hasMappedValue(_id)); }

         const StrHashMap<GroupTemplate<T, U>* >& getGroupList(void) const { return (groupList); }

         size_t getNbGroup() const {return (groupList.getVectorSize()); }

         /// Pour les objets enfants ///

         T& createChild(const string& _id)

         {
            T& obj = *ObjectTemplate<T>::CreateObject(_id);
            childList.addObject(&obj);
            return (obj);
         }

         T& createChild(void)
         {
            T& obj = *ObjectTemplate<T>::CreateObject();
            childList.addObject(&obj);
            return (obj);
         }

         T& createChildRef(const T* const _ori)
         { return (*_ori); }

         T& getChild(const string& _id) const

         { return (*childList[_id]); }

         bool hasChild(const string& _id) const
         { return (childList.hasMappedValue(_id)); }

         const StrHashMap<T*> & getCurrentListChild  (void) const { return (childList); }
         const std::vector<T*>& getCurrentVectorChild(void) const { return (childList.getVector()); }

         size_t getNbChild() const {return (childList.getVectorSize()); }

         void getAllChildren(std::vector<T*>& _allc ) const
         {
            const vector<GroupTemplate<T, U>*>& groupvect = groupList.getVector();
            _allc.insert (_allc.end(), getCurrentVectorChild().begin(),
                                       getCurrentVectorChild().end());

            for(unsigned int i = 0; i < groupvect.size() ; i++)
               groupvect[i] -> getAllChildren(_allc);
         }

      public : /* static */

         static string GetName(void)    { return (T::GetName().append("_group")); }
         static string GetDefName(void) { return (T::GetName().append("_definition")); }

      public : /* virtual */

         virtual ~GroupTemplate(void)
         {
            for (unsigned int i = 0; i < childList.getVector().size(); i++)
               delete childList.getVector()[i];
            for (unsigned int i = 0; i < groupList.getVector().size(); i++)
               delete groupList.getVector()[i];
         }

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

         virtual bool hasChild(void) const { return ((getNbGroup() + getNbChild())>0); }
         virtual void printChild(ostream& out) const
         {
            // Ecriture des sous-groupes.
            for(unsigned int i = 0; i < groupList.getVector().size() ; i++)
               out << *(groupList.getVector()[i])  << std::endl;
            // Ecriture des enfants.
            for(unsigned int i = 0; i < childList.getVector().size() ; i++)
               out << *(childList.getVector()[i]) << std::endl;
         }

         virtual void solveDescInheritance(const AttributRegistrar* const _parent = 0)
         {
            const vector<T*>&  childvect = childList.getVector();
            const vector<GroupTemplate<T, U>*>& groupvect = groupList.getVector();

            // On complÚte les propres attributs du groupe avec ceux du parent.
            if (_parent != NULL) AttributRegistrar::addAttributes(*_parent);

            for(unsigned int i = 0; i < childvect.size() ; i++)
            // on complÚte les attributs des enfants.
               childvect[i] -> solveDescInheritance(this);

            for(unsigned int i = 0; i < groupvect.size() ; i++)
            { // on complÚte les attributs des groupes enfants.
               groupvect[i] -> solveRefInheritance ();
               groupvect[i] -> solveDescInheritance(this);
            }
         }

      protected:

         template <class W> void _parse (XMLNode& _node, bool _withAttr = true)
         {
            string name = _node.getElementName();
            THashAttributes attributes;

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

               if (attributes.end() != attributes.find("src"))
               { // Si une demande d'inclusion de fichier est trouvée.
                  XMLNode _node_inc = ObjectTemplate<GroupTemplate<T, U> >::getNodeIncludedFile(attributes["src"], name);
                  _parse<W> (_node_inc);
               }

               attributes.clear();
            }

            /// PARSING POUR GESTION DES ENFANTS ///
            if (!(_node.goToChildElement()))
               WARNING("L'objet de type \""+W::GetName()+"\" ne contient pas d'enfant !");
            else
            {
               do { // Parcours pour traitement.

                  string name = _node.getElementName();
                  attributes.clear(); _node.getAttributes(attributes);

                  if (name.compare(W::GetName()) == 0)
                  { createGroupAndParse<W>(attributes, _node); continue; }

                  if (name.compare(T::GetName()) == 0)
                  { createChildAndParse<T>(attributes, _node); continue; }

                  WARNING("Un objet de type \""+W::GetName()+"\" ne peut contenir qu'un object de type \""+T::GetName()+"\" ou \""+W::GetName()+"\" !");

               } while (_node.goToNextElement());
               _node.goToParentElement(); // Retour au parent
            }
         }

         template <class V> V* createGroupAndParse(THashAttributes& attributes, XMLNode& _node)
         {
            V* instance_ptr = NULL;
            if (attributes.end() != attributes.find("id"))
            {// Si l'identifiant est défini.
               if (V::HasObject(attributes["id"]))
                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommée \""+attributes["id"]
                          +"\" existe déjà , le second fera référence au premier par défaut !"); // TODO TODO
               instance_ptr = (V*)(&createGroup(attributes["id"]));
               instance_ptr->parse(_node);
            }
            else
            {// Si l'identifiant n'est pas défini.
               instance_ptr = (V*)(&createGroup());
               instance_ptr->parse(_node);
            }
            return (instance_ptr);
         }

         template <class V> V* createChildAndParse(THashAttributes& attributes, XMLNode& _node)
         {
            V* instance_ptr = NULL;
            if (attributes.end() != attributes.find("id"))
            {// Si l'identifiant est défini.
               if (V::HasObject(attributes["id"]))
                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommée \""+attributes["id"]
                          +"\" existe déjà , le second fera référence au premier par défaut !"); // TODO TODO
               instance_ptr = (V*)(&createChild(attributes["id"]));
               instance_ptr->parse(_node);
            }
            else
            {// Si l'identifiant n'est pas défini.
               instance_ptr = (V*)(&createChild());
               instance_ptr->parse(_node);
            }
            return (instance_ptr);
         }

      private :

         StrHashMap<T> childList;
         StrHashMap<GroupTemplate<T, U> > groupList;

   }; // class GroupTemplate

}// namespace XMLIOSERVER


#endif // __XMLIO_GROUP_TEMPLATE__