Context Navigation

Back to Ticket #160

Ticket #160: 66969f54d61d.patch

File 66969f54d61d.patch, 8.7 KB (added by Alpar Juttner, 15 years ago)

lemon/maps.h

# HG changeset patch
# User Alpar Juttner <alpar@cs.elte.hu>
# Date 1238826658 -3600
# Node ID 66969f54d61de7c2024d58358135912901540862
# Parent  eda12d8ac95313c837f493e8fd2ca49adc49de26
DescriptorMap->RangeIdMap, InvertableMap->CrossRefMap (#160)

diff --git a/lemon/maps.h b/lemon/maps.h

-                      a
   /// \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:
 …
   };
   /// \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"
 …
   ///
   /// \see IterableValueMap
   template <typename GR, typename K, typename V>
   class InvertableMap
+  class CrossRefMap
     : protected ItemSetTraits<GR, K>::template Map<V>::Type {
   private:
 …
   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.
     explicit InvertableMap(const Graph& graph) : Map(graph) {}
+    /// Construct a new CrossRefMap for the given graph.
+    explicit CrossRefMap(const Graph& graph) : Map(graph) {}
     /// \brief Forward iterator for values.
     ///
 …
     /// 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) {}
 …
       /// \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.
       ///
 …
+      }
     private:
       const InvertableMap& _inverted;
+      const CrossRefMap& _inverted;
     };
     /// \brief It gives back the read-only inverse map.
 …
   };
   /// \brief Provides a mutable, continuous and unique descriptor for each
   /// item in a graph.
+  /// \brief Provides continuous and unique ID for the
+  /// items of a graph.
   ///
   /// DescriptorMap provides a unique and continuous (but mutable)
   /// descriptor (id) for each item of the same type (\c Node, \c Arc or
+  /// RangeIdMap provides a unique and continuous
+  /// 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
+  ///    change if you delete an other item of the same type, i.e. this
+  ///    id is mutable.
+  ///    this type (\c Node, \c Arc or \c Edge).
+  ///  - So, the ids will can change when you deleting an item of the same type.
   ///
   /// Thus this id is not (necessarily) the same as what can get using
   /// the \c id() function of the graph or \ref IdMap.
 …
   ///
   /// \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.
     explicit DescriptorMap(const Graph& gr) : Map(gr) {
+    /// Constructor.
+    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)) {
 …
       _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.
     ///
     /// Gives back th item by its descriptor.
+    /// \brief Gives back the item belonging to a RangeId
+    ///
+    /// Gives back the item belonging to a RangeId.
     Item operator()(int id) const {
       return _inv_map[id];
+    }
 …
   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.
       ///
 …
+      }
     private:
       const DescriptorMap& _inverted;
+      const RangeIdMap& _inverted;
     };
     /// \brief Gives back the inverse of the map.

test/graph_utils_test.cc

diff --git a/test/graph_utils_test.cc b/test/graph_utils_test.cc

-                      a
     for (int i = 0; i < 10; ++i) {
       digraph.addNode();
+    }
     DescriptorMap<Digraph, Node> nodes(digraph);
     typename DescriptorMap<Digraph, Node>::InverseMap invNodes(nodes);
+    RangeIdMap<Digraph, Node> nodes(digraph);
+    typename RangeIdMap<Digraph, Node>::InverseMap invNodes(nodes);
     for (int i = 0; i < 100; ++i) {
       int src = rnd[invNodes.size()];
       int trg = rnd[invNodes.size()];
       digraph.addArc(invNodes[src], invNodes[trg]);
+    }
     typename Digraph::template ArcMap<bool> found(digraph, false);
     DescriptorMap<Digraph, Arc> arcs(digraph);
+    RangeIdMap<Digraph, Arc> arcs(digraph);
     for (NodeIt src(digraph); src != INVALID; ++src) {
       for (NodeIt trg(digraph); trg != INVALID; ++trg) {
         for (ConArcIt<Digraph> con(digraph, src, trg); con != INVALID; ++con) {
 …
   for (int i = 0; i < 10; ++i) {
     graph.addNode();
+  }
   DescriptorMap<Graph, Node> nodes(graph);
   typename DescriptorMap<Graph, Node>::InverseMap invNodes(nodes);
+  RangeIdMap<Graph, Node> nodes(graph);
+  typename RangeIdMap<Graph, Node>::InverseMap invNodes(nodes);
   for (int i = 0; i < 100; ++i) {
     int src = rnd[invNodes.size()];
     int trg = rnd[invNodes.size()];
     graph.addEdge(invNodes[src], invNodes[trg]);
+  }
   typename Graph::template EdgeMap<int> found(graph, 0);
   DescriptorMap<Graph, Edge> edges(graph);
+  RangeIdMap<Graph, Edge> edges(graph);
   for (NodeIt src(graph); src != INVALID; ++src) {
     for (NodeIt trg(graph); trg != INVALID; ++trg) {
       for (ConEdgeIt<Graph> con(graph, src, trg); con != INVALID; ++con) {

Download in other formats:

Original Format