Index: lemon/bfs.h
===================================================================
--- lemon/bfs.h	(revision 252)
+++ lemon/bfs.h	(revision 257)
@@ -231,5 +231,5 @@
 
     template <class T>
-    struct DefPredMapTraits : public Traits {
+    struct SetPredMapTraits : public Traits {
       typedef T PredMap;
       static PredMap *createPredMap(const Digraph &)
@@ -244,10 +244,10 @@
     ///\ref PredMap type.
     template <class T>
-    struct DefPredMap : public Bfs< Digraph, DefPredMapTraits<T> > {
-      typedef Bfs< Digraph, DefPredMapTraits<T> > Create;
+    struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
+      typedef Bfs< Digraph, SetPredMapTraits<T> > Create;
     };
 
     template <class T>
-    struct DefDistMapTraits : public Traits {
+    struct SetDistMapTraits : public Traits {
       typedef T DistMap;
       static DistMap *createDistMap(const Digraph &)
@@ -262,10 +262,10 @@
     ///\ref DistMap type.
     template <class T>
-    struct DefDistMap : public Bfs< Digraph, DefDistMapTraits<T> > {
-      typedef Bfs< Digraph, DefDistMapTraits<T> > Create;
+    struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
+      typedef Bfs< Digraph, SetDistMapTraits<T> > Create;
     };
 
     template <class T>
-    struct DefReachedMapTraits : public Traits {
+    struct SetReachedMapTraits : public Traits {
       typedef T ReachedMap;
       static ReachedMap *createReachedMap(const Digraph &)
@@ -280,10 +280,10 @@
     ///\ref ReachedMap type.
     template <class T>
-    struct DefReachedMap : public Bfs< Digraph, DefReachedMapTraits<T> > {
-      typedef Bfs< Digraph, DefReachedMapTraits<T> > Create;
+    struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
+      typedef Bfs< Digraph, SetReachedMapTraits<T> > Create;
     };
 
     template <class T>
-    struct DefProcessedMapTraits : public Traits {
+    struct SetProcessedMapTraits : public Traits {
       typedef T ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &)
@@ -298,9 +298,9 @@
     ///\ref ProcessedMap type.
     template <class T>
-    struct DefProcessedMap : public Bfs< Digraph, DefProcessedMapTraits<T> > {
-      typedef Bfs< Digraph, DefProcessedMapTraits<T> > Create;
-    };
-
-    struct DefDigraphProcessedMapTraits : public Traits {
+    struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
+      typedef Bfs< Digraph, SetProcessedMapTraits<T> > Create;
+    };
+
+    struct SetStandardProcessedMapTraits : public Traits {
       typedef typename Digraph::template NodeMap<bool> ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &g)
@@ -315,8 +315,7 @@
     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///If you don't set it explicitly, it will be automatically allocated.
-    template <class T>
-    struct DefProcessedMapToBeDefaultMap :
-      public Bfs< Digraph, DefDigraphProcessedMapTraits> {
-      typedef Bfs< Digraph, DefDigraphProcessedMapTraits> Create;
+    struct SetStandardProcessedMap :
+      public Bfs< Digraph, SetStandardProcessedMapTraits > {
+      typedef Bfs< Digraph, SetStandardProcessedMapTraits > Create;
     };
 
@@ -1066,8 +1065,8 @@
 
     template<class T>
-    struct DefPredMapBase : public Base {
+    struct SetPredMapBase : public Base {
       typedef T PredMap;
       static PredMap *createPredMap(const Digraph &) { return 0; };
-      DefPredMapBase(const TR &b) : TR(b) {}
+      SetPredMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
@@ -1077,15 +1076,15 @@
     ///for setting \ref PredMap object.
     template<class T>
-    BfsWizard<DefPredMapBase<T> > predMap(const T &t)
+    BfsWizard<SetPredMapBase<T> > predMap(const T &t)
     {
       Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return BfsWizard<DefPredMapBase<T> >(*this);
+      return BfsWizard<SetPredMapBase<T> >(*this);
     }
 
     template<class T>
-    struct DefReachedMapBase : public Base {
+    struct SetReachedMapBase : public Base {
       typedef T ReachedMap;
       static ReachedMap *createReachedMap(const Digraph &) { return 0; };
-      DefReachedMapBase(const TR &b) : TR(b) {}
+      SetReachedMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
@@ -1095,15 +1094,15 @@
     ///for setting \ref ReachedMap object.
     template<class T>
-    BfsWizard<DefReachedMapBase<T> > reachedMap(const T &t)
+    BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
     {
       Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return BfsWizard<DefReachedMapBase<T> >(*this);
+      return BfsWizard<SetReachedMapBase<T> >(*this);
     }
 
     template<class T>
-    struct DefProcessedMapBase : public Base {
+    struct SetProcessedMapBase : public Base {
       typedef T ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
-      DefProcessedMapBase(const TR &b) : TR(b) {}
+      SetProcessedMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
@@ -1113,15 +1112,15 @@
     ///for setting \ref ProcessedMap object.
     template<class T>
-    BfsWizard<DefProcessedMapBase<T> > processedMap(const T &t)
+    BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
     {
       Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return BfsWizard<DefProcessedMapBase<T> >(*this);
+      return BfsWizard<SetProcessedMapBase<T> >(*this);
     }
 
     template<class T>
-    struct DefDistMapBase : public Base {
+    struct SetDistMapBase : public Base {
       typedef T DistMap;
       static DistMap *createDistMap(const Digraph &) { return 0; };
-      DefDistMapBase(const TR &b) : TR(b) {}
+      SetDistMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
@@ -1131,8 +1130,8 @@
     ///for setting \ref DistMap object.
     template<class T>
-    BfsWizard<DefDistMapBase<T> > distMap(const T &t)
+    BfsWizard<SetDistMapBase<T> > distMap(const T &t)
     {
       Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return BfsWizard<DefDistMapBase<T> >(*this);
+      return BfsWizard<SetDistMapBase<T> >(*this);
     }
 
@@ -1262,9 +1261,4 @@
   /// class. It works with callback mechanism, the BfsVisit object calls
   /// the member functions of the \c Visitor class on every BFS event.
-  ///
-  /// This interface of the BFS algorithm should be used in special cases
-  /// when extra actions have to be performed in connection with certain
-  /// events of the BFS algorithm. Otherwise consider to use Bfs or bfs()
-  /// instead.
   ///
   /// \tparam _Digraph The type of the digraph the algorithm runs on.
@@ -1355,5 +1349,5 @@
     ///@{
     template <class T>
-    struct DefReachedMapTraits : public Traits {
+    struct SetReachedMapTraits : public Traits {
       typedef T ReachedMap;
       static ReachedMap *createReachedMap(const Digraph &digraph) {
@@ -1366,7 +1360,7 @@
     /// \ref named-templ-param "Named parameter" for setting ReachedMap type.
     template <class T>
-    struct DefReachedMap : public BfsVisit< Digraph, Visitor,
-                                            DefReachedMapTraits<T> > {
-      typedef BfsVisit< Digraph, Visitor, DefReachedMapTraits<T> > Create;
+    struct SetReachedMap : public BfsVisit< Digraph, Visitor,
+                                            SetReachedMapTraits<T> > {
+      typedef BfsVisit< Digraph, Visitor, SetReachedMapTraits<T> > Create;
     };
     ///@}
Index: lemon/bits/base_extender.h
===================================================================
--- lemon/bits/base_extender.h	(revision 256)
+++ lemon/bits/base_extender.h	(revision 220)
@@ -60,5 +60,5 @@
       Arc() {}
 
-      // Invalid arc constructor
+      /// Invalid arc constructor
       Arc(Invalid i) : Edge(i), forward(true) {}
 
@@ -75,20 +75,16 @@
     };
 
-    /// First node of the edge
-    Node u(const Edge &e) const {
-      return Parent::source(e);
-    }
-
-    /// Source of the given arc
+
+
+    using Parent::source;
+
+    /// Source of the given Arc.
     Node source(const Arc &e) const {
       return e.forward ? Parent::source(e) : Parent::target(e);
     }
 
-    /// Second node of the edge
-    Node v(const Edge &e) const {
-      return Parent::target(e);
-    }
-
-    /// Target of the given arc
+    using Parent::target;
+
+    /// Target of the given Arc.
     Node target(const Arc &e) const {
       return e.forward ? Parent::target(e) : Parent::source(e);
@@ -97,17 +93,18 @@
     /// \brief Directed arc from an edge.
     ///
-    /// Returns a directed arc corresponding to the specified edge.
-    /// If the given bool is true, the first node of the given edge and
-    /// the source node of the returned arc are the same.
-    static Arc direct(const Edge &e, bool d) {
-      return Arc(e, d);
-    }
-
-    /// Returns whether the given directed arc has the same orientation
-    /// as the corresponding edge.
+    /// Returns a directed arc corresponding to the specified Edge.
+    /// If the given bool is true the given edge and the
+    /// returned arc have the same source node.
+    static Arc direct(const Edge &ue, bool d) {
+      return Arc(ue, d);
+    }
+
+    /// Returns whether the given directed arc is same orientation as the
+    /// corresponding edge.
     ///
     /// \todo reference to the corresponding point of the undirected digraph
     /// concept. "What does the direction of an edge mean?"
-    static bool direction(const Arc &a) { return a.forward; }
+    static bool direction(const Arc &e) { return e.forward; }
+
 
     using Parent::first;
@@ -232,4 +229,5 @@
       return Parent::maxArcId();
     }
+
 
     int arcNum() const {
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 252)
+++ lemon/dfs.h	(revision 257)
@@ -231,5 +231,5 @@
 
     template <class T>
-    struct DefPredMapTraits : public Traits {
+    struct SetPredMapTraits : public Traits {
       typedef T PredMap;
       static PredMap *createPredMap(const Digraph &)
@@ -244,10 +244,10 @@
     ///\ref PredMap type.
     template <class T>
-    struct DefPredMap : public Dfs<Digraph, DefPredMapTraits<T> > {
-      typedef Dfs<Digraph, DefPredMapTraits<T> > Create;
+    struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
+      typedef Dfs<Digraph, SetPredMapTraits<T> > Create;
     };
 
     template <class T>
-    struct DefDistMapTraits : public Traits {
+    struct SetDistMapTraits : public Traits {
       typedef T DistMap;
       static DistMap *createDistMap(const Digraph &)
@@ -262,10 +262,10 @@
     ///\ref DistMap type.
     template <class T>
-    struct DefDistMap : public Dfs< Digraph, DefDistMapTraits<T> > {
-      typedef Dfs<Digraph, DefDistMapTraits<T> > Create;
+    struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
+      typedef Dfs<Digraph, SetDistMapTraits<T> > Create;
     };
 
     template <class T>
-    struct DefReachedMapTraits : public Traits {
+    struct SetReachedMapTraits : public Traits {
       typedef T ReachedMap;
       static ReachedMap *createReachedMap(const Digraph &)
@@ -280,10 +280,10 @@
     ///\ref ReachedMap type.
     template <class T>
-    struct DefReachedMap : public Dfs< Digraph, DefReachedMapTraits<T> > {
-      typedef Dfs< Digraph, DefReachedMapTraits<T> > Create;
+    struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
+      typedef Dfs< Digraph, SetReachedMapTraits<T> > Create;
     };
 
     template <class T>
-    struct DefProcessedMapTraits : public Traits {
+    struct SetProcessedMapTraits : public Traits {
       typedef T ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &)
@@ -298,9 +298,9 @@
     ///\ref ProcessedMap type.
     template <class T>
-    struct DefProcessedMap : public Dfs< Digraph, DefProcessedMapTraits<T> > {
-      typedef Dfs< Digraph, DefProcessedMapTraits<T> > Create;
-    };
-
-    struct DefDigraphProcessedMapTraits : public Traits {
+    struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
+      typedef Dfs< Digraph, SetProcessedMapTraits<T> > Create;
+    };
+
+    struct SetStandardProcessedMapTraits : public Traits {
       typedef typename Digraph::template NodeMap<bool> ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &g)
@@ -315,8 +315,7 @@
     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///If you don't set it explicitly, it will be automatically allocated.
-    template <class T>
-    struct DefProcessedMapToBeDefaultMap :
-      public Dfs< Digraph, DefDigraphProcessedMapTraits> {
-      typedef Dfs< Digraph, DefDigraphProcessedMapTraits> Create;
+    struct SetStandardProcessedMap :
+      public Dfs< Digraph, SetStandardProcessedMapTraits > {
+      typedef Dfs< Digraph, SetStandardProcessedMapTraits > Create;
     };
 
@@ -1001,8 +1000,8 @@
 
     template<class T>
-    struct DefPredMapBase : public Base {
+    struct SetPredMapBase : public Base {
       typedef T PredMap;
       static PredMap *createPredMap(const Digraph &) { return 0; };
-      DefPredMapBase(const TR &b) : TR(b) {}
+      SetPredMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
@@ -1012,15 +1011,15 @@
     ///for setting \ref PredMap object.
     template<class T>
-    DfsWizard<DefPredMapBase<T> > predMap(const T &t)
+    DfsWizard<SetPredMapBase<T> > predMap(const T &t)
     {
       Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return DfsWizard<DefPredMapBase<T> >(*this);
+      return DfsWizard<SetPredMapBase<T> >(*this);
     }
 
     template<class T>
-    struct DefReachedMapBase : public Base {
+    struct SetReachedMapBase : public Base {
       typedef T ReachedMap;
       static ReachedMap *createReachedMap(const Digraph &) { return 0; };
-      DefReachedMapBase(const TR &b) : TR(b) {}
+      SetReachedMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
@@ -1030,15 +1029,15 @@
     ///for setting \ref ReachedMap object.
     template<class T>
-    DfsWizard<DefReachedMapBase<T> > reachedMap(const T &t)
+    DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
     {
       Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return DfsWizard<DefReachedMapBase<T> >(*this);
+      return DfsWizard<SetReachedMapBase<T> >(*this);
     }
 
     template<class T>
-    struct DefProcessedMapBase : public Base {
+    struct SetProcessedMapBase : public Base {
       typedef T ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
-      DefProcessedMapBase(const TR &b) : TR(b) {}
+      SetProcessedMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
@@ -1048,15 +1047,15 @@
     ///for setting \ref ProcessedMap object.
     template<class T>
-    DfsWizard<DefProcessedMapBase<T> > processedMap(const T &t)
+    DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
     {
       Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return DfsWizard<DefProcessedMapBase<T> >(*this);
+      return DfsWizard<SetProcessedMapBase<T> >(*this);
     }
 
     template<class T>
-    struct DefDistMapBase : public Base {
+    struct SetDistMapBase : public Base {
       typedef T DistMap;
       static DistMap *createDistMap(const Digraph &) { return 0; };
-      DefDistMapBase(const TR &b) : TR(b) {}
+      SetDistMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
@@ -1066,8 +1065,8 @@
     ///for setting \ref DistMap object.
     template<class T>
-    DfsWizard<DefDistMapBase<T> > distMap(const T &t)
+    DfsWizard<SetDistMapBase<T> > distMap(const T &t)
     {
       Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return DfsWizard<DefDistMapBase<T> >(*this);
+      return DfsWizard<SetDistMapBase<T> >(*this);
     }
 
@@ -1209,9 +1208,4 @@
   /// class. It works with callback mechanism, the DfsVisit object calls
   /// the member functions of the \c Visitor class on every DFS event.
-  ///
-  /// This interface of the DFS algorithm should be used in special cases
-  /// when extra actions have to be performed in connection with certain
-  /// events of the DFS algorithm. Otherwise consider to use Dfs or dfs()
-  /// instead.
   ///
   /// \tparam _Digraph The type of the digraph the algorithm runs on.
@@ -1302,5 +1296,5 @@
     ///@{
     template <class T>
-    struct DefReachedMapTraits : public Traits {
+    struct SetReachedMapTraits : public Traits {
       typedef T ReachedMap;
       static ReachedMap *createReachedMap(const Digraph &digraph) {
@@ -1313,7 +1307,7 @@
     /// \ref named-templ-param "Named parameter" for setting ReachedMap type.
     template <class T>
-    struct DefReachedMap : public DfsVisit< Digraph, Visitor,
-                                            DefReachedMapTraits<T> > {
-      typedef DfsVisit< Digraph, Visitor, DefReachedMapTraits<T> > Create;
+    struct SetReachedMap : public DfsVisit< Digraph, Visitor,
+                                            SetReachedMapTraits<T> > {
+      typedef DfsVisit< Digraph, Visitor, SetReachedMapTraits<T> > Create;
     };
     ///@}
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 251)
+++ lemon/dijkstra.h	(revision 257)
@@ -332,5 +332,5 @@
 
     template <class T>
-    struct DefPredMapTraits : public Traits {
+    struct SetPredMapTraits : public Traits {
       typedef T PredMap;
       static PredMap *createPredMap(const Digraph &)
@@ -345,11 +345,11 @@
     ///\ref PredMap type.
     template <class T>
-    struct DefPredMap
-      : public Dijkstra< Digraph, LengthMap, DefPredMapTraits<T> > {
-      typedef Dijkstra< Digraph, LengthMap, DefPredMapTraits<T> > Create;
+    struct SetPredMap
+      : public Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > {
+      typedef Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > Create;
     };
 
     template <class T>
-    struct DefDistMapTraits : public Traits {
+    struct SetDistMapTraits : public Traits {
       typedef T DistMap;
       static DistMap *createDistMap(const Digraph &)
@@ -364,11 +364,11 @@
     ///\ref DistMap type.
     template <class T>
-    struct DefDistMap
-      : public Dijkstra< Digraph, LengthMap, DefDistMapTraits<T> > {
-      typedef Dijkstra< Digraph, LengthMap, DefDistMapTraits<T> > Create;
+    struct SetDistMap
+      : public Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > {
+      typedef Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > Create;
     };
 
     template <class T>
-    struct DefProcessedMapTraits : public Traits {
+    struct SetProcessedMapTraits : public Traits {
       typedef T ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &)
@@ -383,10 +383,10 @@
     ///\ref ProcessedMap type.
     template <class T>
-    struct DefProcessedMap
-      : public Dijkstra< Digraph, LengthMap, DefProcessedMapTraits<T> > {
-      typedef Dijkstra< Digraph, LengthMap, DefProcessedMapTraits<T> > Create;
-    };
-
-    struct DefDigraphProcessedMapTraits : public Traits {
+    struct SetProcessedMap
+      : public Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > {
+      typedef Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > Create;
+    };
+
+    struct SetStandardProcessedMapTraits : public Traits {
       typedef typename Digraph::template NodeMap<bool> ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &g)
@@ -401,13 +401,12 @@
     ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     ///If you don't set it explicitly, it will be automatically allocated.
-    template <class T>
-    struct DefProcessedMapToBeDefaultMap
-      : public Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits> {
-      typedef Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits>
+    struct SetStandardProcessedMap
+      : public Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits > {
+      typedef Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits >
       Create;
     };
 
     template <class H, class CR>
-    struct DefHeapTraits : public Traits {
+    struct SetHeapTraits : public Traits {
       typedef CR HeapCrossRef;
       typedef H Heap;
@@ -426,11 +425,11 @@
     ///reference type.
     template <class H, class CR = typename Digraph::template NodeMap<int> >
-    struct DefHeap
-      : public Dijkstra< Digraph, LengthMap, DefHeapTraits<H, CR> > {
-      typedef Dijkstra< Digraph, LengthMap, DefHeapTraits<H, CR> > Create;
+    struct SetHeap
+      : public Dijkstra< Digraph, LengthMap, SetHeapTraits<H, CR> > {
+      typedef Dijkstra< Digraph, LengthMap, SetHeapTraits<H, CR> > Create;
     };
 
     template <class H, class CR>
-    struct DefStandardHeapTraits : public Traits {
+    struct SetStandardHeapTraits : public Traits {
       typedef CR HeapCrossRef;
       typedef H Heap;
@@ -451,12 +450,12 @@
     ///parameter and the heap's constructor waits for the cross reference.
     template <class H, class CR = typename Digraph::template NodeMap<int> >
-    struct DefStandardHeap
-      : public Dijkstra< Digraph, LengthMap, DefStandardHeapTraits<H, CR> > {
-      typedef Dijkstra< Digraph, LengthMap, DefStandardHeapTraits<H, CR> >
+    struct SetStandardHeap
+      : public Dijkstra< Digraph, LengthMap, SetStandardHeapTraits<H, CR> > {
+      typedef Dijkstra< Digraph, LengthMap, SetStandardHeapTraits<H, CR> >
       Create;
     };
 
     template <class T>
-    struct DefOperationTraitsTraits : public Traits {
+    struct SetOperationTraitsTraits : public Traits {
       typedef T OperationTraits;
     };
@@ -468,7 +467,7 @@
     ///\ref OperationTraits type.
     template <class T>
-    struct DefOperationTraits
-      : public Dijkstra<Digraph, LengthMap, DefOperationTraitsTraits<T> > {
-      typedef Dijkstra<Digraph, LengthMap, DefOperationTraitsTraits<T> >
+    struct SetOperationTraits
+      : public Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> > {
+      typedef Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> >
       Create;
     };
@@ -1069,6 +1068,4 @@
     //Pointer to the length map
     void *_length;
-    //Pointer to the map of processed nodes.
-    void *_processed;
     //Pointer to the map of predecessors arcs.
     void *_pred;
@@ -1083,5 +1080,5 @@
     /// This constructor does not require parameters, therefore it initiates
     /// all of the attributes to default values (0, INVALID).
-    DijkstraWizardBase() : _g(0), _length(0), _processed(0), _pred(0),
+    DijkstraWizardBase() : _g(0), _length(0), _pred(0),
                            _dist(0), _source(INVALID) {}
 
@@ -1097,5 +1094,5 @@
       _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
       _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
-      _processed(0), _pred(0), _dist(0), _source(s) {}
+      _pred(0), _dist(0), _source(s) {}
 
   };
@@ -1176,10 +1173,6 @@
         dij(*reinterpret_cast<const Digraph*>(Base::_g),
             *reinterpret_cast<const LengthMap*>(Base::_length));
-      if(Base::_processed)
-        dij.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
-      if(Base::_pred)
-        dij.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
-      if(Base::_dist)
-        dij.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
+      if(Base::_pred) dij.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
+      if(Base::_dist) dij.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
       dij.run(Base::_source);
     }
@@ -1206,8 +1199,8 @@
 
     template<class T>
-    struct DefPredMapBase : public Base {
+    struct SetPredMapBase : public Base {
       typedef T PredMap;
       static PredMap *createPredMap(const Digraph &) { return 0; };
-      DefPredMapBase(const TR &b) : TR(b) {}
+      SetPredMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
@@ -1217,15 +1210,15 @@
     ///for setting \ref PredMap object.
     template<class T>
-    DijkstraWizard<DefPredMapBase<T> > predMap(const T &t)
+    DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
     {
       Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return DijkstraWizard<DefPredMapBase<T> >(*this);
+      return DijkstraWizard<SetPredMapBase<T> >(*this);
     }
 
     template<class T>
-    struct DefProcessedMapBase : public Base {
+    struct SetProcessedMapBase : public Base {
       typedef T ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
-      DefProcessedMapBase(const TR &b) : TR(b) {}
+      SetProcessedMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
@@ -1235,15 +1228,15 @@
     ///for setting \ref ProcessedMap object.
     template<class T>
-    DijkstraWizard<DefProcessedMapBase<T> > processedMap(const T &t)
+    DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
     {
       Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return DijkstraWizard<DefProcessedMapBase<T> >(*this);
+      return DijkstraWizard<SetProcessedMapBase<T> >(*this);
     }
 
     template<class T>
-    struct DefDistMapBase : public Base {
+    struct SetDistMapBase : public Base {
       typedef T DistMap;
       static DistMap *createDistMap(const Digraph &) { return 0; };
-      DefDistMapBase(const TR &b) : TR(b) {}
+      SetDistMapBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-templ-param "Named parameter"
@@ -1253,8 +1246,8 @@
     ///for setting \ref DistMap object.
     template<class T>
-    DijkstraWizard<DefDistMapBase<T> > distMap(const T &t)
+    DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
     {
       Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return DijkstraWizard<DefDistMapBase<T> >(*this);
+      return DijkstraWizard<SetDistMapBase<T> >(*this);
     }
 
Index: lemon/dim2.h
===================================================================
--- lemon/dim2.h	(revision 253)
+++ lemon/dim2.h	(revision 241)
@@ -29,5 +29,6 @@
 /// a two dimensional vector with the usual operations.
 ///
-/// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine
+/// The class \ref lemon::dim2::BoundingBox "dim2::BoundingBox"
+/// can be used to determine
 /// the rectangular bounding box of a set of
 /// \ref lemon::dim2::Point "dim2::Point"'s.
@@ -44,5 +45,5 @@
   /// @{
 
-  /// Two dimensional vector (plain vector)
+  /// A simple two dimensional vector (plain vector) implementation
 
   /// A simple two dimensional vector (plain vector) implementation
@@ -221,5 +222,5 @@
   inline std::ostream& operator<<(std::ostream &os, const Point<T>& z)
   {
-    os << "(" << z.x << "," << z.y << ")";
+    os << "(" << z.x << ", " << z.y << ")";
     return os;
   }
@@ -260,31 +261,31 @@
 
 
-  /// Bounding box of plain vectors (\ref Point points).
-
-  /// A class to calculate or store the bounding box of plain vectors
-  /// (\ref Point points).
-  template<typename T>
-  class Box {
+    /// A class to calculate or store the bounding box of plain vectors.
+
+    /// A class to calculate or store the bounding box of plain vectors.
+    ///
+    template<typename T>
+    class BoundingBox {
       Point<T> _bottom_left, _top_right;
       bool _empty;
     public:
 
-      ///Default constructor: creates an empty box
-      Box() { _empty = true; }
-
-      ///Construct a box from one point
-      Box(Point<T> a) {
+      ///Default constructor: creates an empty bounding box
+      BoundingBox() { _empty = true; }
+
+      ///Construct an instance from one point
+      BoundingBox(Point<T> a) {
         _bottom_left = _top_right = a;
         _empty = false;
       }
 
-      ///Construct a box from two points
-
-      ///Construct a box from two points.
+      ///Construct an instance from two points
+
+      ///Construct an instance from two points.
       ///\param a The bottom left corner.
       ///\param b The top right corner.
       ///\warning The coordinates of the bottom left corner must be no more
       ///than those of the top right one.
-      Box(Point<T> a,Point<T> b)
+      BoundingBox(Point<T> a,Point<T> b)
       {
         _bottom_left = a;
@@ -293,7 +294,7 @@
       }
 
-      ///Construct a box from four numbers
-
-      ///Construct a box from four numbers.
+      ///Construct an instance from four numbers
+
+      ///Construct an instance from four numbers.
       ///\param l The left side of the box.
       ///\param b The bottom of the box.
@@ -302,5 +303,5 @@
       ///\warning The left side must be no more than the right side and
       ///bottom must be no more than the top.
-      Box(T l,T b,T r,T t)
+      BoundingBox(T l,T b,T r,T t)
       {
         _bottom_left=Point<T>(l,b);
@@ -309,16 +310,16 @@
       }
 
-      ///Return \c true if the box is empty.
-
-      ///Return \c true if the box is empty (i.e. return \c false
+      ///Return \c true if the bounding box is empty.
+
+      ///Return \c true if the bounding box is empty (i.e. return \c false
       ///if at least one point was added to the box or the coordinates of
       ///the box were set).
       ///
-      ///The coordinates of an empty box are not defined.
+      ///The coordinates of an empty bounding box are not defined.
       bool empty() const {
         return _empty;
       }
 
-      ///Make the box empty
+      ///Make the BoundingBox empty
       void clear() {
         _empty = true;
@@ -328,5 +329,5 @@
 
       ///Give back the bottom left corner of the box.
-      ///If the box is empty, then the return value is not defined.
+      ///If the bounding box is empty, then the return value is not defined.
       Point<T> bottomLeft() const {
         return _bottom_left;
@@ -344,5 +345,5 @@
 
       ///Give back the top right corner of the box.
-      ///If the box is empty, then the return value is not defined.
+      ///If the bounding box is empty, then the return value is not defined.
       Point<T> topRight() const {
         return _top_right;
@@ -360,5 +361,5 @@
 
       ///Give back the bottom right corner of the box.
-      ///If the box is empty, then the return value is not defined.
+      ///If the bounding box is empty, then the return value is not defined.
       Point<T> bottomRight() const {
         return Point<T>(_top_right.x,_bottom_left.y);
@@ -377,5 +378,5 @@
 
       ///Give back the top left corner of the box.
-      ///If the box is empty, then the return value is not defined.
+      ///If the bounding box is empty, then the return value is not defined.
       Point<T> topLeft() const {
         return Point<T>(_bottom_left.x,_top_right.y);
@@ -394,5 +395,5 @@
 
       ///Give back the bottom of the box.
-      ///If the box is empty, then the return value is not defined.
+      ///If the bounding box is empty, then the return value is not defined.
       T bottom() const {
         return _bottom_left.y;
@@ -410,5 +411,5 @@
 
       ///Give back the top of the box.
-      ///If the box is empty, then the return value is not defined.
+      ///If the bounding box is empty, then the return value is not defined.
       T top() const {
         return _top_right.y;
@@ -426,5 +427,5 @@
 
       ///Give back the left side of the box.
-      ///If the box is empty, then the return value is not defined.
+      ///If the bounding box is empty, then the return value is not defined.
       T left() const {
         return _bottom_left.x;
@@ -442,5 +443,5 @@
 
       /// Give back the right side of the box.
-      ///If the box is empty, then the return value is not defined.
+      ///If the bounding box is empty, then the return value is not defined.
       T right() const {
         return _top_right.x;
@@ -458,5 +459,5 @@
 
       ///Give back the height of the box.
-      ///If the box is empty, then the return value is not defined.
+      ///If the bounding box is empty, then the return value is not defined.
       T height() const {
         return _top_right.y-_bottom_left.y;
@@ -466,10 +467,10 @@
 
       ///Give back the width of the box.
-      ///If the box is empty, then the return value is not defined.
+      ///If the bounding box is empty, then the return value is not defined.
       T width() const {
         return _top_right.x-_bottom_left.x;
       }
 
-      ///Checks whether a point is inside the box
+      ///Checks whether a point is inside a bounding box
       bool inside(const Point<T>& u) const {
         if (_empty)
@@ -481,9 +482,9 @@
       }
 
-      ///Increments the box with a point
-
-      ///Increments the box with a point.
+      ///Increments a bounding box with a point
+
+      ///Increments a bounding box with a point.
       ///
-      Box& add(const Point<T>& u){
+      BoundingBox& add(const Point<T>& u){
         if (_empty) {
           _bottom_left = _top_right = u;
@@ -499,9 +500,9 @@
       }
 
-      ///Increments the box to contain another box
-
-      ///Increments the box to contain another box.
+      ///Increments a bounding box to contain another bounding box
+
+      ///Increments a bounding box to contain another bounding box.
       ///
-      Box& add(const Box &u){
+      BoundingBox& add(const BoundingBox &u){
         if ( !u.empty() ){
           add(u._bottom_left);
@@ -511,10 +512,10 @@
       }
 
-      ///Intersection of two boxes
-
-      ///Intersection of two boxes.
+      ///Intersection of two bounding boxes
+
+      ///Intersection of two bounding boxes.
       ///
-      Box operator&(const Box& u) const {
-        Box b;
+      BoundingBox operator&(const BoundingBox& u) const {
+        BoundingBox b;
         if (_empty || u._empty) {
           b._empty = true;
@@ -530,47 +531,6 @@
       }
 
-  };//class Box
-
-
-  ///Read a box from a stream
-
-  ///Read a box from a stream.
-  ///\relates Box
-  template<typename T>
-  inline std::istream& operator>>(std::istream &is, Box<T>& b) {
-    char c;
-    Point<T> p;
-    if (is >> c) {
-      if (c != '(') is.putback(c);
-    } else {
-      is.clear();
-    }
-    if (!(is >> p)) return is;
-    b.bottomLeft(p);
-    if (is >> c) {
-      if (c != ',') is.putback(c);
-    } else {
-      is.clear();
-    }
-    if (!(is >> p)) return is;
-    b.topRight(p);
-    if (is >> c) {
-      if (c != ')') is.putback(c);
-    } else {
-      is.clear();
-    }
-    return is;
-  }
-
-  ///Write a box to a stream
-
-  ///Write a box to a stream.
-  ///\relates Box
-  template<typename T>
-  inline std::ostream& operator<<(std::ostream &os, const Box<T>& b)
-  {
-    os << "(" << b.bottomLeft() << "," << b.topRight() << ")";
-    return os;
-  }
+    };//class Boundingbox
+
 
   ///Map of x-coordinates of a \ref Point "Point"-map
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 253)
+++ lemon/graph_to_eps.h	(revision 220)
@@ -726,8 +726,8 @@
     double diag_len = 1;
     if(!(_absoluteNodeSizes&&_absoluteArcWidths)) {
-      dim2::Box<double> bb;
+      dim2::BoundingBox<double> bb;
       for(NodeIt n(g);n!=INVALID;++n) bb.add(mycoords[n]);
       if (bb.empty()) {
-        bb = dim2::Box<double>(dim2::Point<double>(0,0));
+        bb = dim2::BoundingBox<double>(dim2::Point<double>(0,0));
       }
       diag_len = std::sqrt((bb.bottomLeft()-bb.topRight()).normSquare());
@@ -737,5 +737,5 @@
     }
 
-    dim2::Box<double> bb;
+    dim2::BoundingBox<double> bb;
     for(NodeIt n(g);n!=INVALID;++n) {
       double ns=_nodeSizes[n]*_nodeScale;
@@ -759,5 +759,5 @@
     }
     if (bb.empty()) {
-      bb = dim2::Box<double>(dim2::Point<double>(0,0));
+      bb = dim2::BoundingBox<double>(dim2::Point<double>(0,0));
     }
 
