RhodeCode

        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.

      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

    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;

}