lemon-0.x: comparison lemon/maps.h

equal deleted inserted replaced

-:6d5e9d388843
+:fe91c7bf9ade
 };
 ///Logical 'not' of a map with writing possibility
 ///This bool \ref concept::ReadWriteMap "read-write map" returns the
-///logical negation of value returned by the given map. It is setted
+///logical negation of value returned by the given map. When it is set,
-///then the negation of the value be setted to the original map.
+///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;
 }
 /// \brief Writable bool map for store each true assigned elements.
 ///
-/// Writable bool map for store each true assigned elements. It will
+/// Writable bool map to store each true assigned elements. It will
-/// copies all the true setted keys to the given iterator.
+/// copies all the keys set to true to the given iterator.
 ///
 /// \note The container of the iterator should contain space
 /// for each element.
 ///
 /// The next example shows how can you write the nodes directly
 /// Constructor
 StoreBoolMap(Iterator it, const Functor& functor = Functor())
 : _begin(it), _end(it), _functor(functor) {}
-/// Gives back the given first setted iterator.
+/// Gives back the given iterator set for the first time.
 Iterator begin() const {
 return _begin;
 }
-/// Gives back the iterator after the last setted.
+/// Gives back the iterator after the last set operation.
 Iterator end() const {
 return _end;
 }
 /// Setter function of the map
 /// \brief Writable bool map for store each true assigned elements in
 /// a back insertable container.
 ///
 /// Writable bool map for store each true assigned elements in a back
-/// insertable container. It will push back all the true setted keys into
+/// insertable container. It will push back all the keys set to true into
 /// the container. It can be used to retrieve the items into a standard
 /// container. The next example shows how can you store the undirected
 /// edges in a vector with prim algorithm.
 ///
 ///\code
 /// \brief Writable bool map for store each true assigned elements in
 /// a front insertable container.
 ///
 /// Writable bool map for store each true assigned elements in a front
-/// insertable container. It will push front all the true setted keys into
+/// 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 {
 /// \brief Writable bool map for store each true assigned elements in
 /// an insertable container.
 ///
 /// Writable bool map for store each true assigned elements in an
-/// insertable container. It will insert all the true setted keys into
+/// insertable container. It will insert all the keys set to \c true into
 /// the container. If you want to store the cut edges of the strongly
 /// connected components in a set you can use the next code:
 ///
 ///\code
 /// set<Edge> cut_edges;
 Container& container;
 typename Container::iterator it;
 Functor functor;
 };
-/// \brief Fill the true setted elements with a given value.
+/// \brief Fill the true set elements with a given value.
 ///
-/// Writable bool map for fill the true setted elements with a given value.
+/// Writable bool map to fill the elements set to \c true with a given value.
-/// The value can be setted
+/// The value can set
 /// the container.
 ///
 /// The next code finds the connected components of the undirected graph
 /// and stores it in the \c comp map:
 ///\code
 /// Constructor
 SettingOrderBoolMap(Map& _map)
 : map(_map), counter(0) {}
-/// Number of setted keys.
+/// Number of set operations.
 int num() const {
 return counter;
 }
 /// Setter function of the map

changeset 2259	da142c310d02
parent 2248	1ac928089d68
child 2260	4274224f8a7d