RhodeCode

      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;

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

      }

      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;

      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;

      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;

      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;

      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;

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

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

    ///

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

      }

      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;

        }

      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;

        }

      {

      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;

        }

      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;

        }

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

      };

    };

          : 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.

          : 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.

          : 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.

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

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

      ++s;

    }

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

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

      s -= map[it];

    }

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

  }

} //namespace lemon

#endif