RhodeCode

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

  /// 

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

    ///

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

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

      friend class CrossRefMap;

    private:

        : it(_it) {}

    public:

      /// Constructor

      /// \e

      /// \e

        operator++();

        return tmp;

      }

      /// \e

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

      /// \e

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

      /// \e

      /// \e

    private:

      typename Container::const_iterator it;

    };

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

    ///

    /// Returns an STL compatible iterator to the

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

    ///

    /// Returns an STL compatible iterator after the

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

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

    /// range.

    }

    /// \brief Sets the value associated with the given key.

    ///

    /// Sets the value associated with the given key.

    void set(const Key& key, const Value& val) {

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

  ///

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

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

  /// the value (\c ItemIt), and the values of the map can be accessed

  /// The map stores a linked list for each value, which contains

  /// the items mapped to the value, and the used values are stored

  /// in balanced binary tree (\c std::map).

  ///

  /// \ref IterableBoolMap and \ref IterableIntMap are similar classes

  /// specialized for \c bool and \c int values, respectively.

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

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

      friend class IterableValueMap;

    private:

        : it(_it) {}

    public:

      /// Constructor

      /// \e

      /// \e

        operator++();

        return tmp;

      }

      /// \e

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

      /// \e

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

      /// \e

      /// \e

    private:

      typename std::map<Value, Key>::const_iterator it;

    };

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

    ///

    /// Returns an STL compatible iterator to the

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

    ///

    /// Returns an STL compatible iterator after the

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

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

    /// range.

    }

    /// \brief Set operation of the map.

    ///

    /// Set operation of the map.

    void set(const Key& key, const Value& value) {

  /// \tparam GR The digraph type.

  /// \see TargetMap

  template <typename GR>

  class SourceMap {

  public:

    typedef typename GR::Arc Key;

    typedef typename GR::Node Value;

    /// \brief Constructor

    ///

    /// Constructor.

    /// \param digraph The digraph that the map belongs to.

  /// \tparam GR The digraph type.

  /// \see SourceMap

  template <typename GR>

  class TargetMap {

  public:

    typedef typename GR::Arc Key;

    typedef typename GR::Node Value;

    /// \brief Constructor

    ///

    /// Constructor.

    /// \param digraph The digraph that the map belongs to.

  /// \tparam GR The graph type.

  /// \see BackwardMap

  template <typename GR>

  class ForwardMap {

  public:

    typedef typename GR::Arc Value;

    /// \brief Constructor

    ///

    /// Constructor.

    /// \param graph The graph that the map belongs to.

    explicit ForwardMap(const GR& graph) : _graph(graph) {}

  /// \tparam GR The graph type.

  /// \see ForwardMap

  template <typename GR>

  class BackwardMap {

  public:

    typedef typename GR::Arc Value;

    /// \brief Constructor

    ///

    /// Constructor.

    /// \param graph The graph that the map belongs to.

    explicit BackwardMap(const GR& graph) : _graph(graph) {}

                 CrossRefMap<Graph, Node, bool> >();

    checkConcept<ReadWriteMap<Node, double>,

                 CrossRefMap<Graph, Node, double> >();

    Graph gr;

    typedef CrossRefMap<Graph, Node, char> CRMap;

    CRMap map(gr);

    Node n0 = gr.addNode();

    Node n1 = gr.addNode();

    Node n2 = gr.addNode();

          "Wrong CrossRefMap");

    check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2,

          "Wrong CrossRefMap");

    check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,

          "Wrong CrossRefMap::count()");

    check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&

          it == map.endValue(), "Wrong value iterator");

    map.set(n2, 'A');

    check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',

      Ivm::ItemIt it(map1, static_cast<double>(i));

      check(static_cast<Item>(it) == items[i], "Wrong value");

      ++it;

      check(static_cast<Item>(it) == INVALID, "Wrong value");

    }

         vit != map1.endValue(); ++vit) {

      check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit,

    }

    for (int i = 0; i < num; ++i) {

      map1.set(items[i], static_cast<double>(i % 2));

    }

    check(distance(map1.beginValue(), map1.endValue()) == 2, "Wrong size");