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

#ifndef __XMLIO_GROUP_TEMPLATE__
#define __XMLIO_GROUP_TEMPLATE__

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

         GroupTemplate(void) : ObjectTemplate<GroupTemplate<T, U> >(),  U(), childList(), groupList()
         {/* Ne rien faire de plus */}
         GroupTemplate(const string& _id) : ObjectTemplate<GroupTemplate<T, U> >(_id), U(), childList(), groupList()
         {/* Ne rien faire de plus */}

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

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

         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 resolveDescInheritance(const AttributRegistrar* _parent = 0)
         {
            const vector<T*>&  childvect = childList.getVector();
            const vector<GroupTemplate<T, U>*>& groupvect = groupList.getVector();

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

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

         GroupTemplate<T, U>& createGroup(const string& _id) throw (XMLIOUndefinedValueException)
         {
            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) throw (XMLIOUndefinedValueException) { return (*groupList[_id]); }
         bool hasGroup(const string _id) { 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) throw (XMLIOUndefinedValueException)
         {
            T& obj = ObjectTemplate<T>::CreateObject(_id);
            childList.addObject(&obj);
            return (obj);
         }

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

         T& getChild(const string& _id) throw (XMLIOUndefinedValueException) { return (*childList[_id]); }
         bool hasChild(const string& _id) { return (childList.hasMappedValue(_id)); }

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

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

         void getAllChildren(std::vector<T*>& _allc )
         {
            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);
         }

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

      protected:


         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__