lemon-0.x: comparison src/hugo/array_map

equal deleted inserted replaced

-:d816b9dbb169
+:0da22869bbe6
 ///\file
 ///\brief Graph maps that construates and destruates
 ///their elements dynamically.
 namespace hugo {
 /// \addtogroup graphmapfactory
 /// @{
-///.
+/** The ArrayMapFactory template class is a factory class
-template <typename MapRegistry> class ArrayMapFactory {
+*  to create maps for the edge and nodes. This map factory
+*  uses the allocators to implement the container function.
+*
+*  The template parameter is the MapRegistry that the maps
+*  will belong to.
+*/
+template <typename MapRegistry>
+class ArrayMapFactory {
 public:
+/// The graph type of the maps.
 typedef typename MapRegistry::Graph Graph;
+/// The key type of the maps.
 typedef typename MapRegistry::KeyType KeyType;
+/// The iterator to iterate on the keys.
 typedef typename MapRegistry::KeyIt KeyIt;
+/// The MapBase of the Map which imlements the core regisitry function.
 typedef typename MapRegistry::MapBase MapBase;
+/** The template Map type.
+*/
 template <typename V, typename A = std::allocator<V> >
 class Map : public MapBase {
 public:
+/// The value type of the map.
+typedef V ValueType;
+/// The value type of the map.
 typedef V Value;
-typedef V ValueType;
+/// The reference type of the map;
+typedef Value& Reference;
+/// The pointer type of the map;
+typedef Value* Pointer;
+/// The const value type of the map.
+typedef const Value ConstValue;
+/// The const reference type of the map;
+typedef const Value& ConstReference;
+/// The pointer type of the map;
+typedef const Value* ConstPointer;
 typedef A Allocator;
+/** Default constructor for the map.
+*/
 Map() : values(0), capacity(0) {}
+/** Graph and Registry initialized map constructor.
+*/
 Map(const Graph& g, MapRegistry& r) : MapBase(g, r) {
 	allocate_memory();
 	for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {
 	  int id = MapBase::getGraph()->id(it);
 	  allocator.construct(&(values[id]), Value());
 	}
 }
+/** Constructor to use default value to initialize the map.
+*/
 Map(const Graph& g, MapRegistry& r, const Value& v) : MapBase(g, r) {
 	allocate_memory();
 	for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {
 	  int id = MapBase::getGraph()->id(it);
 	  allocator.construct(&(values[id]), v);
 	}
 }
+/** Constructor to copy a map of the same map type.
+*/
 Map(const Map& copy) : MapBase(*copy.graph, *copy.registry) {
 	capacity = copy.capacity;
 	if (capacity == 0) return;
 	values = allocator.allocate(capacity);
 	for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {
 	  int id = MapBase::getGraph()->id(it);
 	  allocator.construct(&(values[id]), copy.values[id]);
 	}
 }
+/** Constructor to copy a map of an other map type.
+*/
 template <typename CMap> Map(const CMap& copy)
 	: MapBase(copy), capacity(0), values(0) {
 	if (MapBase::getGraph()) {
 	  allocate_memory();
 	  for (KeyIt it(*MapBase::getGraph()); it != INVALID; ++it) {
 	    set(it, copy[it]);
 	  }
 	}
 }
+/** Assign operator to copy a map of the same map type.
+*/
 Map& operator=(const Map& copy) {
 	if (&copy == this) return *this;
 	if (capacity != 0) {
 	  MapBase::destroy();
 	  allocator.deallocate(values, capacity);
 	  allocator.construct(&(values[id]), copy.values[id]);
 	}
 	return *this;
 }
+/** Assign operator to copy a map an other map type.
+*/
 template <typename CMap> Map& operator=(const CMap& copy) {
 	if (MapBase::getGraph()) {
 	  MapBase::destroy();
 	}
 	MapBase::operator=(copy);
 	  }
 	}
 	return *this;
 }
+/** The destructor of the map.
+*/
 virtual ~Map() {
 	if (capacity != 0) {
 	  MapBase::destroy();
 	  allocator.deallocate(values, capacity);
 	}
 }
+/**
+* The subscript operator. The map can be subscripted by the
+* actual keys of the graph.
+*/
 Value& operator[](const KeyType& key) {
 	int id = MapBase::getGraph()->id(key);
 	return values[id];
 }
+/**
+* The const subscript operator. The map can be subscripted by the
+* actual keys of the graph.
+*/
 const Value& operator[](const KeyType& key) const {
 	int id = MapBase::getGraph()->id(key);
 	return values[id];
 }
-const Value& get(const KeyType& key) const {
+/** Setter function of the map. Equivalent with map[key] = val.
-	int id = MapBase::getGraph()->id(key);
+*  This is a compatibility feature with the not dereferable maps.
-	return values[id];
+*/
-}
 void set(const KeyType& key, const Value& val) {
 	int id = MapBase::getGraph()->id(key);
 	values[id] = val;
 }
+/** Add a new key to the map. It called by the map registry.
+*/
 void add(const KeyType& key) {
 	int id = MapBase::getGraph()->id(key);
 	if (id >= capacity) {
 	  int new_capacity = (capacity == 0 ? 1 : capacity);
 	  while (new_capacity <= id) {
 	  capacity = new_capacity;
 	}
 	allocator.construct(&(values[id]), Value());
 }
+/** Erase a key from the map. It called by the map registry.
+*/
 void erase(const KeyType& key) {
 	int id = MapBase::getGraph()->id(key);
 	allocator.destroy(&(values[id]));
 }
+/** Clear the data structure.
+*/
 void clear() {
 	if (capacity != 0) {
 	  MapBase::destroy();
 	  allocator.deallocate(values, capacity);
 	  capacity = 0;
 	}
 }
+/** Compatible iterator with the stl maps' iterators.
+*  It iterates on pairs of a key and a value.
+*/
 class iterator {
 	friend class Map;
 	friend class const_iterator;
 private:
 int capacity;
 Value* values;
 Allocator allocator;
 };
 };
 /// @}
 }
 #endif

changeset 799	3393abe30678
parent 786	d7b3b13b9df6
child 817	3e30caeb9c00