RhodeCode

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

      }

      return *this;

    }

    /// \brief The destructor of the map.

    ///

    /// The destructor of the map.

    virtual ~ArrayMap() {

        : Parent(digraph) {}

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

        : Parent(digraph, value) {}

      NodeMap& operator=(const NodeMap& cmap) {

        return operator=<NodeMap>(cmap);

      }

        : Parent(digraph) {}

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

        : Parent(digraph, value) {}

      ArcMap& operator=(const ArcMap& cmap) {

        return operator=<ArcMap>(cmap);

      }

        : Parent(graph) {}

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

        : Parent(graph, value) {}

      NodeMap& operator=(const NodeMap& cmap) {

        return operator=<NodeMap>(cmap);

      }

        : Parent(graph) {}

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

        : Parent(graph, value) {}

      ArcMap& operator=(const ArcMap& cmap) {

        return operator=<ArcMap>(cmap);

      }

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

        : Parent(graph, value) {}

      EdgeMap& operator=(const EdgeMap& cmap) {

        return operator=<EdgeMap>(cmap);

      }

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

      : Parent(graph, value) {}

    MapExtender& operator=(const MapExtender& cmap) {

      return operator=<MapExtender>(cmap);

    }

      Parent::operator=(cmap);

      return *this;

    }

    class MapIt : public Item {

    public:

      typedef Item Parent;

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

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

    SubMapExtender& operator=(const SubMapExtender& cmap) {

      return operator=<MapExtender>(cmap);

    }

      }

      return *this;

    }

    class MapIt : public Item {

    public:

      typedef Item Parent;

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

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

    }

    /// \brief Copy constructor

    ///

    /// Copy constructor.

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

        NodeMap(const Digraph&) { }

        ///\e

        NodeMap(const Digraph&, T) { }

        ///Copy constructor

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

        ///Assignment operator

        template <typename CMap>

        ///\e

        ArcMap(const Digraph&) { }

        ///\e

        ArcMap(const Digraph&, T) { }

        ///Copy constructor

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

        ///Assignment operator

        template <typename CMap>

        NodeMap(const Graph&) { }

        ///\e

        NodeMap(const Graph&, T) { }

        ///Copy constructor

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

        ///Assignment operator

        template <typename CMap>

        ///\e

        ArcMap(const Graph&) { }

        ///\e

        ArcMap(const Graph&, T) { }

        ///Copy constructor

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

        ///Assignment operator

        template <typename CMap>

        ///\e

        EdgeMap(const Graph&) { }

        ///\e

        EdgeMap(const Graph&, T) { }

        ///Copy constructor

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

        ///Assignment operator

        template <typename CMap>

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

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

        return *this;

      }

      template<typename _Map>

      struct Constraints {

        void constraints() {

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

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

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

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

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

      s -= map[it];

    }

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

  }

  template <typename Graph>

  void checkGraphArcMap(const Graph& G) {

      s -= map[it];

    }

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

  }

  template <typename Graph>

  void checkGraphEdgeMap(const Graph& G) {

      s -= map[it];

    }

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

  }

} //namespace lemon