NodeMap.hh

Go to the documentation of this file.

#ifndef __DIADES__GRAPH__NODEMAP__HH
#define __DIADES__GRAPH__NODEMAP__HH

#include <memory>
#include <vector>
#include <diades/utils/Exceptions.hh>
//#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 NodeMapIterator;

        template < typename T >
        class NodeMap {
        public:

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

            NodeMap();

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

            ~NodeMap() {
                clear();
            }





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



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

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

            Graph & owner() {
                return *_owner;
            }

            NodeMapIterator< ValueType > nodeBegin(ConstReference value) const;


            NodeMapIterator< 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;
            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 NodeMapIterator {
            typedef NodeMapIterator<T> self;
            typedef NodeMapIterator<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 NodeMap<T>::ValueType value_type;
            typedef typename NodeMap<T>::ValueType ValueType;

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

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

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

            NodeMapIterator(const NodeMap<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 >
        NodeMap<T>::NodeMap() : _tabData(), _owner(), _dflt() {
        }

        template <typename T>
        NodeMap<T>::NodeMap(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(), "NodeMap");
        }

        template <typename T>
        void NodeMap<T>::init(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(), "NodeMap");
        }

        template <typename T>
        typename NodeMap<T>::Reference NodeMap<T>::operator[](Node n) {
            //require(Exception, _owner!=0,"NodeMap::operator[]: invalid owner");
            require(Exception, n.valid(), "NodeMap::operator[]: invalid node");
            //require(Exception, n.owner()==_owner,"NodeMap::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(), "NodeMap[]");
            return _tabData.operator[](n.id());
        }

        template <typename T>
        typename NodeMap<T>::ConstReference NodeMap<T>::operator[](Node n) const {
            //require(Exception, _owner!=0,"NodeMap::operator[]: invalid owner");
            require(Exception, n.valid(), "NodeMap::operator[]: invalid node");
            //require(Exception, n.owner()==_owner,"NodeMap::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(), "NodeMap[]");
            return _tabData.operator[](n.id());
        }

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

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

        template<typename T>
        NodeMapIterator<T>::NodeMapIterator(const NodeMap<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 NodeMapIterator<T>::Reference NodeMapIterator<T>::operator*() const {
            return _pMap->operator[](*_currentIterator);
        }

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

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

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

        template<typename T>
        typename NodeMapIterator<T>::Self NodeMapIterator<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 NodeMapIterator<T>::operator==(const Self & it) const {
            return (_pMap == it._pMap) && (_currentIterator == it._currentIterator);
        }

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

        template<typename T>
        void printDot(ostream & os, const T & value) {
            os << "[ label=\"" << value << "\"];";
        }

        template<typename T>
        void NodeMap<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;
                printDot(os, 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 >
        NodeMapIterator< typename NodeMap<T>::ValueType > NodeMap<T>::nodeBegin(NodeMap<T>::ConstReference value) const {
            return NodeMapIterator< NodeMap<T>::ValueType >(this, owner().nodeBegin(), value);
        }

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

#endif