RhodeCode

#include <iterator>

#include <functional>

#include <vector>

#include <lemon/core.h>

///\file

///\ingroup maps

///\brief Miscellaneous property maps

namespace lemon {

  /// \addtogroup maps

  /// It wraps an arbitrary \ref concepts::ReadWriteMap "ReadWriteMap"

  /// and if a key is set to a new value then store it

  /// in the inverse map.

  /// The values of the map can be accessed

  /// with stl compatible forward iterator.

  ///

  /// \tparam GR The graph type.

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

  /// \c GR::Edge).

    }

  };

  ///

  ///

  class IterableBoolMap

  private:

    typedef GR Graph;

    int _sep;

  public:

    typedef True ReferenceMapTag;

    /// The key type

    /// The value type

    typedef bool Value;

    /// The const reference type.

  public:

    ///

    class Reference {

      friend class IterableBoolMap;

    private:

      _sep = (value ? _array.size() : 0);

    }

    ///

    int trueNum() const {

      return _sep;

    }

    ///

    int falseNum() const {

      return _array.size() - _sep;

    }

    ///

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

    /// \c INVALID.

    class TrueIt : public Key {

    public:

      /// \brief Creates an iterator.

      ///

      /// Creates an iterator. It iterates on the

      explicit TrueIt(const IterableBoolMap& map)

        : Parent(map._sep > 0 ? map._array[map._sep - 1] : INVALID),

          _map(&map) {}

      /// \brief Invalid constructor \& conversion.

      ///

      /// \sa Invalid for more details.

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

      /// \brief Increment operator.

      ///

      TrueIt& operator++() {

        int pos = _map->position(*this);

        Parent::operator=(pos > 0 ? _map->_array[pos - 1] : INVALID);

        return *this;

      }

    private:

      const IterableBoolMap* _map;

    };

    ///

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

    /// \c INVALID.

    class FalseIt : public Key {

    public:

      /// \brief Creates an iterator.

      ///

      /// Creates an iterator. It iterates on the

      explicit FalseIt(const IterableBoolMap& map)

        : Parent(map._sep < int(map._array.size()) ?

                 map._array.back() : INVALID), _map(&map) {}

      /// \brief Invalid constructor \& conversion.

      ///

      /// \sa Invalid for more details.

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

      /// \brief Increment operator.

      ///

      FalseIt& operator++() {

        int pos = _map->position(*this);

        Parent::operator=(pos > _map->_sep ? _map->_array[pos - 1] : INVALID);

    /// \brief Iterator for the keys mapped to a given value.

    ///

    /// Iterator for the keys mapped to a given value. It works

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

    /// \c INVALID.

    class ItemIt : public Key {

    public:

      typedef Key Parent;

      ///

      ItemIt(const IterableBoolMap& map, bool value)

        : Parent(value ? 

                 (map._sep > 0 ?

      /// \brief Invalid constructor \& conversion.

      ///

      /// \sa Invalid for more details.

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

      /// \brief Increment operator.

      ///

      ItemIt& operator++() {

        int pos = _map->position(*this);

        int _sep = pos >= _map->_sep ? _map->_sep : 0;

    };

  }

  /// \brief Dynamic iterable integer map.

  ///

  ///

  /// value in the map.

  ///

  class IterableIntMap

  public:

    /// The key type

    /// The value type

    typedef int Value;

    /// The graph type

    /// \brief Constructor of the map.

    ///

    explicit IterableIntMap(const Graph& graph)

      : Parent(graph) {}

    ///

    /// Constructor of the map with a given value.

    explicit IterableIntMap(const Graph& graph, int value)

      if (value >= 0) {

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

          lace(it);

  public:

    typedef True ReferenceMapTag;

    ///

    class Reference {

      friend class IterableIntMap;

    private:

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

    ///

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

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

    /// \c INVALID.

    public:

      /// \brief Invalid constructor \& conversion.

      ///

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

      ItemIt(const IterableIntMap& map, int value) : _map(&map) {

        if (value < 0 || value >= int(_map->_first.size())) {

          Parent::operator=(INVALID);

      /// \brief Increment operator.

      ///

      ItemIt& operator++() {

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

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

        return *this;

      }

    private:

      const IterableIntMap* _map;

    };

    }

  private:

  };

  namespace _maps_bits {

    };

  }

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

  ///

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

  /// in balanced binary tree. The values of the map can be accessed

  /// with stl compatible forward iterator.

  ///

  /// the subscription operator.

  ///

  ///

  class IterableValueMap

  public:

    /// The key type

    /// The value type

    /// The graph type

    typedef GR Graph;

  public:

    ///

    explicit IterableValueMap(const Graph& graph,

                              const Value& value = Value())

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

        lace(it);

      }

      typename std::map<Value, Key>::iterator it = _first.find(node.value);

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

        node.prev = node.next = INVALID;

        _first.insert(std::make_pair(node.value, key));

      } else {

        node.prev = INVALID;

    ///

    /// This iterator is an stl compatible forward

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

    class ValueIterator

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

      friend class IterableValueMap;

    ///

    /// Returns an stl compatible iterator to the

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

    /// range.

    ValueIterator beginValue() const {

      return ValueIterator(_first.begin());

    ///

    /// Returns an stl compatible iterator after the

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

    /// range.

    ValueIterator endValue() const {

      return ValueIterator(_first.end());

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

    ///

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

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

    /// \c INVALID.

    public:

      /// \brief Invalid constructor \& conversion.

      ///

      /// \sa Invalid for more details.

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

#include <lemon/concept_check.h>

#include <lemon/concepts/maps.h>

#include <lemon/maps.h>

#include "test_tools.h"

    typedef SmartGraph::Node Item;

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

    const int num = 10;

    Graph g;

    typedef SmartGraph::Node Item;

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

    const int num = 10;

    Graph g;

    int n = 0;

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

      ++n;

    }

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

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

      ++n;

    }

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

    int n = 0;

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

      ++n;

    }

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

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

      ++n;

    }

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