lemon-0.x: comparison src/work/deba/map

equal deleted inserted replaced

-:151b7e8528ac
+:d4e514548966
 using namespace std;
 namespace hugo {
 /**
-Registry class to register edge or node maps in the graph. The
+* Registry class to register edge or node maps into the graph. The
-registry helps you to implement an observer pattern. If you add
+* registry helps you to implement an observer pattern. If you add
-or erase an edge or node you must notify all the maps about the
+* or erase an edge or node you must notify all the maps about the
-event.
+* event.
 */
 template <typename G, typename K, typename KIt>
 class MapRegistry {
 public:
 typedef G Graph;
 typedef K Key;
 typedef KIt KeyIt;
-///.
+/**
+* MapBase is the base class of the registered maps.
-///.
+* It defines the core modification operations on the maps and
-///
+* implements some helper functions.
+*/
 class MapBase {
 public:
 typedef G Graph;
 typedef MapRegistry<G, K, KIt> Registry;
 typedef K Key;
 typedef KIt KeyIt;
 friend class Registry;
 /**
-	  Default constructor.
+* Default constructor for MapBase.
 */
 MapBase() : graph(0), registry(0) {}
 /**
-	  Simple constructor to register into a graph registry.
+* Simple constructor to register into a graph registry.
 */
-MapBase(Graph& g, Registry& r) : graph(&g), registry(0) {
+MapBase(const Graph& g, Registry& r) : graph(&g), registry(0) {
 	r.attach(*this);
 }
 /**
-	  Copy constructor with registering into the map.
+* Copy constructor to register into the registry.
 */
 MapBase(const MapBase& copy) : registry(0), graph(copy.graph) {
 	if (copy.registry) {
 	  copy.registry->attach(*this);
 	}
 }
 /**
-	  Assign operator.
+* Assign operator.
 */
 const MapBase& operator=(const MapBase& copy) {
 	if (registry) {
 	  registry->detach(*this);
 	}
 }
 /**
-	  Destructor.
+* Destructor.
 */
 virtual ~MapBase() {
 	if (registry) {
 	  registry->detach(*this);
 	}
 }
+/*
+* Returns the graph that the map belongs to.
+*/
+const Graph* getGraph() const { return graph; }
+private:
+const Graph* graph;
+Registry* registry;
+int registry_index;
 protected:
-Graph* graph;
-Registry* registry;
-int registry_index;
 /**
 	 Helper function to implement constructors in the subclasses.
 */
 /**
 	 Helper function to implement the destructor in the subclasses.
 */
 virtual void destroy() {
-	for (KeyIt it(*graph); graph->valid(it); graph->next(it)) {
+	for (KeyIt it(*getGraph()); getGraph()->valid(it); getGraph()->next(it)) {
 	  erase(it);
 	}
 }
 /**
 };
 protected:
+/**
+* The container type of the maps.
+*/
 typedef std::vector<MapBase*> Container;
+/**
+* The container of the registered maps.
+*/
 Container container;
 public:
-///.
+/**
+* Default Constructor of the MapRegistry. It creates an empty registry.
+*/
 MapRegistry() {}
-///.
+/**
+* Copy Constructor of the MapRegistry. The new registry does not steal
+* the maps from the right value. The new registry will be an empty.
+*/
 MapRegistry(const MapRegistry&) {}
-///.
+/**
+* Assign operator. The left value does not steal the maps
+* from the right value. The left value will be an empty registry.
+*/
 MapRegistry& operator=(const MapRegistry&) {
 for (it = container.begin(); it != container.end(); ++it) {
 	(*it)->destroy();
 	(*it)->graph = 0;
 	(*it)->registry = 0;
 }
 }
-///.
+/**
+* Destructor of the MapRegistry.
+*/
 ~MapRegistry() {
 typename Container::iterator it;
 for (it = container.begin(); it != container.end(); ++it) {
 	(*it)->destroy();
 	(*it)->registry = 0;
 }
 public:
-///.
+/**
+* Attach a map into thr registry. If the map has been attached
+* into an other registry it is detached from that automaticly.
+*/
 void attach(MapBase& map) {
 if (map.registry) {
 	map.registry->detach(map);
 }
 container.push_back(&map);
 map.registry = this;
 map.registry_index = container.size()-1;
 }
-///.
+/**
+* Detach the map from the registry.
+*/
 void detach(MapBase& map) {
 container.back()->registry_index = map.registry_index;
 container[map.registry_index] = container.back();
 container.pop_back();
 map.registry = 0;
 map.graph = 0;
 }
-///.
+/**
+* Notify all the registered maps about a Key added.
+*/
 virtual void add(Key& key) {
 typename Container::iterator it;
 for (it = container.begin(); it != container.end(); ++it) {
 	(*it)->add(key);
 }
 }
-///.
+/**
+* Notify all the registered maps about a Key erased.
+*/
 virtual void erase(Key& key) {
 typename Container::iterator it;
 for (it = container.begin(); it != container.end(); ++it) {
 	(*it)->erase(key);
 }

changeset 702	4207f82a1778
parent 676	7ec5e7e6c7b4
child 703	32f280a5ed7d