EdgeMap.hh

Go to the documentation of this file.

#ifndef __DIADES__GRAPH__EDGEMAP_HH
#define __DIADES__GRAPH__EDGEMAP_HH

#include <memory>
#include <vector>
//#include <boost/archive/text_oarchive.hpp>
//#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <diades/graph/Graph.hh>



namespace Diades
{
  namespace Graph
  {
        using  std::vector;

        template <typename T> struct EdgeMapIterator;
        
        template<class T >
        class EdgeMap {
        public:

            static string typeName() {
                return "Graph::EdgeMap";
            }
            typedef Diades::Utils::Exception<EdgeMap> Exception;
        public:

          typedef typename  vector<T>::reference              Reference;
          typedef typename  vector<T>::const_reference        ConstReference;
          typedef typename vector<T>::value_type             ValueType;
          typedef typename vector<T>::iterator               Iterator;
          typedef typename vector<T>::const_iterator         ConstIterator;
          typedef typename vector<T>::size_type              SizeType;
          typedef typename vector<T>::difference_type        DifferenceType;
          typedef typename vector<T>::allocator_type         AllocatorType;
          typedef typename vector<T>::pointer                Pointer;
          typedef typename vector<T>::const_pointer          ConstPointer;
          typedef typename vector<T>::reverse_iterator       ReverseIterator;
          typedef typename vector<T>::const_reverse_iterator ConstReverseIterator;
          
          
          

        public:

          EdgeMap();

          explicit EdgeMap(Graph & g, SizeType capacity=0,ValueType dflt=ValueType());

          ~EdgeMap()
          {
            clear();
          }



          void init(Graph & g, SizeType capacity=0, ValueType dflt=ValueType());


          void clear()
          {
            _tabData.clear();
          }


          const Graph & owner() const
          {
                return *_owner;
          }
          
          
          Graph & owner()
          {
                return *_owner;
          }
          Reference operator[](Edge edge);

          ConstReference operator[](Edge edge) const;

          bool valid() const {
                return _owner!=nullptr;
          }


          EdgeIterator initValue(EdgeIterator begin, EdgeIterator end, ConstReference value);
          LocalEdgeIterator initValue(LocalEdgeIterator begin, LocalEdgeIterator end, ConstReference value);
        
          EdgeMapIterator< ValueType > edgeBegin(ConstReference value) const;

        
          EdgeMapIterator< ValueType > egdeEnd(ConstReference value) const;
        


        private:
          mutable vector<ValueType> _tabData;
          mutable Graph * _owner;
          T _dflt;
        public:
//        template<class Archive>
//        void serialize(Archive & ar, const unsigned int version)
//        {
//              ar & _owner;
//              ar & _dflt;
//              ar & _tabData;
//        }
        };








        template <typename T>
        struct EdgeMapIterator
        {
          typedef EdgeMapIterator<T>   self;
          typedef EdgeMapIterator<T>   Self;
          typedef ptrdiff_t            difference_type;
          typedef ptrdiff_t            DifferenceType;
          typedef std::forward_iterator_tag    iterator_category;
          typedef std::forward_iterator_tag    IteratorCategory;
          typedef typename EdgeMap<T>::ValueType   value_type;
          typedef typename EdgeMap<T>::ValueType   ValueType;
          
          typedef typename EdgeMap<T>::Pointer  pointer;
          typedef typename EdgeMap<T>::Pointer  Pointer;
          typedef typename EdgeMap<T>::Reference  reference;
          typedef typename EdgeMap<T>::Reference  Reference;
          typedef typename EdgeMap<T>::ConstReference  ConstReference;
          
          const EdgeMap<ValueType> * _pMap;
          EdgeIterator _currentIterator;
          ValueType _value;

          EdgeMapIterator(): _pMap(0),_currentIterator(),_value(){}
        
          EdgeMapIterator(const EdgeMap<ValueType> & mapping,
                                          const EdgeIterator & currentIterator,
                                          ConstReference value);

          Reference operator*() const;
  
  
          Pointer operator->() const;
 

          Self & operator++();
 

          Self operator++(int);
 
        
  
          bool operator==(const Self & it) const;
  
 
          bool operator !=(const Self & it) const;

        };


        
        //--------------------------------------------------------------------------
        //   Implementation
        //--------------------------------------------------------------------------

        template <typename T >
        EdgeMap<T>::EdgeMap():_tabData(),_owner(nullptr),_dflt() { }


        template <typename T>
        EdgeMap<T>::EdgeMap(Graph & g, SizeType capacity, ValueType dflt):_tabData(),_owner(&g),_dflt(dflt)
        {
          if(capacity > (_owner->edgeCapacity()+1))
                {
                  _tabData.resize(capacity,_dflt);
                }
          else
                {
                  _tabData.resize(_owner->edgeCapacity()+1, _dflt);
                }
          ensure(Exception, valid() && _tabData.size() > _owner->edgeCapacity(),"EdgeMap"); 
        }


        template <typename T>
        void EdgeMap<T>::init(Graph & g, SizeType capacity, ValueType dflt){
          _owner=&g;
          _tabData.clear();
          _dflt =dflt;
          if(capacity > (_owner->edgeCapacity()+1))
                {
                  _tabData.resize(capacity,_dflt);
                }
          else
                {
                  _tabData.resize(_owner->edgeCapacity()+1,_dflt);
                }
          ensure(Exception, valid() && _tabData.size() > _owner->edgeCapacity(),"EdgeMap"); 
        }


        template <typename T>
        typename EdgeMap<T>::Reference EdgeMap<T>::operator[](Edge e)
        {
          require(Exception, valid(),"EdgeMap::operator[]: invalid _owner");
          require(Exception, e.valid(),"EdgeMap::operator[]: invalid edge");
          require(Exception, &e.owner()==_owner,"EdgeMap::operator[]: The edge's _owner is not the map's _owner");
          if( _owner->edgeCapacity() >=  _tabData.size())
                {
                  _tabData.resize(_owner->edgeCapacity()+1,_dflt);
                }
          ensure(Exception, valid() && _tabData.size() > _owner->edgeCapacity(),"EdgeMap[]"); 
          return _tabData.operator[](e.id());
        }

        template <typename T>
        typename EdgeMap<T>::ConstReference EdgeMap<T>::operator[](Edge e) const
        {
          require(Exception, valid(),"EdgeMap::operator[]: invalid _owner");
          require(Exception, e.valid(),"EdgeMap::operator[]: invalid edge");
          require(Exception, &e.owner()==_owner,"EdgeMap::operator[]: The edge's _owner is not the map's _owner");
          if( _owner->edgeCapacity() >=  _tabData.size() )
                {
                  _tabData.resize(_owner->edgeCapacity()+1,_dflt);
                }
          ensure(Exception, valid() && _tabData.size() > _owner->edgeCapacity(),"EdgeMap[]"); 
          return _tabData.operator[](e.id());
        }



        



        template <typename InputIterator, typename T>
        InputIterator initValue(EdgeMap<T> & map, InputIterator start, InputIterator end,
                                                        typename EdgeMap<T>::ConstReference value)
        {
          for(; start != end; ++start)
                {
                  map[*start] = value;
                }
          return end;
        }

        template <typename T>
        EdgeIterator EdgeMap<T>::initValue(EdgeIterator begin, EdgeIterator end,
                                                                           typename EdgeMap<T>::ConstReference value)
        {
          return initValue(*this,begin,end,value);
        }


        template <typename T>
        LocalEdgeIterator EdgeMap<T>::initValue(LocalEdgeIterator begin, LocalEdgeIterator end,
                                                                                        typename EdgeMap<T>::ConstReference value)
        {
          return initValue(*this,begin,end,value);
        }

        template<typename T>
        EdgeMapIterator<T>::EdgeMapIterator(const EdgeMap<ValueType> & mapping,
                                                                                const EdgeIterator & currentIterator,
                                                                                ConstReference value):_pMap(mapping),
                                                                                                                          _currentIterator(currentIterator),
                                                                                                                          _value(value)
        {
          while( (_currentIterator != _pMap->owner().nodeEnd())
                         &&
                         !(_pMap->operator[](*_currentIterator) == _value ) )
                {
                  ++_currentIterator;
                }                 
        }

  
        template<typename T>
        typename EdgeMapIterator<T>::Reference EdgeMapIterator<T>::operator*() const
        {
          return _pMap->operator[](*_currentIterator);
        }
  
        template<typename T>
        typename EdgeMapIterator<T>::Pointer EdgeMapIterator<T>::operator->() const
        {
          
          return  &(_pMap->operator[](*_currentIterator));
        }

        template<typename T>
        typename EdgeMapIterator<T>::Self & EdgeMapIterator<T>::operator++()
        {
          if(_currentIterator != _pMap->owner().edgeEnd())
                {
                  ++_currentIterator;
                }
          while( (_currentIterator != _pMap->owner().edgeEnd())
                         &&
                         !(_pMap->operator[](*_currentIterator) == _value ) )
                {
                  ++_currentIterator;
                }
          return *this;
        }

        template<typename T>
        typename EdgeMapIterator<T>::Self EdgeMapIterator<T>::operator++(int)
        {
          Self tmp = *this;
          if(_currentIterator != _pMap->owner().edgeEnd())
                {
                  ++_currentIterator;
                }
          while( (_currentIterator != _pMap->owner().edgeEnd())
                         &&
                         !(_pMap->operator[](*_currentIterator) == _value ) )
                {
                  ++_currentIterator;
                }
          return tmp;
        }

        
        template<typename T>
        bool EdgeMapIterator<T>::operator==(const Self & it) const
        {
          return (_pMap == it._pMap) && (_currentIterator == it._currentIterator);
        }
  
        template<typename T>
        bool  EdgeMapIterator<T>::operator !=(const Self & it) const
        {
          return !(*this == it);
        }

  };
};

#endif