RhodeCode

    /// The graph type of IdMap.

    typedef GR Graph;

    typedef GR Digraph;

    /// The key type of IdMap (\c Node, \c Arc or \c Edge).

    typedef K Item;

    /// The key type of IdMap (\c Node, \c Arc or \c Edge).

    typedef K Key;

    /// The value type of IdMap.

    typedef int Value;

    /// \brief Constructor.

    ///

    /// Constructor of the map.

    explicit IdMap(const Graph& graph) : _graph(&graph) {}

    /// \brief Gives back the \e id of the item.

    ///

    /// Gives back the immutable and unique \e id of the item.

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

    /// \brief Gives back the \e item by its id.

    ///

    /// Gives back the \e item by its id.

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

  private:

    const Graph* _graph;

  public:

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

    ///

    /// The inverse map type of IdMap. The subscript operator gives back

    /// an item by its id.

    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.

    /// \see inverse()

    class InverseMap {

    public:

      /// \brief Constructor.

      ///

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

      explicit InverseMap(const Graph& graph) : _graph(&graph) {}

      /// \brief Constructor.

      ///

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

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

      /// \brief Gives back an item by its id.

      ///

      /// Gives back an item by its id.

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

    private:

      const Graph* _graph;

    };

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

    ///

    /// Gives back the inverse of the IdMap.

    InverseMap inverse() const { return InverseMap(*_graph);}

  };

  /// \brief General cross reference graph map type.

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

  /// The graph items can be accessed by their values either using

  /// \c InverseMap or \c operator()(), and the values of the map can be

  /// accessed with an STL compatible forward iterator (\c ValueIt).

  /// 

  /// This map is intended to be used when all associated values are

  /// different (the map is actually invertable) or there are only a few

  /// items with the same value.

  /// Otherwise consider to use \c IterableValueMap, which is more 

  /// suitable and more efficient for such cases. It provides iterators

  /// to traverse the items with the same associated value, however

  /// it does not have \c InverseMap.

  ///

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

  /// the subscript operator.

  ///

  /// \tparam GR The graph type.

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

  /// \c GR::Edge).

  /// \tparam V The value type of the map.

  ///

  /// \see IterableValueMap

  template <typename GR, typename K, typename V>

  class CrossRefMap

    : protected ItemSetTraits<GR, K>::template Map<V>::Type {

  private:

    typedef typename ItemSetTraits<GR, K>::

      template Map<V>::Type Map;

    typedef std::multimap<V, K> Container;

    Container _inv_map;

  public:

    /// The graph type of CrossRefMap.

    typedef GR Graph;

    typedef GR Digraph;

    /// The key type of CrossRefMap (\c Node, \c Arc or \c Edge).

    typedef K Item;

    /// The key type of CrossRefMap (\c Node, \c Arc or \c Edge).

    typedef K Key;

    /// The value type of CrossRefMap.

    typedef V Value;

    /// \brief Constructor.

    ///

    /// Construct a new CrossRefMap for the given graph.

    explicit CrossRefMap(const Graph& graph) : Map(graph) {}

    /// \brief Forward iterator for values.

    ///

    /// This iterator is an STL compatible forward

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

    /// traversed for each item it is assigned to.

    class ValueIt

      : public std::iterator<std::forward_iterator_tag, Value> {

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

      return Map::operator[](item);

    }

    /// \brief Gives back the item belonging to a \e range \e id

    ///

    /// Gives back the item belonging to the given \e range \e id.

    Item operator()(int id) const {

      return _inv_map[id];

    }

  private:

    typedef std::vector<Item> Container;

    Container _inv_map;

  public:

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

    ///

    /// The inverse map type of RangeIdMap. The subscript operator gives

    /// back an item by its \e range \e id.

    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.

    class InverseMap {

    public:

      /// \brief Constructor

      ///

      /// Constructor of the InverseMap.

      explicit InverseMap(const RangeIdMap& inverted)

        : _inverted(inverted) {}

      /// The value type of the InverseMap.

      typedef typename RangeIdMap::Key Value;

      /// The key type of the InverseMap.

      typedef typename RangeIdMap::Value Key;

      /// \brief Subscript operator.

      ///

      /// Subscript operator. It gives back the item

      /// that the given \e range \e id currently belongs to.

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

        return _inverted(key);

      }

      /// \brief Size of the map.

      ///

      /// Returns the size of the map.

      unsigned int size() const {

        return _inverted.size();

      }

    private:

      const RangeIdMap& _inverted;

    };

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

    ///

    /// Gives back the inverse of the RangeIdMap.

    const InverseMap inverse() const {

      return InverseMap(*this);

    }

  };

  /// \brief Dynamic iterable \c bool map.

  ///

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

  /// the keys mapped to the value.

  ///

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

  /// subscript operator.

  ///

  /// \tparam GR The graph type.

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

  /// \c GR::Edge).

  ///

  /// \see IterableIntMap, IterableValueMap

  /// \see CrossRefMap

  template <typename GR, typename K>

  class IterableBoolMap

    : protected ItemSetTraits<GR, K>::template Map<int>::Type {

  private:

    typedef GR Graph;

    typedef typename ItemSetTraits<GR, K>::ItemIt KeyIt;

    typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Parent;

    std::vector<K> _array;

    int _sep;

  public:

    /// Indicates that the map is reference map.

    typedef True ReferenceMapTag;

    /// The key type

    typedef K Key;

    /// The value type

    typedef bool Value;

    /// The const reference type.

    typedef const Value& ConstReference;

  private:

    int position(const Key& key) const {

      return Parent::operator[](key);

    }

  public:

    /// \brief Reference to the value of the map.

    ///

    /// This class is similar to the \c bool type. It can be converted to

    /// \c bool and it provides the same operators.

    class Reference {

      friend class IterableBoolMap;

    private:

      Reference(IterableBoolMap& map, const Key& key)

        : _key(key), _map(map) {}

    public:

      Reference& operator=(const Reference& value) {

        _map.set(_key, static_cast<bool>(value));

         return *this;

      }