RhodeCode

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

      }

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

  template <typename It,

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

#endif

  public:

    typedef It Iterator;

    typedef bool Value;

    /// Constructor

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

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

    Iterator _end;

  };

  ///

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

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

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

  }

  /// @}

          "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(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;