RhodeCode

    };

    template <typename Out>

    struct SequenceOutputIndicator<Out, 

      typename exists<typename Out::value_type>::type> {

      static const bool value = true;

    };

    template <typename Out, typename Enable = void>

    struct MapOutputIndicator {

      static const bool value = false;

    };

    template <typename Out>

    struct MapOutputIndicator<Out, 

      typename exists<typename Out::Value>::type> {

      static const bool value = true;

    };

    template <typename In, typename InEnable = void>

    struct KruskalValueSelector {};

    template <typename In>

    struct KruskalValueSelector<In,

      typename enable_if<SequenceInputIndicator<In>, void>::type> 

    {

      typedef typename In::value_type::second_type Value;

    };    

    template <typename In>

    struct KruskalValueSelector<In,

      typename enable_if<MapInputIndicator<In>, void>::type> 

    {

      typedef typename In::Value Value;

    };    

    template <typename Graph, typename In, typename Out,

              typename InEnable = void>

    struct KruskalInputSelector {};

    template <typename Graph, typename In, typename Out,

              typename InEnable = void>

    struct KruskalOutputSelector {};

    template <typename Graph, typename In, typename Out>

    struct KruskalInputSelector<Graph, In, Out,

      typename enable_if<SequenceInputIndicator<In>, void>::type > 

    {

      typedef typename In::value_type::second_type Value;

      static Value kruskal(const Graph& graph, const In& in, Out& out) {

        return KruskalOutputSelector<Graph, In, Out>::

          kruskal(graph, in, out);

      }

    };

    template <typename Graph, typename In, typename Out>

    struct KruskalInputSelector<Graph, In, Out,

      typename enable_if<MapInputIndicator<In>, void>::type > 

    {

      typedef typename In::Value Value;

      static Value kruskal(const Graph& graph, const In& in, Out& out) {

        typedef typename In::Key MapArc;

        typedef typename In::Value Value;

        typedef typename ItemSetTraits<Graph, MapArc>::ItemIt MapArcIt;

        typedef std::vector<std::pair<MapArc, Value> > Sequence;

        Sequence seq;

        for (MapArcIt it(graph); it != INVALID; ++it) {

          seq.push_back(std::make_pair(it, in[it]));

        }

        std::sort(seq.begin(), seq.end(), PairComp<Sequence>());

        return KruskalOutputSelector<Graph, Sequence, Out>::

          kruskal(graph, seq, out);

      }

    };

    template <typename T>

    struct RemoveConst {

      typedef T type;

    };

    template <typename T>

    struct RemoveConst<const T> {

      typedef T type;

    };

    template <typename Graph, typename In, typename Out>

    struct KruskalOutputSelector<Graph, In, Out,

      typename enable_if<SequenceOutputIndicator<Out>, void>::type > 

    {

      typedef typename In::value_type::second_type Value;

      static Value kruskal(const Graph& graph, const In& in, Out& out) {

        Map map(out);

        return _kruskal_bits::kruskal(graph, in, map);

      }

    };

    template <typename Graph, typename In, typename Out>

    struct KruskalOutputSelector<Graph, In, Out,

      typename enable_if<MapOutputIndicator<Out>, void>::type > 

    {

      typedef typename In::value_type::second_type Value;

      static Value kruskal(const Graph& graph, const In& in, Out& out) {

        return _kruskal_bits::kruskal(graph, in, out);

      }

    };

  }

  /// \ingroup spantree

  ///

  /// \brief Kruskal's algorithm to find a minimum cost tree of a graph.

  ///

  /// This function runs Kruskal's algorithm to find a minimum cost tree.

  /// Due to some C++ hacking, it accepts various input and output types.

  ///

  /// \param g The graph the algorithm runs on.

  /// It can be either \ref concepts::Digraph "directed" or 

  /// \ref concepts::Graph "undirected".

  /// If the graph is directed, the algorithm consider it to be 

  /// undirected by disregarding the direction of the arcs.

  ///

  /// \param in This object is used to describe the arc costs. It can be one

  /// of the following choices.

  /// - An STL compatible 'Forward Container' with

  /// <tt>std::pair<GR::Edge,X></tt> or

  /// <tt>std::pair<GR::Arc,X></tt> as its <tt>value_type</tt>, where

  /// \c X is the type of the costs. The pairs indicates the arcs

  /// along with the assigned cost. <em>They must be in a

  /// cost-ascending order.</em>

  /// - Any readable Arc map. The values of the map indicate the arc costs.

  ///

  /// \retval out Here we also have a choise.

  /// - It can be a writable \c bool arc map.  After running the

  /// algorithm this will contain the found minimum cost spanning

  /// tree: the value of an arc will be set to \c true if it belongs

  /// to the tree, otherwise it will be set to \c false. The value of

  /// each arc will be set exactly once.

  /// - It can also be an iteraror of an STL Container with

  /// <tt>GR::Edge</tt> or <tt>GR::Arc</tt> as its

  /// <tt>value_type</tt>.  The algorithm copies the elements of the

  /// found tree into this sequence.  For example, if we know that the

  /// spanning tree of the graph \c g has say 53 arcs, then we can

  /// put its arcs into an STL vector \c tree with a code like this.

  ///\code

  /// std::vector<Arc> tree(53);

  /// kruskal(g,cost,tree.begin());

  ///\endcode

  /// Or if we don't know in advance the size of the tree, we can

  /// write this.  

  ///\code std::vector<Arc> tree;

  /// kruskal(g,cost,std::back_inserter(tree)); 

  ///\endcode

  ///

  /// \return The total cost of the found tree.

  ///

  /// \warning If kruskal runs on an be consistent of using the same

  /// Arc type for input and output.

  ///

#ifdef DOXYGEN

  template <class Graph, class In, class Out>

  Value kruskal(GR const& g, const In& in, Out& out)

#else 

  template <class Graph, class In, class Out>

  inline typename _kruskal_bits::KruskalValueSelector<In>::Value 

  kruskal(const Graph& graph, const In& in, Out& out) 

#endif

  {

    return _kruskal_bits::KruskalInputSelector<Graph, In, Out>::

      kruskal(graph, in, out);

  }

  template <class Graph, class In, class Out>

  inline typename _kruskal_bits::KruskalValueSelector<In>::Value

  kruskal(const Graph& graph, const In& in, const Out& out)

  {

    return _kruskal_bits::KruskalInputSelector<Graph, In, const Out>::

      kruskal(graph, in, out);

  }  

} //namespace lemon

    /// Constructor

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

    /// \e

    Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }

  };

  /// Returns an \ref EqualMap class

  /// This function just returns an \ref EqualMap class.

  ///

  /// For example, if \c m1 and \c m2 are maps with keys and values of

  /// the same type, then <tt>equalMap(m1,m2)[x]</tt> will be equal to

  /// <tt>m1[x]==m2[x]</tt>.

  ///

  /// \relates EqualMap

  template<typename M1, typename M2>

  inline EqualMap<M1, M2> equalMap(const M1 &m1, const M2 &m2) {

    return EqualMap<M1, M2>(m1,m2);

  }

  /// Combination of two maps using the \c < operator

  /// This \ref concepts::ReadMap "read-only map" assigns \c true to

  /// the keys for which the corresponding value of the first map is

  /// less then the value of the second map.

  /// Its \c Key type is inherited from \c M1 and its \c Value type is

  /// \c bool. \c M2::Key must be convertible to \c M1::Key.

  ///

  /// If \c m1 is of type \c M1 and \c m2 is of \c M2, then for

  /// \code

  ///   LessMap<M1,M2> lm(m1,m2);

  /// \endcode

  /// <tt>lm[x]</tt> will be equal to <tt>m1[x]<m2[x]</tt>.

  ///

  /// The simplest way of using this map is through the lessMap()

  /// function.

  ///

  /// \sa EqualMap

  template<typename M1, typename M2>

  class LessMap : public MapBase<typename M1::Key, bool> {

    const M1 &_m1;

    const M2 &_m2;

  public:

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

    typedef typename Parent::Key Key;

    typedef typename Parent::Value Value;

    /// Constructor

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

    /// \e

    Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }

  };

  /// Returns an \ref LessMap class

  /// This function just returns an \ref LessMap class.

  ///

  /// For example, if \c m1 and \c m2 are maps with keys and values of

  /// the same type, then <tt>lessMap(m1,m2)[x]</tt> will be equal to

  /// <tt>m1[x]<m2[x]</tt>.

  ///

  /// \relates LessMap

  template<typename M1, typename M2>

  inline LessMap<M1, M2> lessMap(const M1 &m1, const M2 &m2) {

    return LessMap<M1, M2>(m1,m2);

  }

  namespace _maps_bits {

    template <typename _Iterator, typename Enable = void>

    struct IteratorTraits {

      typedef typename std::iterator_traits<_Iterator>::value_type Value;

    };

    template <typename _Iterator>

    struct IteratorTraits<_Iterator,

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

    {

      typedef typename _Iterator::container_type::value_type Value;

    };

  }

  /// \brief Writable bool map for logging each \c true assigned element

  ///

  /// A \ref concepts::WriteMap "writable" bool map for logging

  /// each \c true assigned element, i.e it copies subsequently each

  /// keys set to \c true to the given iterator.

  /// The most important usage of it is storing certain nodes or arcs

  /// that were marked \c true by an algorithm.

  ///

  /// There are several algorithms that provide solutions through bool

  /// maps and most of them assign \c true at most once for each key.

  /// In these cases it is a natural request to store each \c true

  /// assigned elements (in order of the assignment), which can be

  ///

  /// function.

  ///

  /// \tparam It The type of the iterator.

  /// \tparam Ke The key type of the map. The default value set

  /// according to the iterator type should work in most cases.

  ///

  /// \note The container of the iterator must contain enough space

  /// for the elements or the iterator should be an inserter iterator.

#ifdef DOXYGEN

  template <typename It, typename Ke>

#else

  template <typename It,

	    typename Ke=typename _maps_bits::IteratorTraits<It>::Value>

#endif

  public:

    typedef It Iterator;

    typedef Ke Key;

    typedef bool Value;

    /// Constructor

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

    /// Gives back the given iterator set for the first key

    Iterator begin() const {

      return _begin;

    }

    /// Gives back the the 'after the last' iterator

    Iterator end() const {

      return _end;

    }

    /// The set function of the map

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

      if (value) {

	*_end++ = key;

      }

    }

  private:

    Iterator _begin;

    Iterator _end;

  };

  ///

  /// The most important usage of it is storing certain nodes or arcs

  /// that were marked \c true by an algorithm.

  /// For example it makes easier to store the nodes in the processing

  /// order of Dfs algorithm, as the following examples show.

  /// \code

  ///   std::vector<Node> v;

  /// \endcode

  /// \code

  ///   std::vector<Node> v(countNodes(g));

  /// \endcode

  ///

  /// \note The container of the iterator must contain enough space

  /// for the elements or the iterator should be an inserter iterator.

  ///

  /// it cannot be used when a readable map is needed, for example as

  ///

  template<typename Iterator>

  }

  /// @}

}

#endif // LEMON_MAPS_H

  }

  // ForkMap

  {

    checkConcept<DoubleWriteMap, ForkMap<DoubleWriteMap, DoubleWriteMap> >();

    typedef RangeMap<double> RM;

    typedef SparseMap<int, double> SM;

    RM m1(10, -1);

    SM m2(-1);

    checkConcept<ReadWriteMap<int, double>, ForkMap<RM, SM> >();

    checkConcept<ReadWriteMap<int, double>, ForkMap<SM, RM> >();

    ForkMap<RM, SM> map1(m1,m2);

    ForkMap<SM, RM> map2 = forkMap(m2,m1);

    map2.set(5, 10);

    check(m1[1] == -1 && m1[5] == 10 && m2[1] == -1 && m2[5] == 10 && map2[1] == -1 && map2[5] == 10,

          "Something is wrong with ForkMap");

  }

  // Arithmetic maps:

  // - AddMap, SubMap, MulMap, DivMap

  // - ShiftMap, ShiftWriteMap, ScaleMap, ScaleWriteMap

  // - NegMap, NegWriteMap, AbsMap

  {

    checkConcept<DoubleMap, AddMap<DoubleMap,DoubleMap> >();

    checkConcept<DoubleMap, SubMap<DoubleMap,DoubleMap> >();

    checkConcept<DoubleMap, MulMap<DoubleMap,DoubleMap> >();

    checkConcept<DoubleMap, DivMap<DoubleMap,DoubleMap> >();

    ConstMap<int, double> c1(1.0), c2(3.14);

    IdentityMap<int> im;

    ConvertMap<IdentityMap<int>, double> id(im);

    check(addMap(c1,id)[0] == 1.0  && addMap(c1,id)[10] == 11.0, "Something is wrong with AddMap");

    check(subMap(id,c1)[0] == -1.0 && subMap(id,c1)[10] == 9.0,  "Something is wrong with SubMap");

    check(mulMap(id,c2)[0] == 0    && mulMap(id,c2)[2]  == 6.28, "Something is wrong with MulMap");

    check(divMap(c2,id)[1] == 3.14 && divMap(c2,id)[2]  == 1.57, "Something is wrong with DivMap");

    checkConcept<DoubleMap, ShiftMap<DoubleMap> >();

    checkConcept<DoubleWriteMap, ShiftWriteMap<DoubleWriteMap> >();

    checkConcept<DoubleMap, ScaleMap<DoubleMap> >();

    checkConcept<DoubleWriteMap, ScaleWriteMap<DoubleWriteMap> >();

    checkConcept<DoubleMap, NegMap<DoubleMap> >();

    checkConcept<DoubleWriteMap, NegWriteMap<DoubleWriteMap> >();

    checkConcept<DoubleMap, AbsMap<DoubleMap> >();

    check(shiftMap(id, 2.0)[1] == 3.0 && shiftMap(id, 2.0)[10] == 12.0,

          "Something is wrong with ShiftMap");

    check(shiftWriteMap(id, 2.0)[1] == 3.0 && shiftWriteMap(id, 2.0)[10] == 12.0,

          "Something is wrong with ShiftWriteMap");

    check(scaleMap(id, 2.0)[1] == 2.0 && scaleMap(id, 2.0)[10] == 20.0,

          "Something is wrong with ScaleMap");

    check(scaleWriteMap(id, 2.0)[1] == 2.0 && scaleWriteMap(id, 2.0)[10] == 20.0,

          "Something is wrong with ScaleWriteMap");

    check(negMap(id)[1] == -1.0 && negMap(id)[-10] == 10.0,

          "Something is wrong with NegMap");

    check(negWriteMap(id)[1] == -1.0 && negWriteMap(id)[-10] == 10.0,

          "Something is wrong with NegWriteMap");

    check(absMap(id)[1] == 1.0 && absMap(id)[-10] == 10.0,

          "Something is wrong with AbsMap");

  }

  // Logical maps:

  // - TrueMap, FalseMap

  // - AndMap, OrMap

  // - NotMap, NotWriteMap

  // - EqualMap, LessMap

  {

    checkConcept<BoolMap, TrueMap<A> >();

    checkConcept<BoolMap, FalseMap<A> >();

    checkConcept<BoolMap, AndMap<BoolMap,BoolMap> >();

    checkConcept<BoolMap, OrMap<BoolMap,BoolMap> >();

    checkConcept<BoolMap, NotMap<BoolMap> >();

    checkConcept<BoolWriteMap, NotWriteMap<BoolWriteMap> >();

    checkConcept<BoolMap, EqualMap<DoubleMap,DoubleMap> >();

    checkConcept<BoolMap, LessMap<DoubleMap,DoubleMap> >();

    TrueMap<int> tm;

    FalseMap<int> fm;

    RangeMap<bool> rm(2);

    rm[0] = true; rm[1] = false;

    check(andMap(tm,rm)[0] && !andMap(tm,rm)[1] && !andMap(fm,rm)[0] && !andMap(fm,rm)[1],

          "Something is wrong with AndMap");

    check(orMap(tm,rm)[0] && orMap(tm,rm)[1] && orMap(fm,rm)[0] && !orMap(fm,rm)[1],

          "Something is wrong with OrMap");

    check(!notMap(rm)[0] && notMap(rm)[1], "Something is wrong with NotMap");

    check(!notWriteMap(rm)[0] && notWriteMap(rm)[1], "Something is wrong with NotWriteMap");

    ConstMap<int, double> cm(2.0);

    IdentityMap<int> im;

    ConvertMap<IdentityMap<int>, double> id(im);

    check(lessMap(id,cm)[1] && !lessMap(id,cm)[2] && !lessMap(id,cm)[3],

          "Something is wrong with LessMap");

    check(!equalMap(id,cm)[1] && equalMap(id,cm)[2] && !equalMap(id,cm)[3],

          "Something is wrong with EqualMap");

  }

  {

    typedef std::vector<int> vec;

    vec v1;

    vec v2(10);

    map1.set(10, false);

    map1.set(20, true);   map2.set(20, true);

    map1.set(30, false);  map2.set(40, false);

    map1.set(50, true);   map2.set(50, true);

    map1.set(60, true);   map2.set(60, true);

    check(v1.size() == 3 && v2.size() == 10 &&

          v1[0]==20 && v1[1]==50 && v1[2]==60 && v2[0]==20 && v2[1]==50 && v2[2]==60,

    int i = 0;

          it != map2.end(); ++it )

  }

  return 0;

}