RhodeCode

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

// (C) Copyright Jeremy Siek 2000.

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

// accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

//

// Revision History:

//   05 May   2001: Workarounds for HP aCC from Thomas Matelich. (Jeremy Siek)

//   02 April 2001: Removed limits header altogether. (Jeremy Siek)

//   01 April 2001: Modified to use new <boost/limits.hpp> header. (JMaddock)

//

// See http://www.boost.org/libs/concept_check for documentation.

    template <typename T1, typename C1 = std::less<T1> >

    struct rebind {

      typedef StdMap<Key, T1, C1> other;

    };

  };

  /// \brief Map for storing values for the range \c [0..size-1] range keys

  ///

  /// The current map has the \c [0..size-1] keyset and the values

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

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

  template <typename T>

  class IntegerMap {

    template <typename T1>

    friend class IntegerMap;

  public:

    typedef True ReferenceMapTag;

    ///\e

    typedef int Key;

    ///\e

  };

  ///Returns an \c IdentityMap class

  ///This function just returns an \c IdentityMap class.

  ///\relates IdentityMap

  template<typename T>

  inline IdentityMap<T> identityMap() {

    return IdentityMap<T>();

  }

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

  template <typename M, typename T> 

  class ConvertMap : public MapBase<typename M::Key, T> {

    const M& m;

  public:

    typedef MapBase<typename M::Key, T> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    ///Constructor

    ///\param _m is the underlying map

    ConvertMap(const M &_m) : m(_m) {};

    /// \brief The subscript operator.

    ///

    /// The subscript operator.

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

  };

  ///Returns an \c ConvertMap class

  ///This function just returns an \c ConvertMap class.

  ///\relates ConvertMap

  template<typename T, typename M>

  inline ConvertMap<M, T> convertMap(const M &m) {

    return ConvertMap<M, T>(m);

  }

  ///Simple wrapping of the map

  ///This \c concepts::ReadMap "read only map" returns the simple

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

  public:

    typedef MapBase<typename M::Key, typename M::Value> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    SimpleMap(const M &_m) : m(_m) {};

    ///\e

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

  };

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

  public:

    typedef MapBase<typename M::Key, typename M::Value> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    SimpleWriteMap(M &_m) : m(_m) {};

    ///\e

    typedef typename Parent::Value Value;

    ///Constructor

    ///Constructor

    ///\param _m is the undelying map

    ///\param _v is the shift value

    ShiftMap(const M &_m, const C &_v ) : m(_m), v(_v) {};

    ///\e

    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.

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

  ///

  ///Actually,

  ///\code

  ///  ShiftMap<X> sh(x,v);

  ///\endcode

  ///is equivalent with

  ///\code

  ///  ConstMap<X::Key, X::Value> c_tmp(v);

  template<typename M, typename C> 

  inline ShiftWriteMap<M, C> shiftMap(M &m,const C &v) {

    return ShiftWriteMap<M, C>(m,v);

  }

  ///Difference of two maps

  ///This \c concepts::ReadMap "read only map" returns the difference

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

    const M2& m2;

  public:

    typedef MapBase<typename M1::Key, typename M1::Value> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    SubMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};

    /// \e

    typedef typename Parent::Value Value;

    ///Constructor

    ///Constructor

    ///\param _m is the undelying map

    ///\param _v is the scaling value

    ScaleMap(const M &_m, const C &_v ) : m(_m), v(_v) {};

    /// \e

    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

  ///be used as write map also if the given multiplier is not zero.

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

  template<typename M, typename C = typename M::Value> 

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

    M& m;

    C v;

  public:

    typedef MapBase<typename M::Key, typename M::Value> Parent;

    typedef typename Parent::Key Key;

    const M& m;

  public:

    typedef MapBase<typename M::Key, typename M::Value> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    NegMap(const M &_m) : m(_m) {};

    /// \e

    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

  ///given map. Its \c Key and \c Value will be inherited from \c M.

  ///The unary \c - operator must be defined for \c Value, of course.

  template<typename M> 

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

    M& m;

  public:

    typedef MapBase<typename M::Key, typename M::Value> Parent;

    typedef typename Parent::Key Key;

  }

  ///Absolute value of a map

  ///This \c concepts::ReadMap "read only map" returns the absolute value

  ///of the

  ///value returned by the

  ///given map. Its \c Key and \c Value will be inherited

  ///from <tt>M</tt>. <tt>Value</tt>

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

    const M& m;

  public:

    typedef MapBase<typename M::Key, typename M::Value> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    AbsMap(const M &_m) : m(_m) {};

    /// \e

  inline MapFunctor<M> mapFunctor(const M &m) {

    return MapFunctor<M>(m);

  }

  ///Applies all map setting operations to two maps

  ///This map has two \c concepts::ReadMap "readable map"

  ///parameters and each read request will be passed just to the

  ///first map. This class is the just readable map type of the ForkWriteMap.

  ///

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

    const M2& m2;

  public:

    typedef MapBase<typename M1::Key, typename M1::Value> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    ///Constructor

    ForkMap(const M1 &_m1, const M2 &_m2) : m1(_m1), m2(_m2) {};

    /// \e

    const M& m;

  public:

    typedef MapBase<typename M::Key, bool> Parent;

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    /// Constructor

    NotMap(const M &_m) : m(_m) {};

    ///\e

    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,

  ///the opposite value is set to the original map.

  ///Its \c Key and will be inherited from \c M,

  ///its Value is <tt>bool</tt>.

  template <typename M> 

  class NotWriteMap : public MapBase<typename M::Key, bool> {

    M& m;

  public:

    typedef MapBase<typename M::Key, bool> Parent;

    typedef typename Parent::Key Key;

    };

    template <typename _Iterator>

    struct IteratorTraits<_Iterator,

      typename exists<typename _Iterator::container_type>::type> 

    {

      typedef typename _Iterator::container_type::value_type Value;

    };

  }

  ///

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

  /// EdgeIdMap edgeId(graph);

  ///

  /// typedef MapFunctor<EdgeIdMap> EdgeIdFunctor;

  /// EdgeIdFunctor edgeIdFunctor(edgeId);

  ///

  /// StoreBoolMap<ostream_iterator<int>, EdgeIdFunctor> 

  ///   writerMap(ostream_iterator<int>(cout, " "), edgeIdFunctor);

  ///

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

  ///\endcode

  template <typename _Iterator, 

            typename _Functor =

            _maps_bits::Identity<typename _maps_bits::

                                 IteratorTraits<_Iterator>::Value> >

  class StoreBoolMap {

  public:

    typedef _Iterator Iterator;

    typedef typename _Functor::argument_type Key;

    typedef bool Value;

    typedef _Functor Functor;

    /// Constructor

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

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

    Iterator begin() const {

      return _begin;

    }

    Iterator end() const {

      return _end;

    }

    /// Setter function of the map

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

      if (value) {

	*_end++ = _functor(key);

      }

    }

  private:

    Iterator _begin;

    mutable Iterator _end;

    Functor _functor;

  };

  ///

  ///

  ///\code

  /// vector<Edge> span_tree_edges;

  /// BackInserterBoolMap<vector<Edge> > inserter_map(span_tree_edges);

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

  ///\endcode

  template <typename Container,

            typename Functor =

            _maps_bits::Identity<typename Container::value_type> >

  class BackInserterBoolMap {

  public:

    typedef typename Container::value_type Key;

    /// Setter function of the map

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

      if (value) {

	container.push_back(functor(key));

      }

    }

  private:

    Container& container;

    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,

            typename Functor =

            _maps_bits::Identity<typename Container::value_type> >

  class FrontInserterBoolMap {

  public:

    typedef typename Container::value_type Key;

    typedef bool Value;

    /// Constructor

    FrontInserterBoolMap(Container& _container,

    /// Setter function of the map

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

      if (value) {

	container.push_front(key);

      }

    }

  private:

    Container& 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

  /// set<Arc> cut_arcs;

  /// InserterBoolMap<set<Arc> > inserter_map(cut_arcs);

  /// stronglyConnectedCutArcs(digraph, cost, inserter_map);

  ///\endcode

  template <typename Container,

            typename Functor =

            _maps_bits::Identity<typename Container::value_type> >

  class InserterBoolMap {

  public:

  private:

    Container& container;

    typename Container::iterator it;

    Functor functor;

  };

  /// \brief Fill the true set elements with a given value.

  ///

  /// Writable bool map to fill the elements set to \c true with a given value.

  /// The value can set 

  /// the container.

  ///

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

  ///\code

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

  /// ComponentMap comp(graph);

  /// typedef FillBoolMap<Graph::NodeMap<int> > ComponentFillerMap;

  /// ComponentFillerMap filler(comp, 0);

  ///

  /// Dfs<Graph>::DefProcessedMap<ComponentFillerMap>::Create dfs(graph);

  /// dfs.processedMap(filler);

  /// dfs.init();

  /// for (NodeIt it(graph); it != INVALID; ++it) {

  ///   if (!dfs.reached(it)) {

    } 

    /// Gives back the current fill value

    typename Map::Value& fillValue() {

      return fill;

    } 

    /// Sets the current fill value

    void fillValue(const typename Map::Value& _fill) {

      fill = _fill;

    } 

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

      if (value) {

	map.set(key, fill);

      }

    }

  private:

    Map& map;

    typename Map::Value fill;

  };

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

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

  ///

  ///\code

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

  /// OrderMap order(digraph);

  /// typedef SettingOrderBoolMap<OrderMap> OrderSetterMap;

  /// OrderSetterMap setter(order);

  /// Dfs<Digraph>::DefProcessedMap<OrderSetterMap>::Create dfs(digraph);

  /// dfs.processedMap(setter);

  /// dfs.init();

  /// for (NodeIt it(digraph); it != INVALID; ++it) {

  ///   if (!dfs.reached(it)) {

  ///     dfs.addSource(it);

  ///     dfs.start();

  ///   }

  /// }

  ///\endcode

  ///

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

  ///

  ///\code

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

  /// OrderMap order(digraph);

  /// typedef SettingOrderBoolMap<OrderMap> OrderSetterMap;

  /// OrderSetterMap setter(order);

  /// typedef Digraph::NodeMap<bool> StoreMap;

  /// StoreMap store(digraph);

  ///

  /// typedef ForkWriteMap<StoreMap, OrderSetterMap> ReachedMap;

  /// ReachedMap reached(store, setter);

  ///