Index: src/hugo/array_map_factory.h
===================================================================
--- src/hugo/array_map_factory.h	(revision 786)
+++ src/hugo/array_map_factory.h	(revision 799)
@@ -13,19 +13,34 @@
 
 namespace hugo {
-	
+
+
 /// \addtogroup graphmapfactory
 /// @{
-
-  ///.
-  template <typename MapRegistry> class ArrayMapFactory {
+	
+  /** The ArrayMapFactory template class is a factory class
+   *  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 {
@@ -33,11 +48,31 @@
       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();
@@ -48,4 +83,6 @@
       }
 
+      /** Constructor to use default value to initialize the map. 
+       */
       Map(const Graph& g, MapRegistry& r, const Value& v) : MapBase(g, r) {
 	allocate_memory();
@@ -56,4 +93,6 @@
       }
 
+      /** Constructor to copy a map of the same map type.
+       */
       Map(const Map& copy) : MapBase(*copy.graph, *copy.registry) {
 	capacity = copy.capacity;
@@ -66,4 +105,6 @@
       }
 
+      /** Constructor to copy a map of an other map type.
+       */
       template <typename CMap> Map(const CMap& copy) 
 	: MapBase(copy), capacity(0), values(0) {
@@ -76,4 +117,6 @@
       }
 
+      /** Assign operator to copy a map of the same map type.
+       */
       Map& operator=(const Map& copy) {
 	if (&copy == this) return *this;
@@ -92,4 +135,6 @@
       }
 
+      /** Assign operator to copy a map an other map type.
+       */
       template <typename CMap> Map& operator=(const CMap& copy) {
 	if (MapBase::getGraph()) {
@@ -106,4 +151,6 @@
       }
 				
+      /** The destructor of the map.
+       */
       virtual ~Map() {
 	if (capacity != 0) {
@@ -114,4 +161,8 @@
 	
 	
+      /**
+       * 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);
@@ -119,4 +170,8 @@
       } 
 		
+      /**
+       * 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);
@@ -124,9 +179,7 @@
       }
 	
-      const Value& get(const KeyType& key) const {
-	int id = MapBase::getGraph()->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.
+       */
       void set(const KeyType& key, const Value& val) {
 	int id = MapBase::getGraph()->id(key);
@@ -134,4 +187,6 @@
       }
 		
+      /** Add a new key to the map. It called by the map registry.
+       */
       void add(const KeyType& key) {
 	int id = MapBase::getGraph()->id(key);
@@ -156,4 +211,6 @@
       }
 		
+      /** Erase a key from the map. It called by the map registry.
+       */
       void erase(const KeyType& key) {
 	int id = MapBase::getGraph()->id(key);
@@ -161,4 +218,6 @@
       }
 
+      /** Clear the data structure.
+       */
       void clear() {	
 	if (capacity != 0) {
@@ -169,4 +228,7 @@
       }
 	
+      /** Compatible iterator with the stl maps' iterators.
+       *  It iterates on pairs of a key and a value.
+       */
       class iterator {
 	friend class Map;
@@ -372,7 +434,6 @@
     };		
   };
-  
+
 /// @}
-  
 
 }
Index: src/hugo/default_map_factory.h
===================================================================
--- src/hugo/default_map_factory.h	(revision 798)
+++ src/hugo/default_map_factory.h	(revision 799)
@@ -7,5 +7,13 @@
 #include <hugo/vector_map_factory.h>
 
+///\ingroup graphmapfactory
+///\file
+///\brief Graph maps that construates and destruates
+///their elements dynamically.
+
 namespace hugo {
+
+/// \addtogroup graphmapfactory
+/// @{
 
 #define DEFAULT_MAP_BODY(Factory, Val) \
@@ -16,5 +24,5 @@
   \
     typedef typename MapRegistry::Graph Graph; \
-    typedef typename MapRegistry::Key Key; \
+    typedef typename MapRegistry::KeyType KeyType; \
     typedef typename MapRegistry::KeyIt KeyIt; \
     typedef Val Value; \
@@ -96,15 +104,31 @@
   DEFAULT_MAP_BODY(VectorMapFactory, Type*);
 
+
+  /** The DefaultMapFactory template class is a factory class
+   *  to create maps for the edge and nodes. This map factory
+   *  uses the VectorMapFactory if the ValueType is a primitive
+   *  type and the ArrayMapFactory for the other cases.
+   *
+   *  The template parameter is the MapRegistry that the maps
+   *  will belong to.
+   */
+
   template <typename MapRegistry>
   class DefaultMapFactory {
 		
   public:
-		
+    /// The graph type of the maps. 
     typedef typename MapRegistry::Graph Graph;
-    typedef typename MapRegistry::Key Key;
+    /// 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> 
     class Map : public DefaultMap<MapRegistry, V> {
@@ -116,14 +140,26 @@
       typedef V Value;
 
+      /** Default constructor for the map.
+       */
       Map() : MapImpl() {}
 
+      /** Graph and Registry initialized map constructor.
+       */
       Map(const Graph& g, MapRegistry& r) : MapImpl(g, r) {}
 
+      /** Constructor to use default value to initialize the map. 
+       */
       Map(const Graph& g, MapRegistry& r, const Value& v) : MapImpl(g, r, v) {}
 
+      /** Constructor to copy a map of the same map type.
+       */
       Map(const Map& copy) : MapImpl(static_cast<const MapImpl&>(copy)) {}
 
+      /** Constructor to copy a map of an other map type.
+       */
       template <typename CMap> Map(const CMap& copy) : MapImpl(copy) {}
 
+      /** Assign operator to copy a map of the same map type.
+       */
       Map& operator=(const Map& copy) {
 	MapImpl::operator=(static_cast<const MapImpl&>(copy));
@@ -131,4 +167,6 @@
       }
 
+      /** Assign operator to copy a map an other map type.
+       */
       template <typename CMap> Map& operator=(const CMap& copy) {
 	MapImpl::operator=(copy);
Index: src/hugo/vector_map_factory.h
===================================================================
--- src/hugo/vector_map_factory.h	(revision 798)
+++ src/hugo/vector_map_factory.h	(revision 799)
@@ -129,9 +129,5 @@
        * actual keys of the graph. 
        */
-<<<<<<< .mine
-      Reference operator[](const Key& key) {
-=======
-      typename Container::reference operator[](const KeyType& key) {
->>>>>>> .r1091
+      Reference operator[](const KeyType& key) {
 	int id = getGraph()->id(key);
 	return container[id];
@@ -142,9 +138,5 @@
        * actual keys of the graph. 
        */
-<<<<<<< .mine
-      ConstReference operator[](const Key& key) const {
-=======
-      typename Container::const_reference operator[](const KeyType& key) const {
->>>>>>> .r1091
+      ConstReference operator[](const KeyType& key) const {
 	int id = getGraph()->id(key);
 	return container[id];
@@ -210,5 +202,5 @@
 	private:
 	  Reference data;
-	  Pointer(const KeyType& key, Value& val) : data(key, val) {}
+	  Pointer(const KeyType& key, Map::Reference val) : data(key, val) {}
 	public:
 	  Reference* operator->() {return &data;}
@@ -301,5 +293,6 @@
 	private:
 	  Reference data;
-	  Pointer(const KeyType& key, const Value& val) : data(key, val) {}
+	  Pointer(const KeyType& key, Map::ConstReference val) 
+	    : data(key, val) {}
 	public:
 	  Reference* operator->() {return &data;}
