RhodeCode

  /// but data written to it is not required (i.e. it will be sent to

  /// <tt>/dev/null</tt>).

  ///

  /// \sa ConstMap

  ///

  /// In other aspects it is equivalent to \c NullMap.

  /// concept, but it absorbs the data written to it.

  ///

  ///

  /// In other aspects it is equivalent to \c NullMap.

  /// concept, but it absorbs the data written to it.

  ///

  /// It can be used with some data structures, for example

  /// \c UnionFind, \c BinHeap, when the used items are small

  /// "ReferenceMap" concept.

  ///

  /// stored actually. This value can be different from the default

  /// contructed value (i.e. \c %Value()).

  /// concept.

  ///

  /// The \c Key type of it is inherited from \c M and the \c Value

  /// type is \c V.

  ///

  /// The simplest way of using this map is through the convertMap()

  public:

    ///

    /// \see inverse()

    class InverseMap {

      explicit InverseMap(const IdMap& map) : _graph(map._graph) {}

      ///

      Item operator[](int id) const { return _graph->fromId(id, Item());}

  /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap)

  /// and if a key is set to a new value, then stores it in the inverse map.

  ///

  /// This type is not reference map, so it cannot be modified with

    /// \brief Forward iterator for values.

    ///

    /// iterator on the values of the map. The values can

    /// be accessed in the <tt>[beginValue, endValue)</tt> range.

    public:

      ValueIterator() {}

      ValueIterator& operator++() { ++it; return *this; }

      ValueIterator operator++(int) {

        ValueIterator tmp(*this);

      }

      const Value& operator*() const { return it->first; }

      const Value* operator->() const { return &(it->first); }

      bool operator==(ValueIterator jt) const { return it == jt.it; }

      bool operator!=(ValueIterator jt) const { return it != jt.it; }

    /// \brief Returns an iterator to the first value.

    ///

    /// first value of the map. The values of the

    /// map can be accessed in the <tt>[beginValue, endValue)</tt>

    /// \brief Returns an iterator after the last value.

    ///

    /// last value of the map. The values of the

    /// map can be accessed in the <tt>[beginValue, endValue)</tt>

  public:

    ///

    class InverseMap {

    public:

    };

    ///

    InverseMap inverse() const {

      return InverseMap(*this);

    }

    ///

    int operator[](const Item& item) const {

      return Map::operator[](item);

    }

    ///

    Item operator()(int id) const {

      return _inv_map[id];

    /// \brief The inverse map type of RangeIdMap.

    ///

    class InverseMap {

    public:

      ///

      /// Subscript operator. It gives back the item

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

        return _inverted(key);

    /// \brief Gives back the inverse of the map.

    ///

    const InverseMap inverse() const {

      return InverseMap(*this);

  /// \c bool value for graph items (\c Node, \c Arc or \c Edge).

  /// For both \c true and \c false values it is possible to iterate on

  ///

  /// This type is a reference map, so it can be modified with the

  ///

  /// \tparam GR The graph type.

  /// mapped to the value.

  ///

  /// This type is a reference map, so it can be modified with the

  ///

  /// \note The size of the data structure depends on the largest

  /// \brief Dynamic iterable map for comparable values.

  ///

  /// comparable value for graph items (\c Node, \c Arc or \c Edge).

  /// For each value it is possible to iterate on the keys mapped to

  ///

  ///

  /// This type is not reference map, so it cannot be modified with

  ///

  /// \tparam GR The graph type.

    /// \brief Forward iterator for values.

    ///

    /// iterator on the values of the map. The values can

    /// be accessed in the <tt>[beginValue, endValue)</tt> range.

    public:

      ValueIterator() {}

      ValueIterator& operator++() { ++it; return *this; }

      ValueIterator operator++(int) {

        ValueIterator tmp(*this);

      }

      const Value& operator*() const { return it->first; }

      const Value* operator->() const { return &(it->first); }

      bool operator==(ValueIterator jt) const { return it == jt.it; }

      bool operator!=(ValueIterator jt) const { return it != jt.it; }

    /// \brief Returns an iterator to the first value.

    ///

    /// first value of the map. The values of the

    /// map can be accessed in the <tt>[beginValue, endValue)</tt>

    /// \brief Returns an iterator after the last value.

    ///

    /// last value of the map. The values of the

    /// map can be accessed in the <tt>[beginValue, endValue)</tt>