lemon-main: comparison lemon/maps.h

equal deleted inserted replaced

-:a57b20ae1999
+:9c531ecc48f9
 ///
 /// \tparam GR The graph type.
 /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
 /// \c GR::Edge).
 ///
-/// \see DescriptorMap
+/// \see RangeIdMap
 template <typename GR, typename K>
 class IdMap : public MapBase<K, int> {
 public:
 /// The graph type of IdMap.
 typedef GR Graph;
 /// Gives back the inverse of the IdMap.
 InverseMap inverse() const { return InverseMap(*_graph);}
 };
-/// \brief General invertable graph map type.
+/// \brief General cross reference graph map type.
 /// This class provides simple invertable graph maps.
 /// It wraps an arbitrary \ref concepts::ReadWriteMap "ReadWriteMap"
 /// and if a key is set to a new value then store it
 /// in the inverse map.
 /// \c GR::Edge).
 /// \tparam V The value type of the map.
 ///
 /// \see IterableValueMap
 template <typename GR, typename K, typename V>
-class InvertableMap
+class CrossRefMap
 : protected ItemSetTraits<GR, K>::template Map<V>::Type {
 private:
 typedef typename ItemSetTraits<GR, K>::
 template Map<V>::Type Map;
 typedef std::map<V, K> Container;
 Container _inv_map;
 public:
-/// The graph type of InvertableMap.
+/// The graph type of CrossRefMap.
 typedef GR Graph;
-/// The key type of InvertableMap (\c Node, \c Arc or \c Edge).
+/// The key type of CrossRefMap (\c Node, \c Arc or \c Edge).
 typedef K Item;
-/// The key type of InvertableMap (\c Node, \c Arc or \c Edge).
+/// The key type of CrossRefMap (\c Node, \c Arc or \c Edge).
 typedef K Key;
-/// The value type of InvertableMap.
+/// The value type of CrossRefMap.
 typedef V Value;
 /// \brief Constructor.
 ///
-/// Construct a new InvertableMap for the given graph.
+/// Construct a new CrossRefMap for the given graph.
-explicit InvertableMap(const Graph& graph) : Map(graph) {}
+explicit CrossRefMap(const Graph& graph) : Map(graph) {}
 /// \brief Forward iterator for values.
 ///
 /// This iterator is an stl compatible forward
 /// iterator on the values of the map. The values can
 /// be accessed in the <tt>[beginValue, endValue)</tt> range.
 class ValueIterator
 : public std::iterator<std::forward_iterator_tag, Value> {
-friend class InvertableMap;
+friend class CrossRefMap;
 private:
 ValueIterator(typename Container::const_iterator _it)
 : it(_it) {}
 public:
 class InverseMap {
 public:
 /// \brief Constructor
 ///
 /// Constructor of the InverseMap.
-explicit InverseMap(const InvertableMap& inverted)
+explicit InverseMap(const CrossRefMap& inverted)
 : _inverted(inverted) {}
 /// The value type of the InverseMap.
-typedef typename InvertableMap::Key Value;
+typedef typename CrossRefMap::Key Value;
 /// The key type of the InverseMap.
-typedef typename InvertableMap::Value Key;
+typedef typename CrossRefMap::Value Key;
 /// \brief Subscript operator.
 ///
 /// Subscript operator. It gives back the item
 /// that was last assigned to the given value.
 Value operator[](const Key& key) const {
 return _inverted(key);
 }
 private:
-const InvertableMap& _inverted;
+const CrossRefMap& _inverted;
 };
 /// \brief It gives back the read-only inverse map.
 ///
 /// It gives back the read-only inverse map.
 return InverseMap(*this);
 }
 };
-/// \brief Provides a mutable, continuous and unique descriptor for each
+/// \brief Provides continuous and unique ID for the
-/// item in a graph.
+/// items of a graph.
 ///
-/// DescriptorMap provides a unique and continuous (but mutable)
+/// RangeIdMap provides a unique and continuous
-/// descriptor (id) for each item of the same type (\c Node, \c Arc or
+/// ID for each item of a given type (\c Node, \c Arc or
 /// \c Edge) in a graph. This id is
 ///  - \b unique: different items get different ids,
 ///  - \b continuous: the range of the ids is the set of integers
 ///    between 0 and \c n-1, where \c n is the number of the items of
-///    this type (\c Node, \c Arc or \c Edge). So the id of an item can
+///    this type (\c Node, \c Arc or \c Edge).
-///    change if you delete an other item of the same type, i.e. this
+///  - So, the ids can change when deleting an item of the same type.
-///    id is mutable.
 ///
 /// Thus this id is not (necessarily) the same as what can get using
 /// the \c id() function of the graph or \ref IdMap.
 /// This map can be inverted with its member class \c InverseMap,
 /// or with the \c operator() member.
 /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
 /// \c GR::Edge).
 ///
 /// \see IdMap
 template <typename GR, typename K>
-class DescriptorMap
+class RangeIdMap
 : protected ItemSetTraits<GR, K>::template Map<int>::Type {
 typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Map;
 public:
-/// The graph type of DescriptorMap.
+/// The graph type of RangeIdMap.
 typedef GR Graph;
-/// The key type of DescriptorMap (\c Node, \c Arc or \c Edge).
+/// The key type of RangeIdMap (\c Node, \c Arc or \c Edge).
 typedef K Item;
-/// The key type of DescriptorMap (\c Node, \c Arc or \c Edge).
+/// The key type of RangeIdMap (\c Node, \c Arc or \c Edge).
 typedef K Key;
-/// The value type of DescriptorMap.
+/// The value type of RangeIdMap.
 typedef int Value;
 /// \brief Constructor.
 ///
-/// Constructor for descriptor map.
+/// Constructor.
-explicit DescriptorMap(const Graph& gr) : Map(gr) {
+explicit RangeIdMap(const Graph& gr) : Map(gr) {
 Item it;
 const typename Map::Notifier* nf = Map::notifier();
 for (nf->first(it); it != INVALID; nf->next(it)) {
 Map::set(it, _inv_map.size());
 _inv_map.push_back(it);
 _inv_map[qi] = p;
 Map::set(q, pi);
 _inv_map[pi] = q;
 }
-/// \brief Gives back the \e descriptor of the item.
+/// \brief Gives back the \e RangeId of the item
 ///
-/// Gives back the mutable and unique \e descriptor of the map.
+/// Gives back the \e RangeId of the item.
 int operator[](const Item& item) const {
 return Map::operator[](item);
 }
-/// \brief Gives back the item by its descriptor.
+/// \brief Gives back the item belonging to a \e RangeId
 ///
-/// Gives back th item by its descriptor.
+/// Gives back the item belonging to a \e RangeId.
 Item operator()(int id) const {
 return _inv_map[id];
 }
 private:
 typedef std::vector<Item> Container;
 Container _inv_map;
 public:
-/// \brief The inverse map type of DescriptorMap.
+/// \brief The inverse map type of RangeIdMap.
 ///
-/// The inverse map type of DescriptorMap.
+/// The inverse map type of RangeIdMap.
 class InverseMap {
 public:
 /// \brief Constructor
 ///
 /// Constructor of the InverseMap.
-explicit InverseMap(const DescriptorMap& inverted)
+explicit InverseMap(const RangeIdMap& inverted)
 : _inverted(inverted) {}
 /// The value type of the InverseMap.
-typedef typename DescriptorMap::Key Value;
+typedef typename RangeIdMap::Key Value;
 /// The key type of the InverseMap.
-typedef typename DescriptorMap::Value Key;
+typedef typename RangeIdMap::Value Key;
 /// \brief Subscript operator.
 ///
 /// Subscript operator. It gives back the item
 /// that the descriptor currently belongs to.
 unsigned int size() const {
 return _inverted.size();
 }
 private:
-const DescriptorMap& _inverted;
+const RangeIdMap& _inverted;
 };
 /// \brief Gives back the inverse of the map.
 ///
 /// Gives back the inverse of the map.

changeset 579	d11bf7998905
parent 559	c5fd2d996909
child 584	33c6b6e755cd