ConstNodeMap.hh

Go to the documentation of this file.

#ifndef __DIADES__GRAPH__CONSTNODEMAP__HH
#define __DIADES__GRAPH__CONSTNODEMAP__HH

#include <memory>
#include <vector>
#include <diades/utils/Exceptions.hh>
#include <diades/graph/Graph.hh>


namespace Diades {
    namespace Graph {

        using std::vector;

        template <typename T> struct ConstNodeMapIterator;

        template < typename T >
        class ConstNodeMap {
        public:

            static string typeName() {
                return "Graph::ConstNodeMap";
            }
            typedef Diades::Utils::Exception<ConstNodeMap> 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:


            //********************** constructors *****************************

            ConstNodeMap();

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

            ~ConstNodeMap() {
                clear();
            }





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



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

            const Graph & owner() const {
                return *_owner;
            }

            
            ConstNodeMapIterator< ValueType > nodeBegin(ConstReference value) const;


            ConstNodeMapIterator< ValueType > nodeEnd(ConstReference value) const;

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

            Reference operator[](Node node);


            ConstReference operator[](Node node) const;


            NodeIterator initValue(NodeIterator begin, NodeIterator end, ConstReference value);


            void export2dot(ostream & os);



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

        template <typename T>
        struct ConstNodeMapIterator {
            typedef ConstNodeMapIterator<T> self;
            typedef ConstNodeMapIterator<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 ConstNodeMap<T>::ValueType value_type;
            typedef typename ConstNodeMap<T>::ValueType ValueType;

            typedef typename ConstNodeMap<T>::Pointer pointer;
            typedef typename ConstNodeMap<T>::Pointer Pointer;
            typedef typename ConstNodeMap<T>::Reference reference;
            typedef typename ConstNodeMap<T>::Reference Reference;
            typedef typename ConstNodeMap<T>::ConstReference ConstReference;

            const ConstNodeMap<ValueType> * _pMap;
            NodeIterator _currentIterator;
            ValueType _value;

            ConstNodeMapIterator() : _pMap(0), _currentIterator(), _value() {
            }

            ConstNodeMapIterator(const ConstNodeMap<ValueType> & mapping,
                    const NodeIterator & 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 >
        ConstNodeMap<T>::ConstNodeMap() : _tabData(), _owner(), _dflt() {
        }

        template <typename T>
        ConstNodeMap<T>::ConstNodeMap(const Graph & g, SizeType capacity, ValueType dflt) : _tabData(), _owner(&g), _dflt(dflt) {

            if (capacity > (_owner->nodeCapacity() + 1)) {
                _tabData.resize(capacity, _dflt);
            } else {
                _tabData.resize(_owner->nodeCapacity() + 1, dflt);
            }
            ensure(Exception, _tabData.size() > _owner->nodeCapacity(), "ConstNodeMap");
        }

        template <typename T>
        void ConstNodeMap<T>::init(const Graph & g, SizeType capacity, ValueType dflt) {

            _owner = &g;
            _tabData.clear();
            _dflt = dflt;
            if (capacity > (_owner->nodeCapacity() + 1)) {
                _tabData.resize(capacity, _dflt);
            } else {
                _tabData.resize(_owner->nodeCapacity() + 1, _dflt);
            }
            ensure(Exception, _tabData.size() > _owner->nodeCapacity(), "ConstNodeMap");
        }

        template <typename T>
        typename ConstNodeMap<T>::Reference ConstNodeMap<T>::operator[](Node n) {
            //require(Exception, _owner!=0,"ConstNodeMap::operator[]: invalid owner");
            require(Exception, n.valid(), "ConstNodeMap::operator[]: invalid node");
            //require(Exception, n.owner()==_owner,"ConstNodeMap::operator[]: The node's owner is not the map's owner");

            if (_owner->nodeCapacity() >= _tabData.size()) {
                _tabData.resize(_owner->nodeCapacity() + 1, _dflt);
            }
            ensure(Exception, _tabData.size() > _owner->nodeCapacity(), "ConstNodeMap[]");
            return _tabData.operator[](n.id());
        }

        template <typename T>
        typename ConstNodeMap<T>::ConstReference ConstNodeMap<T>::operator[](Node n) const {
            //require(Exception, _owner!=0,"ConstNodeMap::operator[]: invalid owner");
            require(Exception, n.valid(), "ConstNodeMap::operator[]: invalid node");
            //require(Exception, n.owner()==_owner,"ConstNodeMap::operator[]: The node's owner is not the map's owner");
            if (_owner->nodeCapacity() >= _tabData.size()) {
                _tabData.resize(_owner->nodeCapacity() + 1, _dflt);
            }
            ensure(Exception, _tabData.size() > _owner->nodeCapacity(), "ConstNodeMap[]");
            return _tabData.operator[](n.id());
        }

        template <typename T>
        NodeIterator ConstNodeMap<T>::initValue(NodeIterator begin, NodeIterator end, ConstReference value) {
            for (NodeIterator nodeIt = begin; nodeIt != end; ++nodeIt) {
                operator[](*nodeIt) = value;
            }
            ensure(Exception, _tabData.size() > _owner->nodeCapacity(), "ConstNodeMap[]");
            return end;
        }

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

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

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

        template<typename T>
        typename ConstNodeMapIterator<T>::Pointer ConstNodeMapIterator<T>::operator->() const {

            return &(_pMap->operator[](*_currentIterator));
        }

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

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

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

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

        

        template<typename T>
        void ConstNodeMap<T>::export2dot(ostream & os) {

            os << "digraph G {" << "\n";
            os << "\tratio=fill;" << "\n";
            os << "\tpage=\"8.5,11.6\";" << "\n";
            os << "\tsize=\"7.5,10.5\";" << "\n";

            // writing the states
            for (NodeIterator nodeIt = owner().nodeBegin();
                    nodeIt != owner().nodeEnd();
                    nodeIt++) {
                os << "\t" << *nodeIt;
                os << "[ label=\"" << operator[](*nodeIt) << "\"];";
                os << "\n";
            }

            // writing the transitions
            for (EdgeIterator edgeIt = owner().edgeBegin();
                    edgeIt != owner().edgeEnd();
                    ++edgeIt) {
                os << "\t" << edgeIt->source() << " -> " << edgeIt->target();
                os << "\n";
            }

            // writing the end of os
            os << "}" << "\n";
        }

        template< typename T >
        ConstNodeMapIterator< typename ConstNodeMap<T>::ValueType > ConstNodeMap<T>::nodeBegin(ConstNodeMap<T>::ConstReference value) const {
            return ConstNodeMapIterator< ConstNodeMap<T>::ValueType >(this, owner().nodeBegin(), value);
        }

        template< typename T >
        ConstNodeMapIterator< typename ConstNodeMap<T>::ValueType > ConstNodeMap<T>::nodeEnd(ConstNodeMap<T>::ConstReference value) const {
            return ConstNodeMapIterator< ConstNodeMap<T>::ValueType >(this, owner().nodeEnd(), value);
        }
    };
};

#endif