RhodeCode

    }

    /// \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]);

      }

    ///

    /// 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;

      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;

    }

    // 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();

    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) {}

    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) {}

    /// 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

      /// 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>();

      };

      /// \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;

      /// 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  {

      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;

        }

      };

      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;

        }

      };

      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;

        }

      };

      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;

    for (EdgeIt 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 (EdgeIt it(G); it != INVALID; ++it) {

      s -= map[it];

    }

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

  }

} //namespace lemon

#endif