RhodeCode

 *

 */

// (C) Copyright Jeremy Siek 2000.

// Distributed under the Boost Software License, Version 1.0. (See

// accompanying file LICENSE_1_0.txt or copy at

  /// are stored in a \c std::vector<T>  container. It can be used with

  /// some data structures, for example \c UnionFind, \c BinHeap, when 

  /// the used items are small integer numbers.

  template <typename T>

  class IntegerMap {

  }

  ///This \c concepts::ReadMap "read only map"

  ///converts the \c Value of a maps to type \c T.

  ///Its \c Key is inherited from \c M.

    /// \brief The subscript operator.

    ///

    /// The subscript operator.

    Value operator[](const Key& k) const {return m[k];}

  };

  ///wrapping of the given map. Sometimes the reference maps cannot be

  ///combined with simple read maps. This map adaptor wraps the given

  ///map to simple read map.

  template<typename M> 

  class SimpleMap : public MapBase<typename M::Key, typename M::Value> {

    const M& m;

  ///Simple writeable wrapping of the map

  ///wrapping of the given map. Sometimes the reference maps cannot be

  ///combined with simple read-write maps. This map adaptor wraps the

  ///given map to simple read-write map.

  template<typename M> 

  class SimpleWriteMap : public MapBase<typename M::Key, typename M::Value> {

    M& m;

    Value operator[](Key k) const {return m[k] + v;}

  };

  ///This \c concepts::ReadWriteMap "read-write map" returns the sum of the

  ///given map and a constant value. It makes also possible to write the map.

  ///of the values of the two

  ///given maps. Its \c Key and \c Value will be inherited from \c M1.

  ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.

  template<typename M1, typename M2> 

  class SubMap : public MapBase<typename M1::Key, typename M1::Value> {

    const M1& m1;

    Value operator[](Key k) const {return v * m[k];}

  };

  ///This \c concepts::ReadWriteMap "read-write map" returns the value of the

  ///given map multiplied from the left side with a constant value. It can

    Value operator[](Key k) const {return -m[k];}

  };

  ///This \c concepts::ReadWriteMap "read-write map" returns the negative

  ///value of the value returned by the

  ///must be comparable to <tt>0</tt> and the unary <tt>-</tt>

  ///operator must be defined for it, of course.

  ///

  template<typename M> 

  class AbsMap : public MapBase<typename M::Key, typename M::Value> {

  ///

  ///The \c Key and \c Value will be inherited from \c M1.

  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.

  template<typename  M1, typename M2> 

  class ForkMap : public MapBase<typename M1::Key, typename M1::Value> {

    const M1& m1;

    Value operator[](Key k) const {return !m[k];}

  };

  ///This bool \c concepts::ReadWriteMap "read-write map" returns the 

  ///logical negation of value returned by the given map. When it is set,

  }

  ///

  /// copies all the keys set to true to the given iterator.

  ///

  /// \note The container of the iterator should contain space 

  /// for each element.

  ///

  /// to the standard output.

  ///\code

  /// typedef IdMap<Graph, Edge> EdgeIdMap;

  ///

  /// prim(graph, cost, writerMap);

  ///\endcode

  template <typename _Iterator, 

            typename _Functor =

            _maps_bits::Identity<typename _maps_bits::

    StoreBoolMap(Iterator it, const Functor& functor = Functor()) 

      : _begin(it), _end(it), _functor(functor) {}

    Iterator begin() const {

      return _begin;

    }

    Iterator end() const {

      return _end;

    }

    Functor _functor;

  };

  ///

  ///

  ///\code

  /// vector<Edge> span_tree_edges;

    Functor functor;

  };

  /// a front insertable container.

  ///

  /// insertable container. It will push front all the keys set to \c true into

  /// the container. For example see the BackInserterBoolMap.

  template <typename Container,

    Functor functor;

  };

  /// an insertable container.

  ///

  /// insertable container. It will insert all the keys set to \c true into

  /// connected components in a set you can use the next code:

  ///

  ///\code

  /// The value can set 

  /// the container.

  ///

  /// and stores it in the \c comp map:

  ///\code

  /// typedef Graph::NodeMap<int> ComponentMap;

      fill = _fill;

    } 

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

      if (value) {

	map.set(key, fill);

  };

  ///

  /// Writable bool map which stores for each true assigned elements  

  /// order of the nodes in the \c Dfs algorithm.

  ///

  ///\code

  /// }

  ///\endcode

  ///

  /// ReachedMap should be readable in the dfs algorithm but the setting

  ///

  ///\code

  /// typedef Digraph::NodeMap<int> OrderMap;