RhodeCode

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

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

      }

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

      /// \e

      /// \e

    private:

      typename Container::const_iterator 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>

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

    }

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

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

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

      }

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

      /// \e

      /// \e

    private:

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

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

    }

    /// \brief Set operation of the map.

  class SourceMap {

  public:

    typedef typename GR::Arc Key;

    typedef typename GR::Node Value;

    /// \brief Constructor

  class TargetMap {

  public:

    typedef typename GR::Arc Key;

    typedef typename GR::Node Value;

    /// \brief Constructor

  class ForwardMap {

  public:

    typedef typename GR::Arc Value;

    /// \brief Constructor

    ///

  class BackwardMap {

  public:

    typedef typename GR::Arc Value;

    /// \brief Constructor

    ///

    Graph gr;

    typedef CrossRefMap<Graph, Node, char> CRMap;

    CRMap map(gr);

    Node n0 = gr.addNode();

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

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