source: XMLIO_V2/dev/dev_rv/src/XMLIO/container.hpp @ 131

#ifndef __XMLIO_CONTAINER__
#define __XMLIO_CONTAINER__

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

namespace XMLIOSERVER
{
   template<class Key, class Mapped, class HashFunc = Poco::Hash<Key> >
      class ExHashMap
         : private Poco::HashMap<Key, Mapped*, Poco::Hash<Key> >
   {
      public :

         Mapped* operator[] (const Key& kval)
                     throw (XMLIOUndefinedValueException)
         {
            if(!hasMappedValue(kval))
               throw XMLIOSERVER::XMLIOUndefinedValueException
                  ("Appel de la méthode ExHashMap::operator["+kval+"] invalide.");
            return (find(kval)->second);
         }

         bool hasMappedValue(const Key& kval) const
         { return (find(kval) != this->end()); }

         const vector<Mapped*>& getVector(void) const
         { return (this->_elemList); }

         size_t getVectorSize(void) const
         { return (this->_elemList.size()); }

         size_t getSize(void) const
         { return (this->size()); }

      public : /* virtual */

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

      protected :

         ExHashMap(void)
            :  Poco::HashMap<Key, Mapped*, Poco::Hash<Key> >(), _elemList()
         {/* Ne rien faire de plus */}

         bool addValue(const Key& kval, Mapped* const element)
         {
            std::pair<typename ExHashMap::Iterator, bool> p = this->insert(make_pair (kval,element));
            if(!p.second) return (false);
            return (this->addValue(element));
         }

         bool addValue(Mapped* const element)
         {
            this->_elemList.insert(this->_elemList.end(), element);
            return (true);
         }

         void removeValue(const Key& kval) // Non testé
         {
            Mapped* element = find(kval)->second;
            this->removeValue(element);
            this->erase(kval);
         }

         void removeValue(const Mapped* element) // Non testé
         {
            for (int i = 0; i < this->_elemList.size(); i++)
               if (*this->_elemList[i] == element )
                  this->_elemList.erase(this->_elemList.begin()+i);

            delete element;
         }

      private :

         std::vector<Mapped*> _elemList;

   }; // class ExHashMap

   /////////////////////////////////////////////////////////////

   template<class Mapped>
      class StrHashMap
         : public ExHashMap<string, Mapped, Poco::Hash<string> >
   {
      public :

         StrHashMap(void)
            :  ExHashMap<string, Mapped, Poco::Hash<string> >()
         {/* Ne rien faire de plus */}

         bool addObject(Mapped* element)
         {
            if(element->hasId())
               return(addValue(element->getId(), element));
            return(addValue(element));
         }

         bool removeObject(const string& kval)
         {
            if(!ExHashMap<string, Mapped, Poco::Hash<string> >::hasMappedValue(kval)) return (false);
            ExHashMap<string, Mapped, Poco::Hash<string> >::removeValue(kval); return (true);
         }

      public : /* virtual */

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

   }; // class StrHashMap

} // namespace XMLIOSERVER

#endif // __XMLIO_CONTAINER__