Index: ChangeLog
===================================================================
--- ChangeLog	(revision 928)
+++ ChangeLog	(revision 987)
@@ -1,2 +1,8 @@
+	* ValueType -> Value, KeyType -> Key, ReferenceType ->Reference,
+	  PointerType -> Pointer
+	* target() -> target(), source() -> source()
+	* Graph factory
+	* Right include paths in documentation
+	
 2004-09-30  Alpar Juttner  <alpar@cs.elte.hu>
 
Index: doc/maps.dox
===================================================================
--- doc/maps.dox	(revision 986)
+++ doc/maps.dox	(revision 987)
@@ -10,6 +10,6 @@
 
 \code
-  typedef Edge KeyType;
-  typedef double ValueType;
+  typedef Edge Key;
+  typedef double Value;
 \endcode
 
@@ -53,5 +53,5 @@
 \endcode
 - <em>Writable maps</em> have
-a member function \c set(KeyType,const ValueType &)
+a member function \c set(Key,const Value &)
 for this purpose.
 \code
@@ -83,7 +83,7 @@
 struct MyMap 
 {
-  typedef double ValueType;
-  typedef Graph::Edge KeyType;
-  double operator[](KeyType e) const { return M_PI;}
+  typedef double Value;
+  typedef Graph::Edge Key;
+  double operator[](Key e) const { return M_PI;}
 };
 \endcode
@@ -96,5 +96,5 @@
 struct MyMap : public MapBase<Graph::Edge,double>
 {
-  ValueType operator[](KeyType e) const { return M_PI;}
+  Value operator[](Key e) const { return M_PI;}
 };
 \endcode
@@ -112,5 +112,5 @@
   
 public:
-  ValueType operator[](KeyType e) const {
+  Value operator[](Key e) const {
     return orig_len.get(e)-pot.get(G.target(e))-pot.get(G.source(e));
   }
Index: src/lemon/array_map.h
===================================================================
--- src/lemon/array_map.h	(revision 980)
+++ src/lemon/array_map.h	(revision 987)
@@ -39,5 +39,5 @@
    *
    *  The template parameter is the MapRegistry that the maps
-   *  will belong to and the ValueType.
+   *  will belong to and the Value.
    */
 
@@ -53,5 +53,5 @@
     typedef _Graph Graph;
     /// The key type of the maps.
-    typedef _Item KeyType;
+    typedef _Item Key;
 
     typedef AlterationObserverRegistry<_Item> Registry;
@@ -61,6 +61,4 @@
     typedef _ItemIt KeyIt;
 
-    typedef _Value Value;
-
     /// The MapBase of the Map which imlements the core regisitry function.
     typedef typename Registry::ObserverBase Parent;
@@ -70,16 +68,16 @@
 
     /// The value type of the map.
-    typedef Value ValueType;
+    typedef _Value Value;
     /// The reference type of the map;
-    typedef Value& ReferenceType;
+    typedef Value& Reference;
     /// The pointer type of the map;
-    typedef Value* PointerType;
+    typedef Value* Pointer;
 
     /// The const value type of the map.
-    typedef const Value ConstValueType;
+    typedef const Value ConstValue;
     /// The const reference type of the map;
-    typedef const Value& ConstReferenceType;
+    typedef const Value& ConstReference;
     /// The pointer type of the map;
-    typedef const Value* ConstPointerType;
+    typedef const Value* ConstPointer;
 
 
@@ -173,5 +171,5 @@
      * actual keys of the graph. 
      */
-    ReferenceType operator[](const KeyType& key) {
+    Reference operator[](const Key& key) {
       int id = graph->id(key);
       return values[id];
@@ -182,5 +180,5 @@
      * actual keys of the graph. 
      */
-    ConstReferenceType operator[](const KeyType& key) const {
+    ConstReference operator[](const Key& key) const {
       int id = graph->id(key);
       return values[id];
@@ -190,5 +188,5 @@
      *  This is a compatibility feature with the not dereferable maps.
      */
-    void set(const KeyType& key, const ValueType& val) {
+    void set(const Key& key, const Value& val) {
       (*this)[key] = val;
     }
@@ -196,5 +194,5 @@
     /** Add a new key to the map. It called by the map registry.
      */
-    void add(const KeyType& key) {
+    void add(const Key& key) {
       int id = graph->id(key);
       if (id >= capacity) {
@@ -220,5 +218,5 @@
     /** Erase a key from the map. It called by the map registry.
      */
-    void erase(const KeyType& key) {
+    void erase(const Key& key) {
       int id = graph->id(key);
       allocator.destroy(&(values[id]));
@@ -322,11 +320,11 @@
 //     typedef Iterator iterator;
 //     typedef ConstIterator const_iterator;
-//     typedef typename Iterator::PairValueType value_type;
-//     typedef typename Iterator::KeyType key_type;
-//     typedef typename Iterator::ValueType data_type;
-//     typedef typename Iterator::PairReferenceType reference;
-//     typedef typename Iterator::PairPointerType pointer;
-//     typedef typename ConstIterator::PairReferenceType const_reference;
-//     typedef typename ConstIterator::PairPointerType const_pointer;
+//     typedef typename Iterator::PairValue value_type;
+//     typedef typename Iterator::Key key_type;
+//     typedef typename Iterator::Value data_type;
+//     typedef typename Iterator::PairReference reference;
+//     typedef typename Iterator::PairPointer pointer;
+//     typedef typename ConstIterator::PairReference const_reference;
+//     typedef typename ConstIterator::PairPointer const_pointer;
 //     typedef int difference_type;		
   };		
Index: src/lemon/concept/graph.h
===================================================================
--- src/lemon/concept/graph.h	(revision 986)
+++ src/lemon/concept/graph.h	(revision 987)
@@ -568,7 +568,7 @@
 // 	{
 // 	  //Check the typedef's
-// 	  typename Graph::template NodeMap<int>::ValueType val;
+// 	  typename Graph::template NodeMap<int>::Value val;
 // 	  val=1;
-// 	  typename Graph::template NodeMap<int>::KeyType key;
+// 	  typename Graph::template NodeMap<int>::Key key;
 // 	  key = typename Graph::NodeIt(G);
 // 	}
@@ -592,7 +592,7 @@
 // 	{
 // 	  //Check the typedef's
-// 	  typename Graph::template NodeMap<bool>::ValueType val;
+// 	  typename Graph::template NodeMap<bool>::Value val;
 // 	  val=true;
-// 	  typename Graph::template NodeMap<bool>::KeyType key;
+// 	  typename Graph::template NodeMap<bool>::Key key;
 // 	  key= typename Graph::NodeIt(G);
 // 	}
@@ -615,7 +615,7 @@
 // 	{
 // 	  //Check the typedef's
-// 	  typename Graph::template EdgeMap<int>::ValueType val;
+// 	  typename Graph::template EdgeMap<int>::Value val;
 // 	  val=1;
-// 	  typename Graph::template EdgeMap<int>::KeyType key;
+// 	  typename Graph::template EdgeMap<int>::Key key;
 // 	  key= typename Graph::EdgeIt(G);
 // 	}
@@ -638,7 +638,7 @@
 // 	{
 // 	  //Check the typedef's
-// 	  typename Graph::template EdgeMap<bool>::ValueType val;
+// 	  typename Graph::template EdgeMap<bool>::Value val;
 // 	  val=true;
-// 	  typename Graph::template EdgeMap<bool>::KeyType key;
+// 	  typename Graph::template EdgeMap<bool>::Key key;
 // 	  key= typename Graph::EdgeIt(G);
 // 	}
Index: src/lemon/concept/graph_component.h
===================================================================
--- src/lemon/concept/graph_component.h	(revision 986)
+++ src/lemon/concept/graph_component.h	(revision 987)
@@ -678,9 +678,9 @@
       typedef BaseGraphComponent::Edge Edge;
 
-      template <typename Value>
-      class NodeMap : public ReferenceMap<Node, Value> {
+      template <typename _Value>
+      class NodeMap : public ReferenceMap<Node, _Value> {
       public:
 	NodeMap(const Graph&) {}
-	NodeMap(const Graph&, const Value&) {}
+	NodeMap(const Graph&, const _Value&) {}
 	NodeMap(const NodeMap&) {}
 
@@ -689,9 +689,9 @@
       };
 
-      template <typename Value>
-      class EdgeMap : public ReferenceMap<Edge, Value> {
+      template <typename _Value>
+      class EdgeMap : public ReferenceMap<Edge, _Value> {
       public:
 	EdgeMap(const Graph&) {}
-	EdgeMap(const Graph&, const Value&) {}
+	EdgeMap(const Graph&, const _Value&) {}
 	EdgeMap(const EdgeMap&) {}
 
Index: src/lemon/concept/maps.h
===================================================================
--- src/lemon/concept/maps.h	(revision 959)
+++ src/lemon/concept/maps.h	(revision 987)
@@ -37,10 +37,10 @@
     public:
       /// Map's key type.
-      typedef K KeyType;    
-      /// Map's value type. (The type of objects associated with the keys).
-      typedef T ValueType;
+      typedef K Key;    
+      /// Map's value type. (The type of objects associated with the keys).
+      typedef T Value;
 
       /// Returns the value associated with a key.
-      ValueType operator[](const KeyType &k) const {return ValueType();}
+      Value operator[](const Key &k) const {return Value();}
 
       ///Default constructor
@@ -55,10 +55,10 @@
     public:
       /// Map's key type.
-      typedef K KeyType;    
-      /// Map's value type. (The type of objects associated with the keys).
-      typedef T ValueType;
+      typedef K Key;    
+      /// Map's value type. (The type of objects associated with the keys).
+      typedef T Value;
 
       /// Sets the value associated with a key.
-      void set(const KeyType &k,const ValueType &t) {}
+      void set(const Key &k,const Value &t) {}
 
       ///Default constructor
@@ -73,12 +73,12 @@
     public:
       /// Map's key type.
-      typedef K KeyType;    
-      /// Map's value type. (The type of objects associated with the keys).
-      typedef T ValueType;
+      typedef K Key;    
+      /// Map's value type. (The type of objects associated with the keys).
+      typedef T Value;
 
       /// Returns the value associated with a key.
-      ValueType operator[](const KeyType &k) const {return ValueType();}
+      Value operator[](const Key &k) const {return Value();}
       /// Sets the value associated with a key.
-      void set(const KeyType &k,const ValueType &t) {}
+      void set(const Key &k,const Value &t) {}
 
       ///Default constructor
@@ -93,22 +93,22 @@
     public:
       /// Map's key type.
-      typedef K KeyType;    
-      /// Map's value type. (The type of objects associated with the keys).
-      typedef T ValueType;
+      typedef K Key;    
+      /// Map's value type. (The type of objects associated with the keys).
+      typedef T Value;
 
     protected:
-      ValueType tmp;
-    public:
-      typedef ValueType& ReferenceType;
+      Value tmp;
+    public:
+      typedef Value& Reference;
       /// Map's const reference type.
-      typedef const ValueType& ConstReferenceType;
+      typedef const Value& ConstReference;
 
       ///Returns a reference to the value associated to a key.
-      ReferenceType operator[](const KeyType &i) { return tmp; }
+      Reference operator[](const Key &i) { return tmp; }
       ///Returns a const reference to the value associated to a key.
-      ConstReferenceType operator[](const KeyType &i) const
+      ConstReference operator[](const Key &i) const
       { return tmp; }
       /// Sets the value associated with a key.
-      void set(const KeyType &k,const ValueType &t) { operator[](k)=t; }
+      void set(const Key &k,const Value &t) { operator[](k)=t; }
 
       ///Default constructor
@@ -150,13 +150,13 @@
     template<typename ReadMap>
     struct ReadMapConcept {
-      typedef typename ReadMap::KeyType KeyType;
-      typedef typename ReadMap::ValueType ValueType;
+      typedef typename ReadMap::Key Key;
+      typedef typename ReadMap::Value Value;
 
       void constraints() {
 	// No constraints for constructor.
 
-	// What are the requirement for the ValueType?
+	// What are the requirement for the Value?
 	// CopyConstructible? Assignable? None of these?
-	ValueType v = m[k];
+	Value v = m[k];
 	v = m[k];
 
@@ -166,11 +166,11 @@
 
       ReadMap m;
-      KeyType k;
+      Key k;
     };
 
     template<typename WriteMap>
     struct WriteMapConcept {
-      typedef typename WriteMap::KeyType KeyType;
-      typedef typename WriteMap::ValueType ValueType;
+      typedef typename WriteMap::Key Key;
+      typedef typename WriteMap::Value Value;
 
       void constraints() {
@@ -181,6 +181,6 @@
 
       WriteMap m;
-      KeyType k;
-      ValueType v;
+      Key k;
+      Value v;
     };
 
@@ -195,10 +195,10 @@
     template<typename ReferenceMap>
     struct ReferenceMapConcept {
-      typedef typename ReferenceMap::KeyType KeyType;
-      typedef typename ReferenceMap::ValueType ValueType;
-      typedef typename ReferenceMap::ReferenceType ReferenceType;
+      typedef typename ReferenceMap::Key Key;
+      typedef typename ReferenceMap::Value Value;
+      typedef typename ReferenceMap::Reference Reference;
 
       // What for is this?
-      typedef typename ReferenceMap::ConstReferenceType ConstReferenceType;
+      typedef typename ReferenceMap::ConstReference ConstReference;
 
       void constraints() {
@@ -208,11 +208,11 @@
 	// Or should we require real reference?
 	// Like this:
-	// ValueType &vv = m[k];
+	// Value &vv = m[k];
 	// ignore_unused_variable_warning(vv);
       }
 
       ReferenceMap m;
-      KeyType k;
-      ValueType v;
+      Key k;
+      Value v;
     };
 
@@ -236,5 +236,5 @@
       const GraphMap &c;
       const Graph &g;
-      const typename GraphMap::ValueType &t;
+      const typename GraphMap::Value &t;
     };
     
Index: src/lemon/default_map.h
===================================================================
--- src/lemon/default_map.h	(revision 980)
+++ src/lemon/default_map.h	(revision 987)
@@ -34,9 +34,9 @@
   /** The ArrayMap template class is graph map structure what
    *  automatically updates the map when a key is added to or erased from
-   *  the map. This map uses the VectorMap if the ValueType is a primitive
+   *  the map. This map uses the VectorMap if the Value is a primitive
    *  type and the ArrayMap for the other cases.
    *
    *  The template parameter is the MapRegistry that the maps
-   *  will belong to and the ValueType.
+   *  will belong to and the Value.
    */
 
@@ -148,8 +148,8 @@
     
     typedef typename Parent::Graph Graph;
-    typedef typename Parent::ValueType ValueType;
+    typedef typename Parent::Value Value;
 
     DefaultMap(const Graph& _g) : Parent(_g) {}
-    DefaultMap(const Graph& _g, const ValueType& _v) : Parent(_g, _v) {}
+    DefaultMap(const Graph& _g, const Value& _v) : Parent(_g, _v) {}
   };
 
@@ -181,9 +181,9 @@
 
       //typedef typename Parent::Graph Graph;
-      typedef typename Parent::ValueType ValueType;
+      typedef typename Parent::Value Value;
 
       NodeMap(const Graph& _g) 
 	: Parent(_g) {}
-      NodeMap(const Graph& _g, const ValueType& _v) 
+      NodeMap(const Graph& _g, const Value& _v) 
 	: Parent(_g, _v) {}
 
@@ -201,9 +201,9 @@
 
       //typedef typename Parent::Graph Graph;
-      typedef typename Parent::ValueType ValueType;
+      typedef typename Parent::Value Value;
 
       EdgeMap(const Graph& _g) 
 	: Parent(_g) {}
-      EdgeMap(const Graph& _g, const ValueType& _v) 
+      EdgeMap(const Graph& _g, const Value& _v) 
 	: Parent(_g, _v) {}
 
Index: src/lemon/dijkstra.h
===================================================================
--- src/lemon/dijkstra.h	(revision 986)
+++ src/lemon/dijkstra.h	(revision 987)
@@ -38,5 +38,5 @@
   ///
   ///The type of the length is determined by the
-  ///\ref concept::ReadMap::ValueType "ValueType" of the length map.
+  ///\ref concept::ReadMap::Value "Value" of the length map.
   ///
   ///It is also possible to change the underlying priority heap.
@@ -82,5 +82,5 @@
     
     ///The type of the length of the edges.
-    typedef typename LM::ValueType ValueType;
+    typedef typename LM::Value Value;
     ///The type of the map that stores the edge lengths.
     typedef LM LengthMap;
@@ -92,5 +92,5 @@
     typedef typename Graph::template NodeMap<Node> PredNodeMap;
     ///The type of the map that stores the dists of the nodes.
-    typedef typename Graph::template NodeMap<ValueType> DistMap;
+    typedef typename Graph::template NodeMap<Value> DistMap;
 
   private:
@@ -238,6 +238,6 @@
       typename GR::template NodeMap<int> heap_map(*G,-1);
       
-      typedef Heap<Node, ValueType, typename GR::template NodeMap<int>,
-      std::less<ValueType> > 
+      typedef Heap<Node, Value, typename GR::template NodeMap<int>,
+      std::less<Value> > 
       HeapType;
       
@@ -249,5 +249,5 @@
 	
 	Node v=heap.top(); 
-	ValueType oldvalue=heap[v];
+	Value oldvalue=heap[v];
 	heap.pop();
 	distance->set(v, oldvalue);
@@ -282,5 +282,5 @@
     ///\warning If node \c v in unreachable from the root the return value
     ///of this funcion is undefined.
-    ValueType dist(Node v) const { return (*distance)[v]; }
+    Value dist(Node v) const { return (*distance)[v]; }
 
     ///Returns the 'previous edge' of the shortest path tree.
Index: src/lemon/dimacs.h
===================================================================
--- src/lemon/dimacs.h	(revision 986)
+++ src/lemon/dimacs.h	(revision 987)
@@ -51,6 +51,6 @@
 		  CostMap& cost) {
     g.clear();
-    typename CapacityMap::ValueType _cap;
-    typename CostMap::ValueType _cost;
+    typename CapacityMap::Value _cap;
+    typename CostMap::Value _cost;
     char d;
     std::string problem;
Index: src/lemon/graph_wrapper.h
===================================================================
--- src/lemon/graph_wrapper.h	(revision 986)
+++ src/lemon/graph_wrapper.h	(revision 987)
@@ -1122,6 +1122,6 @@
       typename Graph::template EdgeMap<T> forward_map, backward_map; 
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
 
       EdgeMap(const SubBidirGraphWrapper<Graph, 
@@ -1151,5 +1151,5 @@
       }
 
-      typename Graph::template EdgeMap<T>::ConstReferenceType 
+      typename Graph::template EdgeMap<T>::ConstReference 
       operator[](Edge e) const { 
 	if (!e.backward) 
@@ -1159,5 +1159,5 @@
       }
 
-      typename Graph::template EdgeMap<T>::ReferenceType 
+      typename Graph::template EdgeMap<T>::Reference 
       operator[](Edge e) { 
 	if (!e.backward) 
@@ -1346,6 +1346,6 @@
       const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>* res_graph;
     public:
-      typedef Number ValueType;
-      typedef Edge KeyType;
+      typedef Number Value;
+      typedef Edge Key;
       ResCap(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& 
 	     _res_graph) : res_graph(&_res_graph) { }
Index: src/lemon/kruskal.h
===================================================================
--- src/lemon/kruskal.h	(revision 986)
+++ src/lemon/kruskal.h	(revision 987)
@@ -113,10 +113,10 @@
     const Map &m;
   public:
-    typedef typename Map::ValueType ValueType;
+    typedef typename Map::Value Value;
 
     NonConstMapWr(const Map &_m) : m(_m) {}
 
-    template<class KeyType>
-    void set(KeyType const& k, ValueType const &v) const { m.set(k,v); }
+    template<class Key>
+    void set(Key const& k, Value const &v) const { m.set(k,v); }
   };
 
@@ -151,9 +151,9 @@
   class KruskalMapInput
     : public std::vector< std::pair<typename GR::Edge,
-				    typename Map::ValueType> > {
+				    typename Map::Value> > {
     
   public:
     typedef std::vector< std::pair<typename GR::Edge,
-				   typename Map::ValueType> > Parent;
+				   typename Map::Value> > Parent;
     typedef typename Parent::value_type value_type;
 
@@ -236,5 +236,5 @@
   /// wrapper function exists: \ref kruskalEdgeMap_IteratorOut().
   ///
-  /// \warning Not a regular property map, as it doesn't know its KeyType
+  /// \warning Not a regular property map, as it doesn't know its Key
 
   template<class Iterator>
@@ -243,10 +243,10 @@
 
   public:
-    typedef bool ValueType;
+    typedef bool Value;
 
     KruskalSequenceOutput(Iterator const &_it) : it(_it) {}
 
-    template<typename KeyType>
-    void set(KeyType const& k, bool v) const { if(v) {*it=k; ++it;} }
+    template<typename Key>
+    void set(Key const& k, bool v) const { if(v) {*it=k; ++it;} }
   };
 
@@ -288,5 +288,5 @@
   template <class GR, class IN, class RET>
   inline
-  typename IN::ValueType
+  typename IN::Value
   kruskalEdgeMap(GR const& G,
 		 IN const& in,
@@ -333,5 +333,5 @@
   template <class GR, class IN, class RET>
   inline
-  typename IN::ValueType
+  typename IN::Value
   kruskalEdgeMap_IteratorOut(const GR& G,
 			     const IN& in,
Index: src/lemon/map_defines.h
===================================================================
--- src/lemon/map_defines.h	(revision 937)
+++ src/lemon/map_defines.h	(revision 987)
@@ -52,11 +52,11 @@
  */
 #define CREATE_NODE_MAP(DynMap) \
-template <typename Value> \
-class NodeMap : public DynMap<NodeMapRegistry, Value> { \
-public: \
-typedef DynMap<NodeMapRegistry, Value> Parent; \
+template <typename _Value> \
+class NodeMap : public DynMap<NodeMapRegistry, _Value> { \
+public: \
+typedef DynMap<NodeMapRegistry, _Value> Parent; \
 NodeMap(const typename Parent::Graph& g) \
   : Parent(g, g.node_maps) {} \
-NodeMap(const typename Parent::Graph& g, const Value& v) \
+NodeMap(const typename Parent::Graph& g, const _Value& v) \
   : Parent(g, g.node_maps, v) {} \
 NodeMap(const NodeMap& copy) : Parent(static_cast<const Parent&>(copy)) {} \
@@ -82,12 +82,12 @@
  */
 #define CREATE_EDGE_MAP(DynMap) \
-template <typename Value> \
-class EdgeMap : public DynMap<EdgeMapRegistry, Value> { \
-public: \
-typedef DynMap<EdgeMapRegistry, Value> Parent; \
+template <typename _Value> \
+class EdgeMap : public DynMap<EdgeMapRegistry, _Value> { \
+public: \
+typedef DynMap<EdgeMapRegistry, _Value> Parent; \
 \
 EdgeMap(const typename Parent::Graph& g) \
   : Parent(g, g.edge_maps) {} \
-EdgeMap(const typename Parent::Graph& g, const Value& v) \
+EdgeMap(const typename Parent::Graph& g, const _Value& v) \
   : Parent(g, g.edge_maps, v) {} \
 EdgeMap(const EdgeMap& copy) : Parent(static_cast<const Parent&>(copy)) {} \
@@ -126,12 +126,12 @@
  */
 #define CREATE_SYM_EDGE_MAP(DynMap) \
-template <typename Value> \
-class SymEdgeMap : public DynMap<SymEdgeMapRegistry, Value> { \
-public: \
-typedef DynMap<SymEdgeMapRegistry, Value> Parent; \
+template <typename _Value> \
+class SymEdgeMap : public DynMap<SymEdgeMapRegistry, _Value> { \
+public: \
+typedef DynMap<SymEdgeMapRegistry, _Value> Parent; \
 \
 SymEdgeMap(const typename Parent::Graph& g) \
   : Parent(g, g.sym_edge_maps) {} \
-SymEdgeMap(const typename Parent::Graph& g, const Value& v) \
+SymEdgeMap(const typename Parent::Graph& g, const _Value& v) \
   : Parent(g, g.sym_edge_maps, v) {} \
 SymEdgeMap(const SymEdgeMap& copy) \
@@ -154,13 +154,13 @@
  */
 #define IMPORT_NODE_MAP(From, from, To, to) \
-template <typename Value> \
-class NodeMap : public From::template NodeMap<Value> { \
-\
-public: \
-typedef typename From::template NodeMap<Value> Parent; \
+template <typename _Value> \
+class NodeMap : public From::template NodeMap<_Value> { \
+\
+public: \
+typedef typename From::template NodeMap<_Value> Parent; \
 \
 NodeMap(const To& to) \
   : Parent(static_cast<const From&>(from)) { } \
-NodeMap(const To& to, const Value& value) \
+NodeMap(const To& to, const _Value& value) \
   : Parent(static_cast<const From&>(from), value) { } \
 NodeMap(const NodeMap& copy) \
@@ -183,13 +183,13 @@
  */
 #define IMPORT_EDGE_MAP(From, from, To, to) \
-template <typename Value> \
-class EdgeMap : public From::template EdgeMap<Value> { \
-\
-public: \
-typedef typename From::template EdgeMap<Value> Parent; \
+template <typename _Value> \
+class EdgeMap : public From::template EdgeMap<_Value> { \
+\
+public: \
+typedef typename From::template EdgeMap<_Value> Parent; \
 \
 EdgeMap(const To& to) \
   : Parent(static_cast<const From&>(from)) { } \
-EdgeMap(const To& to, const Value& value) \
+EdgeMap(const To& to, const _Value& value) \
   : Parent(static_cast<const From&>(from), value) { } \
 EdgeMap(const EdgeMap& copy) \
Index: src/lemon/map_iterator.h
===================================================================
--- src/lemon/map_iterator.h	(revision 921)
+++ src/lemon/map_iterator.h	(revision 987)
@@ -42,21 +42,21 @@
 
     /// The key type of the iterator.
-    typedef typename Map::KeyType KeyType;
-    /// The iterator to iterate on the keys.
-    typedef typename Map::KeyIt KeyIt;
-
-    /// The value type of the iterator.
-    typedef typename Map::ValueType ValueType;
-    /// The reference type of the iterator.
-    typedef typename Map::ReferenceType ReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::PointerType PointerType;
-
-    /// The const value type of the iterator.
-    typedef typename Map::ConstValueType ConstValueType;
-    /// The const reference type of the iterator.
-    typedef typename Map::ConstReferenceType ConstReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::ConstPointerType ConstPointerType;
+    typedef typename Map::Key Key;
+    /// The iterator to iterate on the keys.
+    typedef typename Map::KeyIt KeyIt;
+
+    /// The value type of the iterator.
+    typedef typename Map::Value Value;
+    /// The reference type of the iterator.
+    typedef typename Map::Reference Reference;
+    /// The pointer type of the iterator.
+    typedef typename Map::Pointer Pointer;
+
+    /// The const value type of the iterator.
+    typedef typename Map::ConstValue ConstValue;
+    /// The const reference type of the iterator.
+    typedef typename Map::ConstReference ConstReference;
+    /// The pointer type of the iterator.
+    typedef typename Map::ConstPointer ConstPointer;
 
   protected:
@@ -105,31 +105,31 @@
 
     /// The key type of the iterator.
-    typedef typename Map::KeyType KeyType;
-    /// The iterator to iterate on the keys.
-    typedef typename Map::KeyIt KeyIt;
-
-    /// The value type of the iterator.
-    typedef typename Map::ValueType ValueType;
-    /// The reference type of the iterator.
-    typedef typename Map::ReferenceType ReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::PointerType PointerType;
-
-    /// The const value type of the iterator.
-    typedef typename Map::ConstValueType ConstValueType;
-    /// The const reference type of the iterator.
-    typedef typename Map::ConstReferenceType ConstReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::ConstPointerType ConstPointerType;
+    typedef typename Map::Key Key;
+    /// The iterator to iterate on the keys.
+    typedef typename Map::KeyIt KeyIt;
+
+    /// The value type of the iterator.
+    typedef typename Map::Value Value;
+    /// The reference type of the iterator.
+    typedef typename Map::Reference Reference;
+    /// The pointer type of the iterator.
+    typedef typename Map::Pointer Pointer;
+
+    /// The const value type of the iterator.
+    typedef typename Map::ConstValue ConstValue;
+    /// The const reference type of the iterator.
+    typedef typename Map::ConstReference ConstReference;
+    /// The pointer type of the iterator.
+    typedef typename Map::ConstPointer ConstPointer;
     
   public:
 
     /// The value type of the iterator.
-    typedef extended_pair<KeyType, const KeyType&,
-      ValueType, const ValueType&> PairValueType;
+    typedef extended_pair<Key, const Key&,
+      Value, const Value&> PairValue;
 
     /// The reference type of the iterator. 
-    typedef extended_pair<const KeyType&, const KeyType&, 
-      ReferenceType, ReferenceType> PairReferenceType;
+    typedef extended_pair<const Key&, const Key&, 
+      Reference, Reference> PairReference;
 
     /// Default constructor. 
@@ -141,22 +141,22 @@
 
     /// Dereference operator for the iterator.
-    PairReferenceType operator*() {
-      return PairReferenceType(Base::it, (*map)[Base::it]);
-    }
-
-    /// The pointer type of the iterator.
-    class PairPointerType {
+    PairReference operator*() {
+      return PairReference(Base::it, (*map)[Base::it]);
+    }
+
+    /// The pointer type of the iterator.
+    class PairPointer {
       friend class MapIterator;
     private:
-      PairReferenceType data;
-      PairPointerType(const KeyType& key, ReferenceType val) 
+      PairReference data;
+      PairPointer(const Key& key, Reference val) 
 	: data(key, val) {}
     public:
-      PairReferenceType* operator->() {return &data;}
+      PairReference* operator->() {return &data;}
     };
 
     /// Arrow operator for the iterator.
-    PairPointerType operator->() {
-      return PairPointerType(Base::it, ((*map)[Base::it])); 
+    PairPointer operator->() {
+      return PairPointer(Base::it, ((*map)[Base::it])); 
     }
 	
@@ -181,7 +181,7 @@
     typedef std::forward_iterator_tag iterator_category;
     typedef int difference_type;
-    typedef PairValueType value_type;
-    typedef PairReferenceType reference;
-    typedef PairPointerType pointer;
+    typedef PairValue value_type;
+    typedef PairReference reference;
+    typedef PairPointer pointer;
   };
 
@@ -198,21 +198,21 @@
 
     /// The key type of the iterator.
-    typedef typename Map::KeyType KeyType;
-    /// The iterator to iterate on the keys.
-    typedef typename Map::KeyIt KeyIt;
-
-    /// The value type of the iterator.
-    typedef typename Map::ValueType ValueType;
-    /// The reference type of the iterator.
-    typedef typename Map::ReferenceType ReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::PointerType PointerType;
-
-    /// The const value type of the iterator.
-    typedef typename Map::ConstValueType ConstValueType;
-    /// The const reference type of the iterator.
-    typedef typename Map::ConstReferenceType ConstReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::ConstPointerType ConstPointerType;
+    typedef typename Map::Key Key;
+    /// The iterator to iterate on the keys.
+    typedef typename Map::KeyIt KeyIt;
+
+    /// The value type of the iterator.
+    typedef typename Map::Value Value;
+    /// The reference type of the iterator.
+    typedef typename Map::Reference Reference;
+    /// The pointer type of the iterator.
+    typedef typename Map::Pointer Pointer;
+
+    /// The const value type of the iterator.
+    typedef typename Map::ConstValue ConstValue;
+    /// The const reference type of the iterator.
+    typedef typename Map::ConstReference ConstReference;
+    /// The pointer type of the iterator.
+    typedef typename Map::ConstPointer ConstPointer;
 
   public:    
@@ -233,30 +233,30 @@
 
     /// The value type of the iterator.
-    typedef extended_pair<KeyType, const KeyType&,
-      ValueType, const ValueType&> PairValueType;
+    typedef extended_pair<Key, const Key&,
+      Value, const Value&> PairValue;
 
     /// The reference type of map.
-    typedef extended_pair<const KeyType&, const KeyType&, 
-      ConstReferenceType, ConstReferenceType> PairReferenceType;
+    typedef extended_pair<const Key&, const Key&, 
+      ConstReference, ConstReference> PairReference;
 
     /// Dereference operator for the iterator.
-    PairReferenceType operator*() {
-      return PairReferenceType(Base::it, (*map)[Base::it]);
-    }
-
-    /// The pointer type of the iterator.
-    class PairPointerType {
+    PairReference operator*() {
+      return PairReference(Base::it, (*map)[Base::it]);
+    }
+
+    /// The pointer type of the iterator.
+    class PairPointer {
       friend class MapConstIterator;
     private:
-      PairReferenceType data;
-      PairPointerType(const KeyType& key, ConstReferenceType val) 
+      PairReference data;
+      PairPointer(const Key& key, ConstReference val) 
 	: data(key, val) {}
     public:
-      PairReferenceType* operator->() {return &data;}
+      PairReference* operator->() {return &data;}
     };
 
     /// Arrow operator for the iterator.
-    PairPointerType operator->() {
-      return PairPointerType(Base::it, (*map)[Base::it]); 
+    PairPointer operator->() {
+      return PairPointer(Base::it, (*map)[Base::it]); 
     }
 
@@ -281,7 +281,7 @@
     typedef std::input_iterator_tag iterator_category;
     typedef int difference_type;
-    typedef PairValueType value_type;
-    typedef PairReferenceType reference;
-    typedef PairPointerType pointer;
+    typedef PairValue value_type;
+    typedef PairReference reference;
+    typedef PairPointer pointer;
   };
 
@@ -298,5 +298,5 @@
  
     /// The key type of the iterator.
-    typedef typename Map::KeyType KeyType;
+    typedef typename Map::Key Key;
     /// The iterator to iterate on the keys.
     typedef typename Map::KeyIt KeyIt;
@@ -324,6 +324,6 @@
 
     /// The dereferencing operator of the iterator.
-    KeyType operator*() const {
-      return static_cast<KeyType>(Base::it);
+    Key operator*() const {
+      return static_cast<Key>(Base::it);
     }
 
@@ -332,7 +332,7 @@
     typedef std::input_iterator_tag iterator_category;
     typedef int difference_type;
-    typedef KeyType value_type;
-    typedef const KeyType& reference;
-    typedef const KeyType* pointer;
+    typedef Key value_type;
+    typedef const Key& reference;
+    typedef const Key* pointer;
   };
 
@@ -353,22 +353,22 @@
 
     /// The key type of the iterator.
-    typedef typename Map::KeyType KeyType;
-    /// The iterator to iterate on the keys.
-    typedef typename Map::KeyIt KeyIt;
-
-
-    /// The value type of the iterator.
-    typedef typename Map::ValueType ValueType;
-    /// The reference type of the iterator.
-    typedef typename Map::ReferenceType ReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::PointerType PointerType;
-
-    /// The const value type of the iterator.
-    typedef typename Map::ConstValueType ConstValueType;
-    /// The const reference type of the iterator.
-    typedef typename Map::ConstReferenceType ConstReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::ConstPointerType ConstPointerType;
+    typedef typename Map::Key Key;
+    /// The iterator to iterate on the keys.
+    typedef typename Map::KeyIt KeyIt;
+
+
+    /// The value type of the iterator.
+    typedef typename Map::Value Value;
+    /// The reference type of the iterator.
+    typedef typename Map::Reference Reference;
+    /// The pointer type of the iterator.
+    typedef typename Map::Pointer Pointer;
+
+    /// The const value type of the iterator.
+    typedef typename Map::ConstValue ConstValue;
+    /// The const reference type of the iterator.
+    typedef typename Map::ConstReference ConstReference;
+    /// The pointer type of the iterator.
+    typedef typename Map::ConstPointer ConstPointer;
 
   private:
@@ -400,10 +400,10 @@
 
     /// The dereferencing operator of the iterator.
-    ReferenceType operator*() const {
+    Reference operator*() const {
       return (*map)[Base::it];
     }
 
     /// The arrow operator of the iterator.
-    PointerType operator->() const {
+    Pointer operator->() const {
       return &(operator*());
     }
@@ -413,7 +413,7 @@
     typedef std::forward_iterator_tag iterator_category;
     typedef int difference_type;
-    typedef ValueType value_type;
-    typedef ReferenceType reference;
-    typedef PointerType pointer;
+    typedef Value value_type;
+    typedef Reference reference;
+    typedef Pointer pointer;
   };
 
@@ -431,21 +431,21 @@
 
     /// The key type of the iterator.
-    typedef typename Map::KeyType KeyType;
-    /// The iterator to iterate on the keys.
-    typedef typename Map::KeyIt KeyIt;
-
-    /// The value type of the iterator.
-    typedef typename Map::ValueType ValueType;
-    /// The reference type of the iterator.
-    typedef typename Map::ReferenceType ReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::PointerType PointerType;
-
-    /// The const value type of the iterator.
-    typedef typename Map::ConstValueType ConstValueType;
-    /// The const reference type of the iterator.
-    typedef typename Map::ConstReferenceType ConstReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::ConstPointerType ConstPointerType;
+    typedef typename Map::Key Key;
+    /// The iterator to iterate on the keys.
+    typedef typename Map::KeyIt KeyIt;
+
+    /// The value type of the iterator.
+    typedef typename Map::Value Value;
+    /// The reference type of the iterator.
+    typedef typename Map::Reference Reference;
+    /// The pointer type of the iterator.
+    typedef typename Map::Pointer Pointer;
+
+    /// The const value type of the iterator.
+    typedef typename Map::ConstValue ConstValue;
+    /// The const reference type of the iterator.
+    typedef typename Map::ConstReference ConstReference;
+    /// The pointer type of the iterator.
+    typedef typename Map::ConstPointer ConstPointer;
 
   private:
@@ -482,10 +482,10 @@
 
     /// The dereferencing operator of the iterator.
-    ConstReferenceType operator*() const {
+    ConstReference operator*() const {
       return (*map)[Base::it];
     }
 
     /// The arrow operator of the iterator.
-    ConstPointerType operator->() const {
+    ConstPointer operator->() const {
       return &(operator*());
     }
@@ -495,7 +495,7 @@
     typedef std::input_iterator_tag iterator_category;
     typedef int difference_type;
-    typedef ValueType value_type;
-    typedef ConstReferenceType reference;
-    typedef ConstPointerType pointer;
+    typedef Value value_type;
+    typedef ConstReference reference;
+    typedef ConstPointer pointer;
   };
 
@@ -512,22 +512,22 @@
 
     /// The key type of the iterator.
-    typedef typename Map::KeyType KeyType;
-    /// The iterator to iterate on the keys.
-    typedef typename Map::KeyIt KeyIt;
-
-
-    /// The value type of the iterator.
-    typedef typename Map::ValueType ValueType;
-    /// The reference type of the iterator.
-    typedef typename Map::ReferenceType ReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::PointerType PointerType;
-
-    /// The const value type of the iterator.
-    typedef typename Map::ConstValueType ConstValueType;
-    /// The const reference type of the iterator.
-    typedef typename Map::ConstReferenceType ConstReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::ConstPointerType ConstPointerType;
+    typedef typename Map::Key Key;
+    /// The iterator to iterate on the keys.
+    typedef typename Map::KeyIt KeyIt;
+
+
+    /// The value type of the iterator.
+    typedef typename Map::Value Value;
+    /// The reference type of the iterator.
+    typedef typename Map::Reference Reference;
+    /// The pointer type of the iterator.
+    typedef typename Map::Pointer Pointer;
+
+    /// The const value type of the iterator.
+    typedef typename Map::ConstValue ConstValue;
+    /// The const reference type of the iterator.
+    typedef typename Map::ConstReference ConstReference;
+    /// The pointer type of the iterator.
+    typedef typename Map::ConstPointer ConstPointer;
 
     /// The map initialized const key set.
@@ -549,8 +549,8 @@
   public:
     // STL  compatibility typedefs.
-    typedef ValueType value_type;
+    typedef Value value_type;
     typedef ConstIterator const_iterator;
-    typedef ConstReferenceType const_reference;
-    typedef ConstPointerType const_pointer;
+    typedef ConstReference const_reference;
+    typedef ConstPointer const_pointer;
     typedef int difference_type;
   };
@@ -568,22 +568,22 @@
 
     /// The key type of the iterator.
-    typedef typename Map::KeyType KeyType;
-    /// The iterator to iterate on the keys.
-    typedef typename Map::KeyIt KeyIt;
-
-
-    /// The value type of the iterator.
-    typedef typename Map::ValueType ValueType;
-    /// The reference type of the iterator.
-    typedef typename Map::ReferenceType ReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::PointerType PointerType;
-
-    /// The const value type of the iterator.
-    typedef typename Map::ConstValueType ConstValueType;
-    /// The const reference type of the iterator.
-    typedef typename Map::ConstReferenceType ConstReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::ConstPointerType ConstPointerType;
+    typedef typename Map::Key Key;
+    /// The iterator to iterate on the keys.
+    typedef typename Map::KeyIt KeyIt;
+
+
+    /// The value type of the iterator.
+    typedef typename Map::Value Value;
+    /// The reference type of the iterator.
+    typedef typename Map::Reference Reference;
+    /// The pointer type of the iterator.
+    typedef typename Map::Pointer Pointer;
+
+    /// The const value type of the iterator.
+    typedef typename Map::ConstValue ConstValue;
+    /// The const reference type of the iterator.
+    typedef typename Map::ConstReference ConstReference;
+    /// The pointer type of the iterator.
+    typedef typename Map::ConstPointer ConstPointer;
 
     /// The map initialized const value set.
@@ -605,8 +605,8 @@
   public:
     // STL  compatibility typedefs.
-    typedef ValueType value_type;
+    typedef Value value_type;
     typedef ConstIterator const_iterator;
-    typedef ConstReferenceType const_reference;
-    typedef ConstPointerType const_pointer;
+    typedef ConstReference const_reference;
+    typedef ConstPointer const_pointer;
     typedef int difference_type;
   };
@@ -625,22 +625,22 @@
 
     /// The key type of the iterator.
-    typedef typename Map::KeyType KeyType;
-    /// The iterator to iterate on the keys.
-    typedef typename Map::KeyIt KeyIt;
-
-
-    /// The value type of the iterator.
-    typedef typename Map::ValueType ValueType;
-    /// The reference type of the iterator.
-    typedef typename Map::ReferenceType ReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::PointerType PointerType;
-
-    /// The const value type of the iterator.
-    typedef typename Map::ConstValueType ConstValueType;
-    /// The const reference type of the iterator.
-    typedef typename Map::ConstReferenceType ConstReferenceType;
-    /// The pointer type of the iterator.
-    typedef typename Map::ConstPointerType ConstPointerType;
+    typedef typename Map::Key Key;
+    /// The iterator to iterate on the keys.
+    typedef typename Map::KeyIt KeyIt;
+
+
+    /// The value type of the iterator.
+    typedef typename Map::Value Value;
+    /// The reference type of the iterator.
+    typedef typename Map::Reference Reference;
+    /// The pointer type of the iterator.
+    typedef typename Map::Pointer Pointer;
+
+    /// The const value type of the iterator.
+    typedef typename Map::ConstValue ConstValue;
+    /// The const reference type of the iterator.
+    typedef typename Map::ConstReference ConstReference;
+    /// The pointer type of the iterator.
+    typedef typename Map::ConstPointer ConstPointer;
 
     /// The map initialized value set.
@@ -675,11 +675,11 @@
   public:
     // STL  compatibility typedefs.
-    typedef ValueType value_type;
+    typedef Value value_type;
     typedef Iterator iterator;
     typedef ConstIterator const_iterator;
-    typedef ReferenceType reference;
-    typedef ConstReferenceType const_reference;
-    typedef PointerType pointer;
-    typedef ConstPointerType const_pointer;
+    typedef Reference reference;
+    typedef ConstReference const_reference;
+    typedef Pointer pointer;
+    typedef ConstPointer const_pointer;
     typedef int difference_type;
 
Index: src/lemon/maps.h
===================================================================
--- src/lemon/maps.h	(revision 977)
+++ src/lemon/maps.h	(revision 987)
@@ -37,7 +37,7 @@
   public:
     ///\e
-    typedef K KeyType;
+    typedef K Key;
     ///\e
-    typedef T ValueType;
+    typedef T Value;
   };
 
@@ -109,18 +109,18 @@
 
   /// This is essentially a wrapper for \c std::map. With addition that
-  /// you can specify a default value different from \c ValueType() .
+  /// you can specify a default value different from \c Value() .
   ///
   /// \todo Provide allocator parameter...
-  template <typename Key, typename T, typename Compare = std::less<Key> >
-  class StdMap : public std::map<Key,T,Compare> {
-    typedef std::map<Key,T,Compare> parent;
+  template <typename K, typename T, typename Compare = std::less<K> >
+  class StdMap : public std::map<K,T,Compare> {
+    typedef std::map<K,T,Compare> parent;
     T v;
     typedef typename parent::value_type PairType;
 
   public:
-    typedef Key KeyType;
-    typedef T ValueType;
-    typedef T& ReferenceType;
-    typedef const T& ConstReferenceType;
+    typedef K Key;
+    typedef T Value;
+    typedef T& Reference;
+    typedef const T& ConstReference;
 
 
@@ -144,8 +144,8 @@
     }
 
-    ReferenceType operator[](const Key &k) {
+    Reference operator[](const Key &k) {
       return insert(PairType(k,v)).first -> second;
     }
-    ConstReferenceType operator[](const Key &k) const {
+    ConstReference operator[](const Key &k) const {
       typename parent::iterator i = lower_bound(k);
       if (i == parent::end() || parent::key_comp()(k, (*i).first))
Index: src/lemon/min_cost_flow.h
===================================================================
--- src/lemon/min_cost_flow.h	(revision 986)
+++ src/lemon/min_cost_flow.h	(revision 987)
@@ -60,8 +60,8 @@
   class MinCostFlow {
 
-    typedef typename LengthMap::ValueType Length;
+    typedef typename LengthMap::Value Length;
 
     //Warning: this should be integer type
-    typedef typename CapacityMap::ValueType Capacity;
+    typedef typename CapacityMap::Value Capacity;
     
     typedef typename Graph::Node Node;
@@ -95,6 +95,6 @@
       const NodeMap &pot;
     public :
-      typedef typename LengthMap::KeyType KeyType;
-      typedef typename LengthMap::ValueType ValueType;
+      typedef typename LengthMap::Key Key;
+      typedef typename LengthMap::Value Value;
 
       ModLengthMap(const ResGW& _g, 
@@ -102,5 +102,5 @@
 	g(_g), /*rev(_rev),*/ length(_length), pot(_pot) { }
 	
-      ValueType operator[](typename ResGW::Edge e) const {     
+      Value operator[](typename ResGW::Edge e) const {     
 	if (g.forward(e))
 	  return  length[e]-(pot[g.target(e)]-pot[g.source(e)]);   
Index: src/lemon/suurballe.h
===================================================================
--- src/lemon/suurballe.h	(revision 986)
+++ src/lemon/suurballe.h	(revision 987)
@@ -59,5 +59,5 @@
 
 
-    typedef typename LengthMap::ValueType Length;
+    typedef typename LengthMap::Value Length;
     
     typedef typename Graph::Node Node;
Index: src/lemon/vector_map.h
===================================================================
--- src/lemon/vector_map.h	(revision 980)
+++ src/lemon/vector_map.h	(revision 987)
@@ -54,5 +54,5 @@
     typedef _Graph Graph;
     /// The key type of the map.
-    typedef _Item KeyType;
+    typedef _Item Key;
     /// The id map type of the map.
     typedef AlterationObserverRegistry<_Item> Registry;
@@ -72,17 +72,15 @@
   public:
 
-    /// The value type of the map.
-    typedef Value ValueType;
     /// The reference type of the map;
-    typedef typename Container::reference ReferenceType;
+    typedef typename Container::reference Reference;
     /// The pointer type of the map;
-    typedef typename Container::pointer PointerType;
+    typedef typename Container::pointer Pointer;
 
     /// The const value type of the map.
-    typedef const Value ConstValueType;
+    typedef const Value ConstValue;
     /// The const reference type of the map;
-    typedef typename Container::const_reference ConstReferenceType;
+    typedef typename Container::const_reference ConstReference;
     /// The pointer type of the map;
-    typedef typename Container::const_pointer ConstPointerType;
+    typedef typename Container::const_pointer ConstPointer;
 
     /// Constructor to attach the new map into the registry.
@@ -151,5 +149,5 @@
     /// actual items of the graph. 
      
-    ReferenceType operator[](const KeyType& key) {
+    Reference operator[](const Key& key) {
       return container[graph->id(key)];
     } 
@@ -160,5 +158,5 @@
     /// actual items of the graph. 
      
-    ConstReferenceType operator[](const KeyType& key) const {
+    ConstReference operator[](const Key& key) const {
       return container[graph->id(key)];
     }
@@ -170,5 +168,5 @@
     ///
      
-    void set(const KeyType& key, const ValueType& value) {
+    void set(const Key& key, const Value& value) {
       (*this)[key] = value;
     }
@@ -179,5 +177,5 @@
     /// and it overrides the add() member function of the observer base.
      
-    void add(const KeyType& key) {
+    void add(const Key& key) {
       int id = graph->id(key);
       if (id >= (int)container.size()) {
@@ -190,5 +188,5 @@
     /// Erase a key from the map. It called by the observer registry
     /// and it overrides the erase() member function of the observer base.     
-    void erase(const KeyType&) {}
+    void erase(const Key&) {}
 
     /// Buildes the map.
Index: src/lemon/xy.h
===================================================================
--- src/lemon/xy.h	(revision 967)
+++ src/lemon/xy.h	(revision 987)
@@ -51,5 +51,5 @@
     public:
 
-      typedef T ValueType;
+      typedef T Value;
 
       T x,y;     
Index: src/test/sym_graph_test.h
===================================================================
--- src/test/sym_graph_test.h	(revision 986)
+++ src/test/sym_graph_test.h	(revision 987)
@@ -96,7 +96,7 @@
 	{
 	  //Check the typedef's
-	  typename Graph::template SymEdgeMap<int>::ValueType val;
+	  typename Graph::template SymEdgeMap<int>::Value val;
 	  val = 1;
-	  typename Graph::template SymEdgeMap<int>::KeyType key;
+	  typename Graph::template SymEdgeMap<int>::Key key;
 	  key = typename Graph::SymEdgeIt(G);
 	}
@@ -119,7 +119,7 @@
 	{
 	  //Check the typedef's
-	  typename Graph::template SymEdgeMap<bool>::ValueType val;
+	  typename Graph::template SymEdgeMap<bool>::Value val;
 	  val=true;
-	  typename Graph::template SymEdgeMap<bool>::KeyType key;
+	  typename Graph::template SymEdgeMap<bool>::Key key;
 	  key= typename Graph::SymEdgeIt(G);
 	}
Index: src/work/alpar/boolmap_iter.cc
===================================================================
--- src/work/alpar/boolmap_iter.cc	(revision 986)
+++ src/work/alpar/boolmap_iter.cc	(revision 987)
@@ -14,6 +14,6 @@
   typedef typename GG::Edge Edge;
   
-  typedef Edge KeyType;
-  typedef bool ValueType;
+  typedef Edge Key;
+  typedef bool Value;
   
   friend class RefType;
@@ -68,10 +68,10 @@
     RefType(BoolIterEdgeMap &_M,Edge _e) : M(_M), e(_e) { }
     
-    operator ValueType() const 
+    operator Value() const 
     {
       return M.isTrue(e);
       
     }
-    ValueType operator = (ValueType v) const
+    Value operator = (Value v) const
     {
       if(v) M.setTrue(e); 
Index: src/work/alpar/dijkstra.h
===================================================================
--- src/work/alpar/dijkstra.h	(revision 986)
+++ src/work/alpar/dijkstra.h	(revision 987)
@@ -47,5 +47,5 @@
     typedef LM LengthMap;
     //The type of the length of the edges.
-    typedef typename LM::ValueType ValueType;
+    typedef typename LM::Value Value;
     ///The heap type used by Dijkstra algorithm.
 
@@ -55,7 +55,7 @@
     ///\sa Dijkstra
     typedef BinHeap<typename Graph::Node,
-		    typename LM::ValueType,
+		    typename LM::Value,
 		    typename GR::template NodeMap<int>,
-		    std::less<ValueType> > Heap;
+		    std::less<Value> > Heap;
 
     ///\brief The type of the map that stores the last
@@ -91,5 +91,5 @@
     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     ///
-    typedef typename Graph::template NodeMap<typename LM::ValueType> DistMap;
+    typedef typename Graph::template NodeMap<typename LM::Value> DistMap;
     ///Instantiates a DistMap.
  
@@ -110,5 +110,5 @@
   ///
   ///The type of the length is determined by the
-  ///\ref concept::ReadMap::ValueType "ValueType" of the length map.
+  ///\ref concept::ReadMap::Value "Value" of the length map.
   ///
   ///It is also possible to change the underlying priority heap.
@@ -159,5 +159,5 @@
     
     ///The type of the length of the edges.
-    typedef typename TR::LengthMap::ValueType ValueType;
+    typedef typename TR::LengthMap::Value Value;
     ///The type of the map that stores the edge lengths.
     typedef typename TR::LengthMap LengthMap;
@@ -388,5 +388,5 @@
 	
 	Node v=heap.top(); 
-	ValueType oldvalue=heap[v];
+	Value oldvalue=heap[v];
 	heap.pop();
 	distance->set(v, oldvalue);
@@ -421,5 +421,5 @@
     ///\warning If node \c v in unreachable from the root the return value
     ///of this funcion is undefined.
-    ValueType dist(Node v) const { return (*distance)[v]; }
+    Value dist(Node v) const { return (*distance)[v]; }
 
     ///Returns the 'previous edge' of the shortest path tree.
@@ -498,5 +498,5 @@
     typedef typename TR::LengthMap LengthMap;
     ///The type of the length of the edges.
-    typedef typename LengthMap::ValueType ValueType;
+    typedef typename LengthMap::Value Value;
     ///\brief The type of the map that stores the last
     ///edges of the shortest paths.
Index: src/work/alpar/f_ed_ka.h
===================================================================
--- src/work/alpar/f_ed_ka.h	(revision 986)
+++ src/work/alpar/f_ed_ka.h	(revision 987)
@@ -14,5 +14,5 @@
 namespace lemon {
   template <typename Graph, typename FlowMap, typename CapacityMap>
-  typename FlowMap::ValueType maxFlow(Graph &G,
+  typename FlowMap::Value maxFlow(Graph &G,
 				      FlowMap &f,
 				      CapacityMap &c,
@@ -26,5 +26,5 @@
     typedef typename Graph::OutEdgeIt OutEdgeIt;
     typedef typename Graph::InEdgeIt InEdgeIt;
-    typedef typename FlowMap::ValueType T;
+    typedef typename FlowMap::Value T;
     
     T flow_val = 0;
Index: src/work/alpar/rw_nonref_map.cc
===================================================================
--- src/work/alpar/rw_nonref_map.cc	(revision 986)
+++ src/work/alpar/rw_nonref_map.cc	(revision 987)
@@ -11,6 +11,6 @@
   typedef typename GG::Edge Edge;
   
-  typedef Edge KeyType;
-  typedef TT ValueType;
+  typedef Edge Key;
+  typedef TT Value;
   
   class RefType 
@@ -21,7 +21,7 @@
     RefType(Graph &_G,Edge _e) : G(_G), e(_e) { }
     
-    operator ValueType() const 
+    operator Value() const 
     {
-      ValueType tmp;
+      Value tmp;
       std::cout << G.id(G.source(e)) << "->"
 		<< G.id(G.target(e)) << ": ";
@@ -29,5 +29,5 @@
       return tmp;
     }
-    ValueType operator = (ValueType v) const
+    Value operator = (Value v) const
     {
       std::cout << G.id(G.source(e)) << "->"
@@ -48,21 +48,21 @@
 {
 public:
-  typedef K KeyType;
-  typedef T ValueType;
+  typedef K Key;
+  typedef T Value;
   
   class RefType 
   {
-    ValueType val;
+    Value val;
   public:
-    RefType(ValueType v) : val(v) { }   
-    operator ValueType() const { return val; }
-    ValueType operator = (ValueType v) const { return val; }
+    RefType(Value v) : val(v) { }   
+    operator Value() const { return val; }
+    Value operator = (Value v) const { return val; }
   };
   
 private:
-  ValueType val;
+  Value val;
 public:
-  NullMap(ValueType v) : val(v) { }
-  RefType operator[] (KeyType e) const { return RefType(v);}  
+  NullMap(Value v) : val(v) { }
+  RefType operator[] (Key e) const { return RefType(v);}  
 };
 
Index: src/work/athos/mincostflow.h
===================================================================
--- src/work/athos/mincostflow.h	(revision 986)
+++ src/work/athos/mincostflow.h	(revision 987)
@@ -44,8 +44,8 @@
   class MinCostFlow {
 
-    typedef typename CostMap::ValueType Cost;
-
-
-    typedef typename SupplyDemandMap::ValueType SupplyDemand;
+    typedef typename CostMap::Value Cost;
+
+
+    typedef typename SupplyDemandMap::Value SupplyDemand;
     
     typedef typename Graph::Node Node;
@@ -69,8 +69,8 @@
       const NodeMap &pot;
     public :
-      typedef typename CostMap::KeyType KeyType;
-      typedef typename CostMap::ValueType ValueType;
+      typedef typename CostMap::Key Key;
+      typedef typename CostMap::Value Value;
 	
-      ValueType operator[](typename ResGraph::Edge e) const {     
+      Value operator[](typename ResGraph::Edge e) const {     
 	if (res_graph.forward(e))
 	  return  ol[e]-(pot[res_graph.target(e)]-pot[res_graph.source(e)]);   
Index: src/work/athos/old/minlengthpaths.h
===================================================================
--- src/work/athos/old/minlengthpaths.h	(revision 986)
+++ src/work/athos/old/minlengthpaths.h	(revision 987)
@@ -31,5 +31,5 @@
   class MinLengthPaths {
 
-    typedef typename LengthMap::ValueType Length;
+    typedef typename LengthMap::Value Length;
     
     typedef typename Graph::Node Node;
@@ -50,8 +50,8 @@
       const NodeMap &pot;
     public :
-      typedef typename LengthMap::KeyType KeyType;
-      typedef typename LengthMap::ValueType ValueType;
-	
-      ValueType operator[](typename ResGraphType::Edge e) const {     
+      typedef typename LengthMap::Key Key;
+      typedef typename LengthMap::Value Value;
+	
+      Value operator[](typename ResGraphType::Edge e) const {     
 	//if ( (1-2*rev[e])*ol[e]-(pot[G.target(e)]-pot[G.source(e)] ) <0 ){
 	//  std::cout<<"Negative length!!"<<std::endl;
Index: src/work/athos/union_find.h
===================================================================
--- src/work/athos/union_find.h	(revision 921)
+++ src/work/athos/union_find.h	(revision 987)
@@ -16,5 +16,5 @@
 namespace lemon {
   
-  template <typename KeyType, typename KeyIntMap>
+  template <typename Key, typename KeyIntMap>
     class UnionFind {
     KeyIntMap& pointmap;
@@ -35,5 +35,5 @@
     
     //Give a component of one point to the structure
-    int addPoint(KeyType u){
+    int addPoint(Key u){
       int _index = container.size();
       VectorElementType buf(_index,1);
@@ -44,5 +44,5 @@
     
     //Finds the big boss of u
-    int find(KeyType u){
+    int find(Key u){
       if (pointmap.get(u)==-1){
 	int whoami = addPoint(u);
@@ -62,5 +62,5 @@
 
     //Finds u and v in the structures and merges the comopnents, if not equal
-    bool findAndMerge(KeyType u,KeyType v){
+    bool findAndMerge(Key u,Key v){
       int bu = find(u);
       int bv = find(v);
Index: src/work/deba/dijkstra.h
===================================================================
--- src/work/deba/dijkstra.h	(revision 921)
+++ src/work/deba/dijkstra.h	(revision 987)
@@ -22,5 +22,5 @@
   ///so it is easy to change it to any kind of length.
   ///
-  ///The type of the length is determined by the \c ValueType of the length map.
+  ///The type of the length is determined by the \c Value of the length map.
   ///
   ///It is also possible to change the underlying priority heap.
@@ -60,5 +60,5 @@
     
     ///The type of the length of the edges.
-    typedef typename LM::ValueType ValueType;
+    typedef typename LM::Value Value;
     ///The type of the map that stores the edge lengths.
     typedef LM LengthMap;
@@ -70,5 +70,5 @@
     typedef typename Graph::template NodeMap<Node> PredNodeMap;
     ///The type of the map that stores the dists of the nodes.
-    typedef typename Graph::template NodeMap<ValueType> DistMap;
+    typedef typename Graph::template NodeMap<Value> DistMap;
 
   private:
@@ -217,6 +217,6 @@
       typename GR::template NodeMap<int> heap_map(*G,-1);
       
-      typedef Heap<Node, ValueType, typename GR::template NodeMap<int>,
-      std::less<ValueType> > 
+      typedef Heap<Node, Value, typename GR::template NodeMap<int>,
+      std::less<Value> > 
       HeapType;
       
@@ -228,5 +228,5 @@
 	
 	Node v=heap.top(); 
-	ValueType oldvalue=heap[v];
+	Value oldvalue=heap[v];
 	heap.pop();
 	distance->set(v, oldvalue);
@@ -262,5 +262,5 @@
     ///\warning If node \c v in unreachable from the root the return value
     ///of this funcion is undefined.
-    ValueType dist(Node v) const { return (*distance)[v]; }
+    Value dist(Node v) const { return (*distance)[v]; }
 
     ///Returns the 'previous edge' of the shortest path tree.
Index: src/work/klao/iter_map.h
===================================================================
--- src/work/klao/iter_map.h	(revision 921)
+++ src/work/klao/iter_map.h	(revision 987)
@@ -26,12 +26,12 @@
   public:
 
-    typedef typename KeyIntMap::KeyType KeyType;
-    typedef Val ValueType;
+    typedef typename KeyIntMap::Key Key;
+    typedef Val Value;
 
-    typedef typename std::vector<KeyType>::const_iterator iterator;
+    typedef typename std::vector<Key>::const_iterator iterator;
 
   protected:
     KeyIntMap &base;
-    std::vector<KeyType> data;
+    std::vector<Key> data;
     size_t bounds[N];
     Val def_val;
@@ -56,5 +56,5 @@
       if(m != n) {
 	size_t orig_a = a;
-	KeyType orig_key = data[a];
+	Key orig_key = data[a];
 	while(m > n) {
 	  --m;
@@ -81,9 +81,9 @@
     }
 
-    Val operator[](const KeyType& k) const {
+    Val operator[](const Key& k) const {
       return find(base[k]);
     }
 
-    void set(const KeyType& k, Val n) {
+    void set(const Key& k, Val n) {
       // FIXME: range check?
       size_t a = base[k];
@@ -96,5 +96,5 @@
     }
 
-    void insert(const KeyType& k, Val n) {
+    void insert(const Key& k, Val n) {
       data.push_back(k);
       base.set(k, move(bounds[N-1]++, N-1, n));
@@ -103,5 +103,5 @@
     /// This func is not very usable, but necessary to implement 
     /// dynamic map behaviour.
-    void remove(const KeyType& k) {
+    void remove(const Key& k) {
       size_t a = base[k];
       if(a < bounds[N-1]) {
@@ -131,5 +131,5 @@
 
     /// For use as an iterator...
-    KeyType& first(KeyType &k, Val n) {
+    Key& first(Key &k, Val n) {
       size_t i = (n ? bounds[n-1] : 0);
       if( i < bounds[n] ) {
@@ -143,5 +143,5 @@
 
     /// For use as an iterator...
-    KeyType& next(KeyType &k) {
+    Key& next(Key &k) {
       size_t i = base[k];
       uint8_t n = find(i);
Index: src/work/marci/augmenting_flow.h
===================================================================
--- src/work/marci/augmenting_flow.h	(revision 986)
+++ src/work/marci/augmenting_flow.h	(revision 987)
@@ -113,6 +113,6 @@
       int* number_of_augmentations;
     public:
-      typedef Node KeyType;
-      typedef bool ValueType;
+      typedef Node Key;
+      typedef bool Value;
       TrickyReachedMap(IntMap& _map, int& _number_of_augmentations) : 
 	map(&_map), number_of_augmentations(&_number_of_augmentations) { }
Index: src/work/marci/bfs_mm.h
===================================================================
--- src/work/marci/bfs_mm.h	(revision 986)
+++ src/work/marci/bfs_mm.h	(revision 987)
@@ -141,5 +141,5 @@
     /// Guess what?
     /// \deprecated 
-    typename ReachedMap::ValueType reached(const Node& n) const { 
+    typename ReachedMap::Value reached(const Node& n) const { 
       return (*reached_map)[n]; 
     }
@@ -243,5 +243,5 @@
     /// Guess what?
     /// \deprecated 
-    typename PredMap::ValueType pred(const Node& n) const { 
+    typename PredMap::Value pred(const Node& n) const { 
       return (*pred_map)[n]; 
     }
@@ -251,5 +251,5 @@
     /// Guess what?
     /// \deprecated 
-    typename PredNodeMap::ValueType predNode(const Node& n) const { 
+    typename PredNodeMap::Value predNode(const Node& n) const { 
       return (*pred_node_map)[n]; 
     }
@@ -259,5 +259,5 @@
     /// Guess what?
     /// \deprecated 
-    typename DistMap::ValueType dist(const Node& n) const { 
+    typename DistMap::Value dist(const Node& n) const { 
       return (*dist_map)[n]; 
     }
Index: src/work/marci/bipartite_graph_wrapper.h
===================================================================
--- src/work/marci/bipartite_graph_wrapper.h	(revision 986)
+++ src/work/marci/bipartite_graph_wrapper.h	(revision 987)
@@ -795,13 +795,13 @@
     template<typename NM> class NodeMapWrapper { 
     public:
-      typedef Node KeyType;
-      typedef typename NM::ValueType ValueType;
+      typedef Node Key;
+      typedef typename NM::Value Value;
     protected:
       NM* nm;
-      ValueType* s_value, t_value;
-    public:
-      NodeMapWrapper(NM& _nm, ValueType& _s_value, ValueType& _t_value) : 
+      Value* s_value, t_value;
+    public:
+      NodeMapWrapper(NM& _nm, Value& _s_value, Value& _t_value) : 
 	nm(&_nm), s_value(&_s_value), t_value(&_t_value) { }
-      ValueType operator[](const Node& n) const { 
+      Value operator[](const Node& n) const { 
 	switch (n.getSpec()) {
 	case 0: 
@@ -814,5 +814,5 @@
 	}
       }
-      void set(const Node& n, ValueType t) { 
+      void set(const Node& n, Value t) { 
 	switch (n.getSpec()) {
 	case 0: 
@@ -874,6 +874,6 @@
     class EdgeMapWrapper {
     public: 
-      typedef Edge KeyType;
-      typedef typename EM::ValueType ValueType;
+      typedef Edge Key;
+      typedef typename EM::Value Value;
     protected:
       EM* em;
@@ -881,5 +881,5 @@
     public:
       EdgeMapWrapper(EM& _em, NM& _nm) : em(&_em), nm(&_nm) { }
-      ValueType operator[](const Edge& e) const { 
+      Value operator[](const Edge& e) const { 
 	switch (e.getSpec()) {
 	case 0: 
@@ -892,5 +892,5 @@
 	}
       }
-      void set(const Edge& e, ValueType t) { 
+      void set(const Edge& e, Value t) { 
 	switch (e.getSpec()) {
 	case 0: 
Index: src/work/marci/experiment/list_graph.h
===================================================================
--- src/work/marci/experiment/list_graph.h	(revision 986)
+++ src/work/marci/experiment/list_graph.h	(revision 987)
@@ -39,6 +39,6 @@
       std::vector<T> container;
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
       NodeMap(const ListGraph& _G) : G(_G), container(G.node_id) { }
       NodeMap(const ListGraph& _G, T a) : 
@@ -60,6 +60,6 @@
       std::vector<T> container;
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
       EdgeMap(const ListGraph& _G) : G(_G), container(G.edge_id) { }
       EdgeMap(const ListGraph& _G, T a) : 
Index: src/work/marci/graph_concept.h
===================================================================
--- src/work/marci/graph_concept.h	(revision 986)
+++ src/work/marci/graph_concept.h	(revision 987)
@@ -168,6 +168,6 @@
     {
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
 
       NodeMap(const GraphConcept& g) { }
@@ -206,6 +206,6 @@
     {
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
 
       EdgeMap(const GraphConcept& g) {}
Index: src/work/marci/leda/leda_graph_wrapper.h
===================================================================
--- src/work/marci/leda/leda_graph_wrapper.h	(revision 986)
+++ src/work/marci/leda/leda_graph_wrapper.h	(revision 987)
@@ -262,6 +262,6 @@
       leda_node_map<T> leda_stuff;
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
 
       NodeMap(const LedaGraphWrapper &G) : leda_stuff(*(G.l_graph)) {}
@@ -282,6 +282,6 @@
       leda_edge_map<T> leda_stuff;
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
 
       EdgeMap(const LedaGraphWrapper &G) : leda_stuff(*(G.l_graph)) {}
@@ -304,6 +304,6 @@
       leda_node_array<T>* leda_stuff;
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
 
       NodeMapWrapper(leda_node_array<T>& _leda_stuff) : 
@@ -326,6 +326,6 @@
       leda_edge_array<T>* leda_stuff;
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
 
       EdgeMapWrapper(leda_edge_array<T>& _leda_stuff) : 
Index: src/work/peter/edgepathgraph.h
===================================================================
--- src/work/peter/edgepathgraph.h	(revision 986)
+++ src/work/peter/edgepathgraph.h	(revision 987)
@@ -307,6 +307,6 @@
     {
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
 
       NodeMap(const EdgePathGraph &) {}
@@ -345,6 +345,6 @@
     {
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
 
       EdgeMap(const EdgePathGraph &) {}
Index: src/work/peter/hierarchygraph.h
===================================================================
--- src/work/peter/hierarchygraph.h	(revision 986)
+++ src/work/peter/hierarchygraph.h	(revision 987)
@@ -434,6 +434,6 @@
     {
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
 
       NodeMap (const HierarchyGraph &)
@@ -490,6 +490,6 @@
     {
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
 
       EdgeMap (const HierarchyGraph &)
Index: src/work/sage_graph.h
===================================================================
--- src/work/sage_graph.h	(revision 986)
+++ src/work/sage_graph.h	(revision 987)
@@ -39,6 +39,6 @@
       std::vector<T> container;
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
       NodeMap(const SageGraph& _G) : G(_G), container(G.node_id) { }
       NodeMap(const SageGraph& _G, T a) : 
@@ -60,6 +60,6 @@
       std::vector<T> container;
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
       EdgeMap(const SageGraph& _G) : G(_G), container(G.edge_id) { }
       EdgeMap(const SageGraph& _G, T a) : 
