lemon-0.x: comparison src/lemon/array

equal deleted inserted replaced

-:94642a1bf8cc
+:80430ba62ad4
 */
 template <typename _Graph,
 	    typename _Item,
 	    typename _ItemIt,
-	    typename _IdMap,
 	    typename _Value>
 class ArrayMap : public AlterationObserverRegistry<_Item>::ObserverBase {
 public:
 typedef AlterationObserverRegistry<_Item> Registry;
 private:
 /// The iterator to iterate on the keys.
 typedef _ItemIt KeyIt;
-typedef _IdMap IdMap;
 typedef _Value Value;
 /// The MapBase of the Map which imlements the core regisitry function.
 typedef typename Registry::ObserverBase Parent;
 public:
 /** Graph and Registry initialized map constructor.
 */
-ArrayMap(const Graph& _g, Registry& _r) : graph(&_g) {
+ArrayMap(const Graph& _g) : graph(&_g) {
-attach(_r);
+attach(_g.getObserverRegistry(_Item()));
 allocate_memory();
 for (KeyIt it(*graph); it != INVALID; ++it) {
-	int id = IdMap(*graph)[it];
+	int id = graph->id(it);;
 	allocator.construct(&(values[id]), Value());
 }
 }
 /// Constructor to use default value to initialize the map.
 /// It constrates a map and initialize all of the the map.
-ArrayMap(const Graph& _g, Registry& _r, const Value& _v) : graph(&_g) {
+ArrayMap(const Graph& _g, const Value& _v) : graph(&_g) {
-attach(_r);
+attach(_g.getObserverRegistry(_Item()));
 allocate_memory();
 for (KeyIt it(*graph); it != INVALID; ++it) {
-	int id = IdMap(*graph)[it];
+	int id = graph->id(it);;
 	allocator.construct(&(values[id]), _v);
 }
 }
 /** Constructor to copy a map of the same map type.
 }
 capacity = copy.capacity;
 if (capacity == 0) return;
 values = allocator.allocate(capacity);
 for (KeyIt it(*graph); it != INVALID; ++it) {
-	int id = IdMap(*graph)[it];
+	int id = graph->id(it);;
 	allocator.construct(&(values[id]), copy.values[id]);
 }
 }
 using Parent::attach;
 	if (capacity == 0) return *this;
 	values = allocator.allocate(capacity);
 }
 for (KeyIt it(*graph); it != INVALID; ++it) {
-	int id = IdMap(*graph)[it];
+	int id = graph->id(it);;
 	allocator.construct(&(values[id]), copy.values[id]);
 }
 return *this;
 }
 /**
 * The subscript operator. The map can be subscripted by the
 * actual keys of the graph.
 */
 ReferenceType operator[](const KeyType& key) {
-int id = IdMap(*graph)[key];
+int id = graph->id(key);
 return values[id];
 }
 /**
 * The const subscript operator. The map can be subscripted by the
 * actual keys of the graph.
 */
 ConstReferenceType operator[](const KeyType& key) const {
-int id = IdMap(*graph)[key];
+int id = graph->id(key);
 return values[id];
 }
 /** Setter function of the map. Equivalent with map[key] = val.
 *  This is a compatibility feature with the not dereferable maps.
 }
 /** Add a new key to the map. It called by the map registry.
 */
 void add(const KeyType& key) {
-int id = IdMap(*graph)[key];
+int id = graph->id(key);
 if (id >= capacity) {
 	int new_capacity = (capacity == 0 ? 1 : capacity);
 	while (new_capacity <= id) {
 	  new_capacity <<= 1;
 	}
 	Value* new_values = allocator.allocate(new_capacity);
 	for (KeyIt it(*graph); it != INVALID; ++it) {
-	  int jd = IdMap(*graph)[it];
+	  int jd = graph->id(it);;
 	  if (id != jd) {
 	    allocator.construct(&(new_values[jd]), values[jd]);
 	    allocator.destroy(&(values[jd]));
 	  }
 	}
 }
 /** Erase a key from the map. It called by the map registry.
 */
 void erase(const KeyType& key) {
-int id = IdMap(*graph)[key];
+int id = graph->id(key);
 allocator.destroy(&(values[id]));
 }
 void build() {
 allocate_memory();
 for (KeyIt it(*graph); it != INVALID; ++it) {
-	int id = IdMap(*graph)[it];
+	int id = graph->id(it);;
 	allocator.construct(&(values[id]), Value());
 }
 }
 void clear() {
 if (capacity != 0) {
 	for (KeyIt it(*graph); it != INVALID; ++it) {
-	  int id = IdMap(*graph)[it];
+	  int id = graph->id(it);;
 	  allocator.destroy(&(values[id]));
 	}
 	allocator.deallocate(values, capacity);
 	capacity = 0;
 }
 //     }
 private:
 void allocate_memory() {
-int max_id = IdMap(*graph).maxId();
+int max_id = graph->maxId(_Item());
 if (max_id == -1) {
 	capacity = 0;
 	values = 0;
 	return;
 }
 typedef ArrayMappableGraphExtender<_Base> Graph;
 typedef _Base Parent;
 typedef typename Parent::Node Node;
 typedef typename Parent::NodeIt NodeIt;
-typedef typename Parent::NodeIdMap NodeIdMap;
 typedef typename Parent::NodeObserverRegistry NodeObserverRegistry;
 typedef typename Parent::Edge Edge;
 typedef typename Parent::EdgeIt EdgeIt;
-typedef typename Parent::EdgeIdMap EdgeIdMap;
 typedef typename Parent::EdgeObserverRegistry EdgeObserverRegistry;
 template <typename _Value>
-class NodeMap : public ArrayMap<Graph, Node, NodeIt, NodeIdMap, _Value> {
+class NodeMap : public ArrayMap<Graph, Node, NodeIt, _Value> {
 public:
 typedef ArrayMappableGraphExtender<_Base> Graph;
 typedef typename Graph::Node Node;
 typedef typename Graph::NodeIt NodeIt;
-typedef typename Graph::NodeIdMap NodeIdMap;
+typedef ArrayMap<Graph, Node, NodeIt, _Value> Parent;
-typedef ArrayMap<Graph, Node, NodeIt, NodeIdMap, _Value> Parent;
 //typedef typename Parent::Graph Graph;
 typedef typename Parent::Value Value;
 NodeMap(const Graph& g)
-	: Parent(g, g.getNodeObserverRegistry()) {}
+	: Parent(g) {}
 NodeMap(const Graph& g, const Value& v)
-	: Parent(g, g.getNodeObserverRegistry(), v) {}
+	: Parent(g, v) {}
 };
 template <typename _Value>
-class EdgeMap : public ArrayMap<Graph, Edge, EdgeIt, EdgeIdMap, _Value> {
+class EdgeMap : public ArrayMap<Graph, Edge, EdgeIt, _Value> {
 public:
 typedef ArrayMappableGraphExtender<_Base> Graph;
 typedef typename Graph::Edge Edge;
 typedef typename Graph::EdgeIt EdgeIt;
-typedef typename Graph::EdgeIdMap EdgeIdMap;
+typedef ArrayMap<Graph, Edge, EdgeIt, _Value> Parent;
-typedef ArrayMap<Graph, Edge, EdgeIt, EdgeIdMap, _Value> Parent;
 //typedef typename Parent::Graph Graph;
 typedef typename Parent::Value Value;
 EdgeMap(const Graph& g)
-	: Parent(g, g.getEdgeObserverRegistry()) {}
+	: Parent(g) {}
 EdgeMap(const Graph& g, const Value& v)
-	: Parent(g, g.getEdgeObserverRegistry(), v) {}
+	: Parent(g, v) {}
 };
 };

changeset 980	0f1044b7a3af
parent 979	b5fb023cdb7b
child 987	87f7c54892df