RhodeCode

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

      unlace(key);

      Parent::operator[](key).value = value;

      lace(key);

    }

    /// \brief Const subscript operator of the map.

    ///

    /// Const subscript operator of the map.

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

      return Parent::operator[](key).value;

    }

    /// \brief Iterator for the keys with the same value.

    ///

    /// Iterator for the keys with the same value. It works

    /// like a graph item iterator, it can be converted to

    /// the item type of the map, incremented with \c ++ operator, and

    /// if the iterator leaves the last valid item, it will be equal to

    /// \c INVALID.

    class ItemIt : public Key {

    public:

      typedef Key Parent;

      /// \brief Invalid constructor \& conversion.

      ///

      /// This constructor initializes the iterator to be invalid.

      /// \sa Invalid for more details.

      ItemIt(Invalid) : Parent(INVALID), _map(0) {}

      /// \brief Creates an iterator with a value.

      ///

      /// Creates an iterator with a value. It iterates on the

      /// keys which have the given value.

      /// \param map The IterableValueMap

      /// \param value The value

      ItemIt(const IterableValueMap& map, const Value& value) : _map(&map) {

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

          map._first.find(value);

        if (it == map._first.end()) {

          Parent::operator=(INVALID);

        } else {

          Parent::operator=(it->second);

        }

      }

      /// \brief Increment operator.

      ///

      /// Increment Operator.

      ItemIt& operator++() {

        Parent::operator=(_map->IterableValueMap::Parent::

                          operator[](static_cast<Parent&>(*this)).next);

        return *this;

      }

    private:

      const IterableValueMap* _map;

    };

  protected:

    virtual void add(const Key& key) {

      Parent::add(key);

    }

    virtual void add(const std::vector<Key>& keys) {

      Parent::add(keys);

      for (int i = 0; i < int(keys.size()); ++i) {

        lace(keys[i]);

      }

    }

    virtual void erase(const Key& key) {

      unlace(key);

      Parent::erase(key);

    }

    virtual void erase(const std::vector<Key>& keys) {

      for (int i = 0; i < int(keys.size()); ++i) {

        unlace(keys[i]);

      }

      Parent::erase(keys);

    }

    virtual void build() {

      Parent::build();

      for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {

        lace(it);

      }

    }

    virtual void clear() {

      _first.clear();

      Parent::clear();

    }

  private:

    std::map<Value, Key> _first;

  };

  /// \brief Map of the source nodes of arcs in a digraph.

  ///

  /// SourceMap provides access for the source node of each arc in a digraph,

  /// which is returned by the \c source() function of the digraph.

  /// \tparam GR The digraph type.

  /// \see TargetMap

  template <typename GR>

  class SourceMap {

  public:

    /// The key type (the \c Arc type of the digraph).

    typedef typename GR::Arc Key;

    /// The value type (the \c Node type of the digraph).

    typedef typename GR::Node Value;

    /// \brief Constructor

    ///

    /// Constructor.

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

    explicit SourceMap(const GR& digraph) : _graph(digraph) {}

    /// \brief Returns the source node of the given arc.

    ///

    /// Returns the source node of the given arc.

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

      return _graph.source(arc);

    }

    it = map.beginValue();

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

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

    map.set(n0, 'C');

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

          "Wrong CrossRefMap");

    check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");

    check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");

    check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");

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

          "Wrong CrossRefMap::count()");

    it = map.beginValue();

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

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

  }

  // CrossRefMap

  {

    typedef SmartDigraph Graph;

    DIGRAPH_TYPEDEFS(Graph);

    checkConcept<ReadWriteMap<Node, int>,

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

    Graph gr;

    typedef CrossRefMap<Graph, Node, char> CRMap;

    typedef CRMap::ValueIterator ValueIt;

    CRMap map(gr);

    Node n0 = gr.addNode();

    Node n1 = gr.addNode();

    Node n2 = gr.addNode();

    map.set(n0, 'A');

    map.set(n1, 'B');

    map.set(n2, 'C');

    map.set(n2, 'A');

    map.set(n0, 'C');

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

          "Wrong CrossRefMap");

    check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");

    check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");

    check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");

    ValueIt it = map.beginValue();

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

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

  }

  // Iterable bool map

  {

    typedef SmartGraph Graph;

    typedef SmartGraph::Node Item;

    typedef IterableBoolMap<SmartGraph, SmartGraph::Node> Ibm;

    checkConcept<ReferenceMap<Item, bool, bool&, const bool&>, Ibm>();

    const int num = 10;

    Graph g;

    std::vector<Item> items;

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

      items.push_back(g.addNode());

    }

    Ibm map1(g, true);

    int n = 0;

    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {

      check(map1[static_cast<Item>(it)], "Wrong TrueIt");

      ++n;

    }

    check(n == num, "Wrong number");

    n = 0;

    for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {

        check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");

        ++n;

    }

    check(n == num, "Wrong number");

    check(Ibm::FalseIt(map1) == INVALID, "Wrong FalseIt");

    check(Ibm::ItemIt(map1, false) == INVALID, "Wrong ItemIt for false");

    map1[items[5]] = true;

    n = 0;

    for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {

        check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");

        ++n;

    }

    check(n == num, "Wrong number");

    map1[items[num / 2]] = false;

    check(map1[items[num / 2]] == false, "Wrong map value");

    n = 0;

    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {

        check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");

        ++n;

    }

    check(n == num - 1, "Wrong number");

    n = 0;

    for (Ibm::FalseIt it(map1); it != INVALID; ++it) {

        check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");

        ++n;

    }

    check(n == 1, "Wrong number");

    map1[items[0]] = false;

    check(map1[items[0]] == false, "Wrong map value");

    map1[items[num - 1]] = false;

    check(map1[items[num - 1]] == false, "Wrong map value");

    n = 0;

    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {

        check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");

        ++n;

    }

    check(n == num - 3, "Wrong number");

    check(map1.trueNum() == num - 3, "Wrong number");

    n = 0;

    for (Ibm::FalseIt it(map1); it != INVALID; ++it) {

        check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");

        ++n;

    }

    check(n == 3, "Wrong number");

    check(map1.falseNum() == 3, "Wrong number");

  }

  // Iterable int map

  {

    typedef SmartGraph Graph;

    typedef SmartGraph::Node Item;

    typedef IterableIntMap<SmartGraph, SmartGraph::Node> Iim;

    checkConcept<ReferenceMap<Item, int, int&, const int&>, Iim>();

    const int num = 10;

    Graph g;

    std::vector<Item> items;

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

      items.push_back(g.addNode());

    }

    Iim map1(g);

    check(map1.size() == 0, "Wrong size");

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

      map1[items[i]] = i;

    }

    check(map1.size() == num, "Wrong size");

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

      Iim::ItemIt it(map1, i);

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

      ++it;

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

    }

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

      map1[items[i]] = i % 2;

    }

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

    int n = 0;

    for (Iim::ItemIt it(map1, 0); it != INVALID; ++it) {

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

      ++n;

    }

    check(n == (num + 1) / 2, "Wrong number");

    for (Iim::ItemIt it(map1, 1); it != INVALID; ++it) {

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

      ++n;

    }

    check(n == num, "Wrong number");

  }

  // Iterable value map

  {

    typedef SmartGraph Graph;

    typedef SmartGraph::Node Item;

    typedef IterableValueMap<SmartGraph, SmartGraph::Node, double> Ivm;

    checkConcept<ReadWriteMap<Item, double>, Ivm>();

    const int num = 10;

    Graph g;

    std::vector<Item> items;

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

      items.push_back(g.addNode());

    }

    Ivm map1(g, 0.0);

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

    check(*map1.beginValue() == 0.0, "Wrong value");

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

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

    }

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

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

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

    }

    for (Ivm::ValueIt vit = map1.beginValue();

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

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

            "Wrong ValueIt");

    }

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

    int n = 0;

    for (Ivm::ItemIt it(map1, 0.0); it != INVALID; ++it) {

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

      ++n;

    }

    check(n == (num + 1) / 2, "Wrong number");

    for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) {

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

      ++n;

    }

    check(n == num, "Wrong number");

  }

  // Graph map utilities:

  // mapMin(), mapMax(), mapMinValue(), mapMaxValue()

  // mapFind(), mapFindIf(), mapCount(), mapCountIf()

  // mapCopy(), mapCompare(), mapFill()

  {

    DIGRAPH_TYPEDEFS(SmartDigraph);

    SmartDigraph g;

    Node n1 = g.addNode();

    Node n2 = g.addNode();

    Node n3 = g.addNode();

    SmartDigraph::NodeMap<int> map1(g);

    SmartDigraph::ArcMap<char> map2(g);

    ConstMap<Node, A> cmap1 = A();

    ConstMap<Arc, C> cmap2 = C(0);