RhodeCode

    typedef std::allocator<Value> Allocator;

  public:

    /// \brief Graph initialized map constructor.

    ///

    /// Graph initialized map constructor.

    explicit ArrayMap(const Graph& graph) {

      Parent::attach(graph.notifier(Item()));

      allocate_memory();

      Notifier* nf = Parent::notifier();

      Item it;

      for (nf->first(it); it != INVALID; nf->next(it)) {

        int id = nf->id(it);;

        allocator.construct(&(values[id]), Value());

      }

    }

    /// \brief Constructor to use default value to initialize the map.

    ///

    /// It constructs a map and initialize all of the the map.

    ArrayMap(const Graph& graph, const Value& value) {

      Parent::attach(graph.notifier(Item()));

      allocate_memory();

      Notifier* nf = Parent::notifier();

      Item it;

      for (nf->first(it); it != INVALID; nf->next(it)) {

        int id = nf->id(it);;

        allocator.construct(&(values[id]), value);

      }

    }

    /// \brief Constructor to copy a map of the same map type.

    ///

    /// Constructor to copy a map of the same map type.

    ArrayMap(const ArrayMap& copy) : Parent() {

      if (copy.attached()) {

        attach(*copy.notifier());

      }

      capacity = copy.capacity;

      if (capacity == 0) return;

      values = allocator.allocate(capacity);

      Notifier* nf = Parent::notifier();

      Item it;

      for (nf->first(it); it != INVALID; nf->next(it)) {

        int id = nf->id(it);;

        allocator.construct(&(values[id]), copy.values[id]);

      }

    }

    /// \brief Assign operator.

    ///

    /// This operator assigns for each item in the map the

    /// value mapped to the same item in the copied map.

    /// The parameter map should be indiced with the same

    /// itemset because this assign operator does not change

    /// the container of the map.

    ArrayMap& operator=(const ArrayMap& cmap) {

      return operator=<ArrayMap>(cmap);

    }

    /// \brief Template assign operator.

    ///

    /// The given parameter should be conform to the ReadMap

    /// concecpt and could be indiced by the current item set of

    /// the NodeMap. In this case the value for each item

    /// is assigned by the value of the given ReadMap.

    template <typename CMap>

    ArrayMap& operator=(const CMap& cmap) {

      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();

      const typename Parent::Notifier* nf = Parent::notifier();

      Item it;

      for (nf->first(it); it != INVALID; nf->next(it)) {

        set(it, cmap[it]);

      }

      return *this;

    }

    /// \brief The destructor of the map.

    ///

    /// The destructor of the map.

    virtual ~ArrayMap() {

      if (attached()) {

        clear();

        detach();

      }

    }

  protected:

    using Parent::attach;

    using Parent::detach;

    using Parent::attached;

  public:

    /// \brief The subscript operator.

    ///

    /// The subscript operator. The map can be subscripted by the

    /// actual keys of the graph.

    Value& operator[](const Key& key) {

      int id = Parent::notifier()->id(key);

      return values[id];

    }

    /// \brief The const subscript operator.

    ///

    /// The const subscript operator. The map can be subscripted by the

    /// actual keys of the graph.

    const Value& operator[](const Key& key) const {

    /// iterator

    Node runningNode(const OutArcIt &arc) const {

      return Parent::target(arc);

    }

    /// \brief Base node of the iterator

    ///

    /// Returns the base node (i.e. the target in this case) of the iterator

    Node baseNode(const InArcIt &arc) const {

      return Parent::target(arc);

    }

    /// \brief Running node of the iterator

    ///

    /// Returns the running node (i.e. the source in this case) of the

    /// iterator

    Node runningNode(const InArcIt &arc) const {

      return Parent::source(arc);

    }

    template <typename _Value>

    class NodeMap

      : public MapExtender<DefaultMap<Digraph, Node, _Value> > {

    public:

      typedef DigraphExtender Digraph;

      typedef MapExtender<DefaultMap<Digraph, Node, _Value> > Parent;

      explicit NodeMap(const Digraph& digraph)

        : Parent(digraph) {}

      NodeMap(const Digraph& digraph, const _Value& value)

        : Parent(digraph, value) {}

      NodeMap& operator=(const NodeMap& cmap) {

        return operator=<NodeMap>(cmap);

      }

      template <typename CMap>

      NodeMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

    template <typename _Value>

    class ArcMap

      : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {

    public:

      typedef DigraphExtender Digraph;

      typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;

      explicit ArcMap(const Digraph& digraph)

        : Parent(digraph) {}

      ArcMap(const Digraph& digraph, const _Value& value)

        : Parent(digraph, value) {}

      ArcMap& operator=(const ArcMap& cmap) {

        return operator=<ArcMap>(cmap);

      }

      template <typename CMap>

      ArcMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

    Node addNode() {

      Node node = Parent::addNode();

      notifier(Node()).add(node);

      return node;

    }

    Arc addArc(const Node& from, const Node& to) {

      Arc arc = Parent::addArc(from, to);

      notifier(Arc()).add(arc);

      return arc;

    }

    void clear() {

      notifier(Arc()).clear();

      notifier(Node()).clear();

      Parent::clear();

    }

    template <typename Digraph, typename NodeRefMap, typename ArcRefMap>

    void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {

    /// iterator

    Node runningNode(const InArcIt &arc) const {

      return Parent::source(static_cast<const Arc&>(arc));

    }

    /// Base node of the iterator

    ///

    /// Returns the base node of the iterator

    Node baseNode(const IncEdgeIt &edge) const {

      return edge._direction ? u(edge) : v(edge);

    }

    /// Running node of the iterator

    ///

    /// Returns the running node of the iterator

    Node runningNode(const IncEdgeIt &edge) const {

      return edge._direction ? v(edge) : u(edge);

    }

    // Mappable extension

    template <typename _Value>

    class NodeMap

      : public MapExtender<DefaultMap<Graph, Node, _Value> > {

    public:

      typedef GraphExtender Graph;

      typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;

      NodeMap(const Graph& graph)

        : Parent(graph) {}

      NodeMap(const Graph& graph, const _Value& value)

        : Parent(graph, value) {}

      NodeMap& operator=(const NodeMap& cmap) {

        return operator=<NodeMap>(cmap);

      }

      template <typename CMap>

      NodeMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

    template <typename _Value>

    class ArcMap

      : public MapExtender<DefaultMap<Graph, Arc, _Value> > {

    public:

      typedef GraphExtender Graph;

      typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;

      ArcMap(const Graph& graph)

        : Parent(graph) {}

      ArcMap(const Graph& graph, const _Value& value)

        : Parent(graph, value) {}

      ArcMap& operator=(const ArcMap& cmap) {

        return operator=<ArcMap>(cmap);

      }

      template <typename CMap>

      ArcMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

    template <typename _Value>

    class EdgeMap

      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {

    public:

      typedef GraphExtender Graph;

      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;

      EdgeMap(const Graph& graph)

        : Parent(graph) {}

      EdgeMap(const Graph& graph, const _Value& value)

        : Parent(graph, value) {}

      EdgeMap& operator=(const EdgeMap& cmap) {

        return operator=<EdgeMap>(cmap);

      }

      template <typename CMap>

      EdgeMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

    // Alteration extension

    Node addNode() {

      Node node = Parent::addNode();

      notifier(Node()).add(node);

      return node;

    }

    Edge addEdge(const Node& from, const Node& to) {

      Edge edge = Parent::addEdge(from, to);

      notifier(Edge()).add(edge);

      std::vector<Arc> ev;

      ev.push_back(Parent::direct(edge, true));

      ev.push_back(Parent::direct(edge, false));

      notifier(Arc()).add(ev);

      return edge;

    }

    void clear() {

      notifier(Arc()).clear();

  /// \ingroup graphbits

  ///

  /// \brief Extender for maps

  template <typename _Map>

  class MapExtender : public _Map {

  public:

    typedef _Map Parent;

    typedef MapExtender Map;

    typedef typename Parent::Graph Graph;

    typedef typename Parent::Key Item;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    class MapIt;

    class ConstMapIt;

    friend class MapIt;

    friend class ConstMapIt;

  public:

    MapExtender(const Graph& graph)

      : Parent(graph) {}

    MapExtender(const Graph& graph, const Value& value)

      : Parent(graph, value) {}

    MapExtender& operator=(const MapExtender& cmap) {

      return operator=<MapExtender>(cmap);

    }

    template <typename CMap>

    MapExtender& operator=(const CMap& cmap) {

      Parent::operator=(cmap);

      return *this;

    }

    class MapIt : public Item {

    public:

      typedef Item Parent;

      typedef typename Map::Value Value;

      MapIt() {}

      MapIt(Invalid i) : Parent(i) { }

      explicit MapIt(Map& _map) : map(_map) {

        map.notifier()->first(*this);

      }

      MapIt(const Map& _map, const Item& item)

        : Parent(item), map(_map) {}

      MapIt& operator++() {

        map.notifier()->next(*this);

        return *this;

      }

      typename MapTraits<Map>::ConstReturnValue operator*() const {

        return map[*this];

      }

      typename MapTraits<Map>::ReturnValue operator*() {

        return map[*this];

      }

      void set(const Value& value) {

        map.set(*this, value);

  /// \ingroup graphbits

  ///

  /// \brief Extender for maps which use a subset of the items.

  template <typename _Graph, typename _Map>

  class SubMapExtender : public _Map {

  public:

    typedef _Map Parent;

    typedef SubMapExtender Map;

    typedef _Graph Graph;

    typedef typename Parent::Key Item;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    class MapIt;

    class ConstMapIt;

    friend class MapIt;

    friend class ConstMapIt;

  public:

    SubMapExtender(const Graph& _graph)

      : Parent(_graph), graph(_graph) {}

    SubMapExtender(const Graph& _graph, const Value& _value)

      : Parent(_graph, _value), graph(_graph) {}

    SubMapExtender& operator=(const SubMapExtender& cmap) {

      return operator=<MapExtender>(cmap);

    }

    template <typename CMap>

    SubMapExtender& operator=(const CMap& cmap) {

      checkConcept<concepts::ReadMap<Key, Value>, CMap>();

      Item it;

      for (graph.first(it); it != INVALID; graph.next(it)) {

        Parent::set(it, cmap[it]);

      }

      return *this;

    }

    class MapIt : public Item {

    public:

      typedef Item Parent;

      typedef typename Map::Value Value;

      MapIt() {}

      MapIt(Invalid i) : Parent(i) { }

      explicit MapIt(Map& _map) : map(_map) {

        map.graph.first(*this);

      }

      MapIt(const Map& _map, const Item& item)

        : Parent(item), map(_map) {}

      MapIt& operator++() {

        map.graph.next(*this);

        return *this;

      }

      typename MapTraits<Map>::ConstReturnValue operator*() const {

        return map[*this];

      }

      typename MapTraits<Map>::ReturnValue operator*() {

        return map[*this];

      }

      void set(const Value& value) {

        map.set(*this, value);

    /// The notifier type.

    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;

    /// The map type.

    typedef VectorMap Map;

    /// The base class of the map.

    typedef typename Notifier::ObserverBase Parent;

    /// The reference type of the map;

    typedef typename Container::reference Reference;

    /// The const reference type of the map;

    typedef typename Container::const_reference ConstReference;

    /// \brief Constructor to attach the new map into the notifier.

    ///

    /// It constructs a map and attachs it into the notifier.

    /// It adds all the items of the graph to the map.

    VectorMap(const Graph& graph) {

      Parent::attach(graph.notifier(Item()));

      container.resize(Parent::notifier()->maxId() + 1);

    }

    /// \brief Constructor uses given value to initialize the map.

    ///

    /// It constructs a map uses a given value to initialize the map.

    /// It adds all the items of the graph to the map.

    VectorMap(const Graph& graph, const Value& value) {

      Parent::attach(graph.notifier(Item()));

      container.resize(Parent::notifier()->maxId() + 1, value);

    }

    /// \brief Copy constructor

    ///

    /// Copy constructor.

    VectorMap(const VectorMap& _copy) : Parent() {

      if (_copy.attached()) {

        Parent::attach(*_copy.notifier());

        container = _copy.container;

      }

    }

    /// \brief Assign operator.

    ///

    /// This operator assigns for each item in the map the

    /// value mapped to the same item in the copied map.

    /// The parameter map should be indiced with the same

    /// itemset because this assign operator does not change

    /// the container of the map.

    VectorMap& operator=(const VectorMap& cmap) {

      return operator=<VectorMap>(cmap);

    }

    /// \brief Template assign operator.

    ///

    /// The given parameter should be conform to the ReadMap

    /// concecpt and could be indiced by the current item set of

    /// the NodeMap. In this case the value for each item

    /// is assigned by the value of the given ReadMap.

    template <typename CMap>

    VectorMap& operator=(const CMap& cmap) {

      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();

      const typename Parent::Notifier* nf = Parent::notifier();

      Node runningNode(const InArcIt&) const { return INVALID; }

      /// \brief The base node of the iterator.

      ///

      /// Gives back the base node of the iterator.

      /// It is always the source of the pointed arc.

      Node baseNode(const OutArcIt&) const { return INVALID; }

      /// \brief The running node of the iterator.

      ///

      /// Gives back the running node of the iterator.

      /// It is always the target of the pointed arc.

      Node runningNode(const OutArcIt&) const { return INVALID; }

      /// \brief The opposite node on the given arc.

      ///

      /// Gives back the opposite node on the given arc.

      Node oppositeNode(const Node&, const Arc&) const { return INVALID; }

      /// \brief Read write map of the nodes to type \c T.

      ///

      /// ReadWrite map of the nodes to type \c T.

      /// \sa Reference

      template<class T>

      class NodeMap : public ReadWriteMap< Node, T > {

      public:

        ///\e

        NodeMap(const Digraph&) { }

        ///\e

        NodeMap(const Digraph&, T) { }

        ///Copy constructor

        NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }

        ///Assignment operator

        template <typename CMap>

        NodeMap& operator=(const CMap&) {

          checkConcept<ReadMap<Node, T>, CMap>();

          return *this;

        }

      };

      /// \brief Read write map of the arcs to type \c T.

      ///

      /// Reference map of the arcs to type \c T.

      /// \sa Reference

      template<class T>

      class ArcMap : public ReadWriteMap<Arc,T> {

      public:

        ///\e

        ArcMap(const Digraph&) { }

        ///\e

        ArcMap(const Digraph&, T) { }

        ///Copy constructor

        ArcMap(const ArcMap& em) : ReadWriteMap<Arc,T>(em) { }

        ///Assignment operator

        template <typename CMap>

        ArcMap& operator=(const CMap&) {

          checkConcept<ReadMap<Arc, T>, CMap>();

          return *this;

        }

      };

      template <typename _Digraph>

      struct Constraints {

        void constraints() {

          checkConcept<IterableDigraphComponent<>, _Digraph>();

          checkConcept<IDableDigraphComponent<>, _Digraph>();

          checkConcept<MappableDigraphComponent<>, _Digraph>();

        }

      };

    };

  } //namespace concepts

} //namespace lemon

#endif // LEMON_CONCEPT_DIGRAPH_H

        ///@param g the graph

        InArcIt(const Graph& g, const Node& n) {

          ignore_unused_variable_warning(n);

          ignore_unused_variable_warning(g);

        }

        /// Arc -> InArcIt conversion

        /// Sets the iterator to the value of the trivial iterator \c e.

        /// This feature necessitates that each time we

        /// iterate the arc-set, the iteration order is the same.

        InArcIt(const Graph&, const Arc&) { }

        /// Next incoming arc

        /// Assign the iterator to the next inarc of the corresponding node.

        ///

        InArcIt& operator++() { return *this; }

      };

      /// \brief Read write map of the nodes to type \c T.

      ///

      /// ReadWrite map of the nodes to type \c T.

      /// \sa Reference

      template<class T>

      class NodeMap : public ReadWriteMap< Node, T >

      {

      public:

        ///\e

        NodeMap(const Graph&) { }

        ///\e

        NodeMap(const Graph&, T) { }

        ///Copy constructor

        NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }

        ///Assignment operator

        template <typename CMap>

        NodeMap& operator=(const CMap&) {

          checkConcept<ReadMap<Node, T>, CMap>();

          return *this;

        }

      };

      /// \brief Read write map of the directed arcs to type \c T.

      ///

      /// Reference map of the directed arcs to type \c T.

      /// \sa Reference

      template<class T>

      class ArcMap : public ReadWriteMap<Arc,T>

      {

      public:

        ///\e

        ArcMap(const Graph&) { }

        ///\e

        ArcMap(const Graph&, T) { }

        ///Copy constructor

        ArcMap(const ArcMap& em) : ReadWriteMap<Arc,T>(em) { }

        ///Assignment operator

        template <typename CMap>

        ArcMap& operator=(const CMap&) {

          checkConcept<ReadMap<Arc, T>, CMap>();

          return *this;

        }

      };

      /// Read write map of the edges to type \c T.

      /// Reference map of the arcs to type \c T.

      /// \sa Reference

      template<class T>

      class EdgeMap : public ReadWriteMap<Edge,T>

      {

      public:

        ///\e

        EdgeMap(const Graph&) { }

        ///\e

        EdgeMap(const Graph&, T) { }

        ///Copy constructor

        EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) {}

        ///Assignment operator

        template <typename CMap>

        EdgeMap& operator=(const CMap&) {

          checkConcept<ReadMap<Edge, T>, CMap>();

          return *this;

        }

      };

      /// \brief Direct the given edge.

      ///

      /// Direct the given edge. The returned arc source

      /// will be the given node.

      Arc direct(const Edge&, const Node&) const {

        return INVALID;

      }

      /// \brief Direct the given edge.

      ///

      /// Direct the given edge. The returned arc

      /// represents the given edge and the direction comes

      /// from the bool parameter. The source of the edge and

      /// the directed arc is the same when the given bool is true.

      Arc direct(const Edge&, bool) const {

        return INVALID;

      }

      /// \brief Returns true if the arc has default orientation.

      ///

      /// Returns whether the given directed arc is same orientation as

      /// the corresponding edge's default orientation.

        const _Graph& graph;

      };

    };

    /// \brief Class describing the concept of graph maps

    ///

    /// This class describes the common interface of the graph maps

    /// (NodeMap, ArcMap), that is \ref maps-page "maps" which can be used to

    /// associate data to graph descriptors (nodes or arcs).

    template <typename _Graph, typename _Item, typename _Value>

    class GraphMap : public ReadWriteMap<_Item, _Value> {

    public:

      typedef ReadWriteMap<_Item, _Value> Parent;

      /// The graph type of the map.

      typedef _Graph Graph;

      /// The key type of the map.

      typedef _Item Key;

      /// The value type of the map.

      typedef _Value Value;

      /// \brief Construct a new map.

      ///

      /// Construct a new map for the graph.

      explicit GraphMap(const Graph&) {}

      /// \brief Construct a new map with default value.

      ///

      /// Construct a new map for the graph and initalise the values.

      GraphMap(const Graph&, const Value&) {}

      /// \brief Copy constructor.

      ///

      /// Copy Constructor.

      GraphMap(const GraphMap&) : Parent() {}

      /// \brief Assign operator.

      ///

      /// Assign operator. It does not mofify the underlying graph,

      /// it just iterates on the current item set and set the  map

      /// with the value returned by the assigned map.

      template <typename CMap>

      GraphMap& operator=(const CMap&) {

        checkConcept<ReadMap<Key, Value>, CMap>();

        return *this;

      }

      template<typename _Map>

      struct Constraints {

        void constraints() {

          checkConcept<ReadWriteMap<Key, Value>, _Map >();

          // Construction with a graph parameter

          _Map a(g);

          // Constructor with a graph and a default value parameter

          _Map a2(g,t);

          // Copy constructor.

          ignore_unused_variable_warning(a2);

        }

        const _Map &c;

        const Graph &g;

        const typename GraphMap::Value &t;

      };

    };

    /// \brief An empty mappable digraph class.

    ///

    /// This class provides beside the core digraph features

    /// map interface for the digraph structure.

    /// This concept is part of the Digraph concept.

    template <typename _Base = BaseDigraphComponent>

    class MappableDigraphComponent : public _Base  {

    public:

      typedef _Base Base;

      typedef typename Base::Node Node;

      typedef typename Base::Arc Arc;

      typedef MappableDigraphComponent Digraph;

      /// \brief ReadWrite map of the nodes.

      ///

      /// ReadWrite map of the nodes.

      ///

      template <typename _Value>

      class NodeMap : public GraphMap<Digraph, Node, _Value> {

      public:

        typedef GraphMap<MappableDigraphComponent, Node, _Value> Parent;

        /// \brief Construct a new map.

        ///

        /// Construct a new map for the digraph.

        explicit NodeMap(const MappableDigraphComponent& digraph)

          : Parent(digraph) {}

        /// \brief Construct a new map with default value.

        ///

        /// Construct a new map for the digraph and initalise the values.

        NodeMap(const MappableDigraphComponent& digraph, const _Value& value)

          : Parent(digraph, value) {}

        /// \brief Copy constructor.

        ///

        /// Copy Constructor.

        NodeMap(const NodeMap& nm) : Parent(nm) {}

        /// \brief Assign operator.

        ///

        /// Assign operator.

        template <typename CMap>

        NodeMap& operator=(const CMap&) {

          checkConcept<ReadMap<Node, _Value>, CMap>();

          return *this;

        }

      };

      /// \brief ReadWrite map of the arcs.

      ///

      /// ReadWrite map of the arcs.

      ///

      template <typename _Value>

      class ArcMap : public GraphMap<Digraph, Arc, _Value> {

      public:

        typedef GraphMap<MappableDigraphComponent, Arc, _Value> Parent;

        /// \brief Construct a new map.

        ///

        /// Construct a new map for the digraph.

        explicit ArcMap(const MappableDigraphComponent& digraph)

          : Parent(digraph) {}

        /// \brief Construct a new map with default value.

        ///

        /// Construct a new map for the digraph and initalise the values.

        ArcMap(const MappableDigraphComponent& digraph, const _Value& value)

          : Parent(digraph, value) {}

        /// \brief Copy constructor.

        ///

        /// Copy Constructor.

        ArcMap(const ArcMap& nm) : Parent(nm) {}

        /// \brief Assign operator.

        ///

        /// Assign operator.

        template <typename CMap>

        ArcMap& operator=(const CMap&) {

          checkConcept<ReadMap<Arc, _Value>, CMap>();

          return *this;

        }

      };

      template <typename _Digraph>

      struct Constraints {

        struct Dummy {

          int value;

          Dummy() : value(0) {}

          Dummy(int _v) : value(_v) {}

        };

        void constraints() {

          checkConcept<Base, _Digraph>();

          { // int map test

            typedef typename _Digraph::template NodeMap<int> IntNodeMap;

            checkConcept<GraphMap<_Digraph, typename _Digraph::Node, int>,

              IntNodeMap >();

    /// map interface for the graph structure.

    /// This concept is part of the Graph concept.

    template <typename _Base = BaseGraphComponent>

    class MappableGraphComponent : public MappableDigraphComponent<_Base>  {

    public:

      typedef _Base Base;

      typedef typename Base::Edge Edge;

      typedef MappableGraphComponent Graph;

      /// \brief ReadWrite map of the edges.

      ///

      /// ReadWrite map of the edges.

      ///

      template <typename _Value>

      class EdgeMap : public GraphMap<Graph, Edge, _Value> {

      public:

        typedef GraphMap<MappableGraphComponent, Edge, _Value> Parent;

        /// \brief Construct a new map.

        ///

        /// Construct a new map for the graph.

        explicit EdgeMap(const MappableGraphComponent& graph)

          : Parent(graph) {}

        /// \brief Construct a new map with default value.

        ///

        /// Construct a new map for the graph and initalise the values.

        EdgeMap(const MappableGraphComponent& graph, const _Value& value)

          : Parent(graph, value) {}

        /// \brief Copy constructor.

        ///

        /// Copy Constructor.

        EdgeMap(const EdgeMap& nm) : Parent(nm) {}

        /// \brief Assign operator.

        ///

        /// Assign operator.

        template <typename CMap>

        EdgeMap& operator=(const CMap&) {

          checkConcept<ReadMap<Edge, _Value>, CMap>();

          return *this;

        }

      };

      template <typename _Graph>

      struct Constraints {

        struct Dummy {

          int value;

          Dummy() : value(0) {}

          Dummy(int _v) : value(_v) {}

        };

        void constraints() {

          checkConcept<MappableGraphComponent<Base>, _Graph>();

          { // int map test

            typedef typename _Graph::template EdgeMap<int> IntEdgeMap;

            checkConcept<GraphMap<_Graph, typename _Graph::Edge, int>,

    for (typename Graph::EdgeIt e(G); e != INVALID; ++e) {

      check(G.edgeFromId(G.id(e)) == e, "Wrong id");

      check(values.find(G.id(e)) == values.end(), "Wrong id");

      check(G.id(e) <= G.maxEdgeId(), "Wrong maximum id");

      values.insert(G.id(e));

    }

  }

  template <typename Graph>

  void checkGraphNodeMap(const Graph& G) {

    typedef typename Graph::Node Node;

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::template NodeMap<int> IntNodeMap;

    IntNodeMap map(G, 42);

    for (NodeIt it(G); it != INVALID; ++it) {

      check(map[it] == 42, "Wrong map constructor.");

    }

    int s = 0;

    for (NodeIt it(G); it != INVALID; ++it) {

      map[it] = 0;

      check(map[it] == 0, "Wrong operator[].");

      map.set(it, s);

      check(map[it] == s, "Wrong set.");

      ++s;

    }

    s = s * (s - 1) / 2;

    for (NodeIt it(G); it != INVALID; ++it) {

      s -= map[it];

    }

    check(s == 0, "Wrong sum.");

  }

  template <typename Graph>

  void checkGraphArcMap(const Graph& G) {

    typedef typename Graph::Arc Arc;

    typedef typename Graph::ArcIt ArcIt;

    typedef typename Graph::template ArcMap<int> IntArcMap;

    IntArcMap map(G, 42);

    for (ArcIt it(G); it != INVALID; ++it) {

      check(map[it] == 42, "Wrong map constructor.");

    }

    int s = 0;

    for (ArcIt it(G); it != INVALID; ++it) {

      map[it] = 0;

      check(map[it] == 0, "Wrong operator[].");

      map.set(it, s);

      check(map[it] == s, "Wrong set.");

      ++s;

    }

    s = s * (s - 1) / 2;

    for (ArcIt it(G); it != INVALID; ++it) {

      s -= map[it];

    }

    check(s == 0, "Wrong sum.");

  }

  template <typename Graph>

  void checkGraphEdgeMap(const Graph& G) {

    typedef typename Graph::Edge Edge;

    typedef typename Graph::EdgeIt EdgeIt;

    typedef typename Graph::template EdgeMap<int> IntEdgeMap;

    IntEdgeMap map(G, 42);

    for (EdgeIt it(G); it != INVALID; ++it) {

      check(map[it] == 42, "Wrong map constructor.");

    }

    int s = 0;