InfoManager.hh

Go to the documentation of this file.

#ifndef __DIADES__UTILS__INFOMANAGER__HH__
#define __DIADES__UTILS__INFOMANAGER__HH__

#include<string>
#include<limits>
#include<unordered_map>
#include<vector>
#include<diades/utils/Assertion.hh>
#include<diades/utils/Exceptions.hh>
#include<diades/utils/Iterator.hh>
#include<diades/utils/NullValue.hh>


namespace Diades
{
   namespace Utils
   {

      template<typename _Info,
      typename _InfoId,
      typename _NullInfo = NullValue<_Info>,
      typename _NullInfoId = NullValue<_InfoId>,
      typename _Hash = std::hash<_Info> >
      class InfoManager
      {
      public:
         using Info = _Info;

         using InfoId = _InfoId;

         using NullInfo = _NullInfo;




         using NullInfoId = _NullInfoId;


         const Info nullInfo = NullInfo().nullValue();

         const InfoId nullInfoId = NullInfoId().nullValue();


         using Hash = _Hash;

         static string
         typeName()
         {
            return "Diades::Utils::InfoManager";
         }

         using Exception = Diades::Utils::Exception<InfoManager>;




      protected:
         using Map = std::unordered_map<size_t, std::vector<InfoId> >;


         using InfoIdIterator = typename std::vector<InfoId>::const_iterator;

         Map _infoMap;
         std::vector<Info> _infos;

         std::vector<InfoId> _infoIds;

         template<typename _Iterator>
         class GetInfo
         {
         public:
            using Data = Info;
            using Iterator = _Iterator;
            using MapStructure = InfoManager;

            const Data & operator()(const MapStructure & m, Iterator it) const
            {
               return m.getInfo(*it);
            }
         };

      public:

         template<typename InfoIdIterator>
         using InfoIdRangeInfoIterator = Diades::Utils::RangeMapperIterator<GetInfo<InfoIdIterator>>;


      public:


         InfoManager() = default;


         InfoManager(InfoManager const& other) = default;

         InfoManager& operator=(InfoManager const& other)
         {
            if(this != &other)
            {
               _infoMap = other._infoMap;
               _infos = other._infos;
               _infoIds = other._infoIds;
            }
            return *this;
         }


         InfoManager(InfoManager&& other):
            _infoMap(std::move(other._infoMap)),
            _infos(std::move(other._infos)),
            _infoIds(std::move(other._infoIds)){}
         
         InfoManager& operator=(InfoManager&& other) 
         {
             if(this != &other)
            {
               _infoMap = std::move(other._infoMap);
               _infos = std::move(other._infos);
               _infoIds = std::move(other._infoIds);
            }
            return *this;
         }

         virtual ~InfoManager() = default;

         bool
         hasInfo(const Info & info) const
         {
            if(!(info == nullInfo))
            {
               auto it = _infoMap.find(Hash()(info));
               if(it != _infoMap.end())
               {
                  return(std::find_if(it->second.begin(),
                                      it->second.end(),
                                      [&info, this](size_t index)
                                      {
                                         return info == _infos[index]; }))
                  != it->second.end();
               }
               else
               {
                  return false;
               }
            }
            return true;
         }

         bool
         hasInfoId(InfoId id) const
         {
            return _infos.size() > id && id != nullInfoId;
         }

         bool
         setInfo(const Info & info, InfoId id)
         {
            if(id == nullInfoId)
            {
               return false;
            }
            if(info == nullInfo)
            {
               return false;
            }
            if(hasInfo(info))
            {
               return infoId(info) == id;
            }
            if(id >= _infos.size())
            {
               _infos.resize(id + 1, nullInfo);
               _infoIds.resize(id + 1, nullInfoId);
            }
            _infos[id] = info;
            _infoIds[id] = id;
            _infoMap[Hash()(info)].push_back(id);
            
            return true;
         }

         InfoId
         infoId(const Info & info)
         {
            if(info == nullInfo)
            {
               return nullInfoId;
            }
            size_t hashInfo = Hash()(info);
            auto it = _infoMap.find(hashInfo);
            if(it != _infoMap.end())
            {
               auto it2 = std::find_if(it->second.begin(),
                                       it->second.end(),
                                       [&info, this](size_t index)
                                       {
                                          return info == _infos[index]; });

               if(it2 != it->second.end())
               {
                  return *it2;
               }
               _infos.push_back(info);
               _infoIds.push_back(_infos.size() - 1);
               it->second.push_back(_infos.size() - 1);
               return it->second.back();
            }
            _infos.push_back(info);
            _infoIds.push_back(_infos.size() - 1);
            _infoMap[hashInfo].push_back(_infos.size() - 1);
            return _infos.size() - 1;
         }

         const Info &
         getInfo(InfoId id) const
         {
            if(id == nullInfoId)
            {
               return nullInfo;
            }
            if(id >= _infos.size())
            {
               return nullInfo;
            }
            return _infos[id];
         }

         InfoManager &
         initialise(unsigned capacity)
         {
            require(Exception, capacity > 0,
                    Msg("initialise: capacity %1% is null, try capacity = 1 at least")
                    % capacity);

            clear();
            _infos.reserve(capacity);
            _infoIds.reserve(capacity);
            return *this;
         }

         const std::vector<Info> &
         storage() const
         {
            return _infos;
         }

         InfoIdIterator
         begin() const
         {
            return _infoIds.begin();
         }

         InfoIdIterator
         end() const
         {
            return _infoIds.end();
         }

         template<typename InfoIdIterator>
         InfoIdRangeInfoIterator<InfoIdIterator>
         infoIdRangeInfoIterator(InfoIdIterator iterator) const
         {
            return InfoIdRangeInfoIterator<InfoIdIterator>(*this, iterator);
         }



      private:

         void
         clear()
         {
            _infoMap.clear();
            _infos.clear();
         }

      public:

         size_t
         numberOfInfos() const
         {
            return _infos.size();
         }

         bool
         isConsistentWith(const InfoManager & manager) const
         {
            if(numberOfInfos() > manager.numberOfInfos())
            {
               return false;
            }
            bool result = true;
            size_t index = 1;
            while(index < numberOfInfos())
            {
               result = (_infos[index] == manager._infos[index]);
               ++index;
            }
            return result;
         }

         bool
         isEquivalentTo(const InfoManager & manager) const
         {
            return isConsistentWith(manager) && manager.isConsistentWith(*this);
         }

         InfoManager &
         appendWith(const InfoManager & manager)
         {
            if(this != &manager)
            {
               for(InfoId id = 0; id < manager.numberOfInfos(); ++id)
               {
                  infoId(manager.getInfo(id));
               }
            }
            return *this;
         }

         InfoManager &
         makeIntersection(const InfoManager & m1,
                          const InfoManager & m2)
         {
            if(&m1 == &m2)
            {
               if(this != &m1)
               {
                  *this = m1;
               }
               return *this;
            }

            if(this == &m1)
            {
               InfoManager tmp(*this);
               makeIntersection(tmp, m2);
            }
            else
            {
               if(this == &m2)
               {
                  InfoManager tmp(*this);
                  makeIntersection(m1, tmp);
               }
               else
               {
                  if(m1.numberOfInfos() == 0)
                  {
                     clear();
                  }
                  else
                  {
                     initialise(m1.numberOfInfos());
                     for(size_t i = 0; i < m1.numberOfInfos(); ++i)
                     {
                        if(m2.hasInfo(m1.getInfo(i)))
                        {
                           infoId(m1.getInfo(i));
                        }
                     }
                  }
               }
            }
            return *this;
         }

         InfoManager &
         makeUnion(const InfoManager & m1,
                   const InfoManager & m2)
         {
            if(&m1 == &m2)
            {
               if(this != &m1)
               {
                  *this = m1;
               }
               return *this;
            }
            if(this == &m1)
            {
               for(size_t i = 0; i < m2.numberOfInfos(); ++i)
               {
                  if(!hasInfo(m2.getInfo(i)))
                  {
                     infoId(m2.getInfo(i));
                  }
               }
            }
            else
            {
               if(this == &m2)
               {

                  for(size_t i = 0; i < m1.numberOfInfos(); ++i)
                  {
                     if(!hasInfo(m1.getInfo(i)))
                     {
                        infoId(m1.getInfo(i));
                     }
                  }



               }
               else
               {
                  *this = m1;
                  appendWith(m2);
               }

            }
            return *this;
         }


         
         bool isNull(const Info & info) const
         {
            return info == nullInfo;
         }
         
         bool isNullId(const InfoId & infoId) const
         {
            return infoId == nullInfoId;
         }
      };


   }
}


#endif /* __DIADES__UTILS__INFOMANAGER__HH__ */