RhodeCode

  /// its type definitions, or if you have to provide a writable map,

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

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

  ///

  /// \sa ConstMap

  template<typename K, typename V>

  /// value to each key.

  ///

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

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

  ///

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

  /// value to each key.

  ///

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

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

  ///

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

  /// values to integer keys from the range <tt>[0..size-1]</tt>.

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

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

  /// "ReferenceMap" concept.

  ///

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

  /// that you can specify a default value for the keys that are not

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

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

  /// concept.

  ///

  /// This map is useful if a default value should be assigned to most of

  /// "readable map" to another type using the default conversion.

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

  /// function.

  public:

    ///

    /// \see inverse()

    class InverseMap {

    public:

      /// Constructor for creating an id-to-item map.

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

      ///

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

    private:

  /// This class provides simple invertable graph maps.

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

  /// the subscript operator.

    /// \brief Forward iterator for values.

    ///

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

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

    /// They are considered with multiplicity, so each value is

        : it(_it) {}

    public:

      ValueIterator() {}

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

      ValueIterator operator++(int) {

        ValueIterator tmp(*this);

        operator++();

        return tmp;

      }

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

    private:

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

    /// range.

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

    /// range.

  public:

    ///

    class InverseMap {

    public:

      /// \brief Constructor

      const CrossRefMap& _inverted;

    };

    ///

    InverseMap inverse() const {

      return InverseMap(*this);

    }

      _inv_map[pi] = q;

    }

    ///

    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:

      /// \brief Constructor

      /// \brief Subscript operator.

      ///

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

    }

  /// This class provides a special graph map type which can store a

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

  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or

  /// For each non-negative value it is possible to iterate on the keys

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

  /// value in the map.

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

  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or

    /// \brief Forward iterator for values.

    ///

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

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

    class ValueIterator

        : it(_it) {}

    public:

      ValueIterator() {}

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

      ValueIterator operator++(int) {

        ValueIterator tmp(*this);

        operator++();

        return tmp;

      }

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

    private:

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

    /// range.

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

    /// range.