Index: doc/graphs.dox
===================================================================
--- doc/graphs.dox	(revision 875)
+++ doc/graphs.dox	(revision 880)
@@ -10,5 +10,5 @@
 
 Each graph should meet the
-\ref hugo::skeleton::StaticGraphSkeleton "StaticGraph" concept.
+\ref hugo::skeleton::StaticGraph "StaticGraph" concept.
 This concept does not
 makes it possible to change the graph (i.e. it is not possible to add
@@ -17,5 +17,5 @@
 
 The graphs meeting the
-\ref hugo::skeleton::ExtendableGraphSkeleton "ExtendableGraph"
+\ref hugo::skeleton::ExtendableGraph "ExtendableGraph"
 concept allow node and
 edge addition. You can also "clear" (i.e. erase all edges and nodes)
@@ -23,5 +23,5 @@
 
 In case of graphs meeting the full feature
-\ref hugo::skeleton::ErasableGraphSkeleton "ErasableGraph"
+\ref hugo::skeleton::ErasableGraph "ErasableGraph"
 concept
 you can also erase individual edges and node in arbitrary order.
@@ -29,10 +29,10 @@
 The implemented graph structures are the following.
 \li \ref hugo::ListGraph "ListGraph" is the most versatile graph class. It meets
-the hugo::skeleton::ErasableGraphSkeleton "ErasableGraph" concept
+the hugo::skeleton::ErasableGraph "ErasableGraph" concept
 and it also have some convenience features.
 \li \ref hugo::SmartGraph "SmartGraph" is a more memory
 efficient version of \ref hugo::ListGraph "ListGraph". The
 price of it is that it only meets the
-\ref hugo::skeleton::ExtendableGraphSkeleton "ExtendableGraph" concept,
+\ref hugo::skeleton::ExtendableGraph "ExtendableGraph" concept,
 so you cannot delete individual edges or nodes.
 \li \ref hugo::SymListGraph "SymListGraph" and
Index: src/hugo/dijkstra.h
===================================================================
--- src/hugo/dijkstra.h	(revision 802)
+++ src/hugo/dijkstra.h	(revision 880)
@@ -19,8 +19,9 @@
   ///This class provides an efficient implementation of %Dijkstra algorithm.
   ///The edge lengths are passed to the algorithm using a
-  ///\ref ReadMapSkeleton "readable map",
+  ///\ref skeleton::ReadMap "ReadMap",
   ///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
+  ///\ref skeleton::ReadMap::ValueType "ValueType" of the length map.
   ///
   ///It is also possible to change the underlying priority heap.
@@ -33,5 +34,5 @@
   ///may involve in relatively time consuming process to compute the edge
   ///length if it is necessary. The default map type is
-  ///\ref GraphSkeleton::EdgeMap "Graph::EdgeMap<int>"
+  ///\ref skeleton::StaticGraph::EdgeMap "Graph::EdgeMap<int>"
   ///\param Heap The heap type used by the %Dijkstra
   ///algorithm. The default
Index: src/hugo/full_graph.h
===================================================================
--- src/hugo/full_graph.h	(revision 822)
+++ src/hugo/full_graph.h	(revision 880)
@@ -28,7 +28,7 @@
   ///It is completely static, so you can neither add nor delete either
   ///edges or nodes.
-  ///Otherwise it conforms to the graph interface documented under
-  ///the description of \ref GraphSkeleton.
-  ///\sa \ref GraphSkeleton.
+  ///Thus it conforms to
+  ///the \ref skeleton::StaticGraph "StaticGraph" concept
+  ///\sa skeleton::StaticGraph.
   ///\todo What about loops?
   ///\todo Don't we need SymEdgeMap?
Index: src/hugo/list_graph.h
===================================================================
--- src/hugo/list_graph.h	(revision 877)
+++ src/hugo/list_graph.h	(revision 880)
@@ -30,8 +30,7 @@
   ///This is a simple and fast erasable graph implementation.
   ///
-  ///It conforms to the graph interface documented under
-  ///the description of
-  ///\ref skeleton::ErasableGraphSkeleton "ErasableGraphSkeleton".
-  ///\sa skeleton::ErasableGraphSkeleton.
+  ///It conforms to the
+  ///\ref skeleton::ErasableGraph "ErasableGraph" concept.
+  ///\sa skeleton::ErasableGraph.
   class ListGraph {
 
@@ -313,5 +312,4 @@
       NodeIt(Invalid i) : Node(i) { }
       NodeIt(const ListGraph& _G) : Node(_G.first_node), G(&_G) { }
-      ///\todo Undocumented conversion Node -\> NodeIt.
       NodeIt(const ListGraph& _G,Node n) : Node(n), G(&_G) { }
       NodeIt &operator++() {
@@ -427,5 +425,5 @@
   ///feature by
   ///storing shared values for the edge pairs. The usual
-  ///\ref GraphSkeleton::EdgeMap "EdgeMap"
+  ///\ref Graph::EdgeMap "EdgeMap"
   ///can be used
   ///as well.
@@ -495,10 +493,11 @@
   ///\ref EdgeSet class.
   ///
-  ///It conforms to the graph interface documented under
-  ///the description of \ref GraphSkeleton with the exception that you cannot
+  ///It conforms to 
+  ///the \ref skeleton::ExtendableGraph "ExtendableGraph" concept
+  ///with the exception that you cannot
   ///add (or delete) edges. The usual edge iterators are exists, but they are
   ///always \ref INVALID.
-  ///\sa \ref GraphSkeleton
-  ///\sa \ref EdgeSet
+  ///\sa skeleton::ExtendableGraph
+  ///\sa EdgeSet
   class NodeSet {
 
@@ -791,10 +790,11 @@
   ///
   ///\param GG The type of the graph which shares its node set with this class.
-  ///Its interface must conform with \ref GraphSkeleton.
+  ///Its interface must conform to the
+  ///\ref skeleton::StaticGraph "StaticGraph" concept.
   ///
-  ///It conforms to the graph interface documented under
-  ///the description of \ref GraphSkeleton.
-  ///\sa \ref GraphSkeleton.
-  ///\sa \ref NodeSet.
+  ///It conforms to the 
+  ///\ref skeleton::ExtendableGraph "ExtendableGraph" concept.
+  ///\sa skeleton::ExtendableGraph.
+  ///\sa NodeSet.
   template<typename GG>
   class EdgeSet {
@@ -898,6 +898,5 @@
     ///Construates a new graph based on the nodeset of an existing one.
     ///\param _G the base graph.
-    ///\todo It looks like a copy constructor, but it isn't.
-    EdgeSet(NodeGraphType &_G) 
+    explicit EdgeSet(NodeGraphType &_G) 
       : G(_G), nodes(_G), edges(),
 	first_free_edge(-1) {}
@@ -906,5 +905,5 @@
     ///Makes a copy of an EdgeSet.
     ///It will be based on the same graph.
-    EdgeSet(const EdgeSet &_g) 
+    explicit EdgeSet(const EdgeSet &_g) 
       : G(_g.G), nodes(_g.G), edges(_g.edges),
 	first_free_edge(_g.first_free_edge) {}
Index: src/hugo/skeletons/graph.h
===================================================================
--- src/hugo/skeletons/graph.h	(revision 873)
+++ src/hugo/skeletons/graph.h	(revision 880)
@@ -5,5 +5,5 @@
 ///\ingroup skeletons
 ///\file
-///\brief Declaration of GraphSkeleton.
+///\brief Declaration of Graph.
 
 #include <hugo/invalid.h>
@@ -32,5 +32,5 @@
     /// like @ref ListGraph or
     /// @ref SmartGraph will just refer to this structure.
-    class StaticGraphSkeleton
+    class StaticGraph
     {
     public:
@@ -39,10 +39,10 @@
       /// Defalult constructor.
       ///
-      StaticGraphSkeleton() { }
+      StaticGraph() { }
       ///Copy consructor.
 
 //       ///\todo It is not clear, what we expect from a copy constructor.
 //       ///E.g. How to assign the nodes/edges to each other? What about maps?
-//       StaticGraphSkeleton(const StaticGraphSkeleton& g) { }
+//       StaticGraph(const StaticGraph& g) { }
 
       /// The base type of node iterators, 
@@ -123,5 +123,5 @@
 	/// Sets the iterator to the first node of \c g.
 	///
-	NodeIt(const StaticGraphSkeleton& g) { }
+	NodeIt(const StaticGraph& g) { }
 	/// Node -> NodeIt conversion.
 
@@ -130,5 +130,5 @@
 	/// This feature necessitates that each time we 
 	/// iterate the edge-set, the iteration order is the same.
-	NodeIt(const StaticGraphSkeleton& g, const Node& n) { }
+	NodeIt(const StaticGraph& g, const Node& n) { }
 	/// Next node.
 
@@ -215,5 +215,5 @@
 	///@param n the node
 	///@param g the graph
-	OutEdgeIt(const StaticGraphSkeleton& g, const Node& n) { }
+	OutEdgeIt(const StaticGraph& g, const Node& n) { }
 	/// Edge -> OutEdgeIt conversion
 
@@ -221,5 +221,5 @@
 	/// This feature necessitates that each time we 
 	/// iterate the edge-set, the iteration order is the same.
-	OutEdgeIt(const StaticGraphSkeleton& g, const Edge& e) { }
+	OutEdgeIt(const StaticGraph& g, const Edge& e) { }
 	///Next outgoing edge
 	
@@ -264,5 +264,5 @@
 	///@param n the node
 	///@param g the graph
-	InEdgeIt(const StaticGraphSkeleton& g, const Node& n) { }
+	InEdgeIt(const StaticGraph& g, const Node& n) { }
 	/// Edge -> InEdgeIt conversion
 
@@ -270,5 +270,5 @@
 	/// This feature necessitates that each time we 
 	/// iterate the edge-set, the iteration order is the same.
-	InEdgeIt(const StaticGraphSkeleton& g, const Edge& n) { }
+	InEdgeIt(const StaticGraph& g, const Edge& n) { }
 	/// Next incoming edge
 
@@ -308,5 +308,5 @@
 	/// node
 	///@param g the graph
-	EdgeIt(const StaticGraphSkeleton& g) { }
+	EdgeIt(const StaticGraph& g) { }
 	/// Edge -> EdgeIt conversion
 
@@ -314,5 +314,5 @@
 	/// This feature necessitates that each time we 
 	/// iterate the edge-set, the iteration order is the same.
-	EdgeIt(const StaticGraphSkeleton&, const Edge&) { } 
+	EdgeIt(const StaticGraph&, const Edge&) { } 
     	///Next edge
 	
@@ -371,9 +371,10 @@
       /// .
       
-      ///\todo What is this?
+      ///\todo Should it be in the concept?
       ///
       int nodeNum() const { return 0; }
       /// .
-      ///\todo What is this?
+
+      ///\todo Should it be in the concept?
       ///
       int edgeNum() const { return 0; }
@@ -382,16 +383,17 @@
       ///Reference map of the nodes to type \c T.
 
+      /// \ingroup skeletons
       ///Reference map of the nodes to type \c T.
-      /// \sa ReferenceSkeleton
+      /// \sa Reference
       /// \warning Making maps that can handle bool type (NodeMap<bool>)
       /// needs some extra attention!
-      template<class T> class NodeMap: public ReferenceMap< Node, T >
+      template<class T> class NodeMap : public ReferenceMap< Node, T >
       {
       public:
 
 	/// .
-	NodeMap(const StaticGraphSkeleton&) { }
+	NodeMap(const StaticGraph&) { }
 	/// .
-	NodeMap(const StaticGraphSkeleton&, T) { }
+	NodeMap(const StaticGraph&, T) { }
 
 	///Copy constructor
@@ -404,6 +406,7 @@
       ///Reference map of the edges to type \c T.
 
+      /// \ingroup skeletons
       ///Reference map of the edges to type \c T.
-      /// \sa ReferenceSkeleton
+      /// \sa Reference
       /// \warning Making maps that can handle bool type (EdgeMap<bool>)
       /// needs some extra attention!
@@ -414,7 +417,7 @@
 
 	/// .
-	EdgeMap(const StaticGraphSkeleton&) { }
+	EdgeMap(const StaticGraph&) { }
 	/// .
-	EdgeMap(const StaticGraphSkeleton&, T) { }
+	EdgeMap(const StaticGraph&, T) { }
     
 	///Copy constructor
@@ -430,8 +433,8 @@
     /// An empty non-static graph class.
 
-    /// This class provides everything that \c StaticGraphSkeleton
+    /// This class provides everything that \ref StaticGraph
     /// with additional functionality which enables to build a
     /// graph from scratch.
-    class ExtendableGraphSkeleton : public StaticGraphSkeleton
+    class ExtendableGraph : public StaticGraph
     {
     public:
@@ -440,5 +443,5 @@
       /// Defalult constructor.
       ///
-      ExtendableGraphSkeleton() { }
+      ExtendableGraph() { }
       ///Add a new node to the graph.
 
@@ -448,8 +451,8 @@
       ///Add a new edge to the graph.
 
-      ///Add a new edge to the graph with tail node \c tail
-      ///and head node \c head.
+      ///Add a new edge to the graph with tail node \c t
+      ///and head node \c h.
       ///\return the new edge.
-      Edge addEdge(Node, Node) { return INVALID; }
+      Edge addEdge(Node h, Node t) { return INVALID; }
     
       /// Resets the graph.
@@ -457,5 +460,5 @@
       /// This function deletes all edges and nodes of the graph.
       /// It also frees the memory allocated to store them.
-      /// \todo It might belong to \c ErasableGraphSkeleton.
+      /// \todo It might belong to \ref ErasableGraph.
       void clear() { }
     };
@@ -463,7 +466,7 @@
     /// An empty erasable graph class.
   
-    /// This class is an extension of \c GraphSkeleton. It also makes it
+    /// This class is an extension of \ref ExtendableGraph. It also makes it
     /// possible to erase edges or nodes.
-    class ErasableGraphSkeleton : public ExtendableGraphSkeleton
+    class ErasableGraph : public ExtendableGraph
     {
     public:
@@ -472,5 +475,5 @@
       /// Defalult constructor.
       ///
-      ErasableGraphSkeleton() { }
+      ErasableGraph() { }
       /// Deletes a node.
 
Index: src/hugo/smart_graph.h
===================================================================
--- src/hugo/smart_graph.h	(revision 822)
+++ src/hugo/smart_graph.h	(revision 880)
@@ -31,7 +31,7 @@
   ///It is also quite memory efficient, but at the price
   ///that <b> it does not support node and edge deletion</b>.
-  ///It conforms to the graph interface documented under
-  ///the description of \ref GraphSkeleton.
-  ///\sa \ref GraphSkeleton.
+  ///It conforms to 
+  ///the \ref skeleton::ExtendableGraph "ExtendableGraph" concept.
+  ///\sa skeleton::ExtendableGraph.
   ///
   ///\todo Some member functions could be \c static.
@@ -303,5 +303,5 @@
   ///feature by
   ///storing shared values for the edge pairs. The usual
-  ///\ref GraphSkeleton::EdgeMap "EdgeMap"
+  ///\ref Graph::EdgeMap "EdgeMap"
   ///can be used
   ///as well.
@@ -311,5 +311,5 @@
   ///\warning It shares the similarity with \ref SmartGraph that
   ///it is not possible to delete edges or nodes from the graph.
-  //\sa \ref SmartGraph.
+  //\sa SmartGraph.
 
   class SymSmartGraph : public SmartGraph
Index: src/test/bfs_test.cc
===================================================================
--- src/test/bfs_test.cc	(revision 793)
+++ src/test/bfs_test.cc	(revision 880)
@@ -11,5 +11,5 @@
 void check_Bfs_Compile() 
 {
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Edge Edge;
Index: src/test/dfs_test.cc
===================================================================
--- src/test/dfs_test.cc	(revision 793)
+++ src/test/dfs_test.cc	(revision 880)
@@ -11,5 +11,5 @@
 void check_Dfs_SmartGraph_Compile() 
 {
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Edge Edge;
Index: src/test/dijkstra_test.cc
===================================================================
--- src/test/dijkstra_test.cc	(revision 793)
+++ src/test/dijkstra_test.cc	(revision 880)
@@ -12,5 +12,5 @@
 {
   typedef int VType;
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Edge Edge;
Index: src/test/graph_test.cc
===================================================================
--- src/test/graph_test.cc	(revision 873)
+++ src/test/graph_test.cc	(revision 880)
@@ -52,13 +52,13 @@
 }
 
-//Compile GraphSkeleton
-template void hugo::checkCompileStaticGraph<skeleton::StaticGraphSkeleton>
-(skeleton::StaticGraphSkeleton &);
+//Compile Graph
+template void hugo::checkCompileStaticGraph<skeleton::StaticGraph>
+(skeleton::StaticGraph &);
 
-template void hugo::checkCompileGraph<skeleton::ExtendableGraphSkeleton>
-(skeleton::ExtendableGraphSkeleton &);
+template void hugo::checkCompileGraph<skeleton::ExtendableGraph>
+(skeleton::ExtendableGraph &);
 
-template void hugo::checkCompileErasableGraph<skeleton::ErasableGraphSkeleton>
-(skeleton::ErasableGraphSkeleton &);
+template void hugo::checkCompileErasableGraph<skeleton::ErasableGraph>
+(skeleton::ErasableGraph &);
 
 //Compile SmartGraph
Index: src/test/kruskal_test.cc
===================================================================
--- src/test/kruskal_test.cc	(revision 810)
+++ src/test/kruskal_test.cc	(revision 880)
@@ -15,8 +15,8 @@
 void checkCompileKruskal()
 {
-  skeleton::WriteMap<skeleton::StaticGraphSkeleton::Edge,bool> w;
+  skeleton::WriteMap<skeleton::StaticGraph::Edge,bool> w;
 
-  kruskalEdgeMap(skeleton::StaticGraphSkeleton(),
-		 skeleton::ReadMap<skeleton::StaticGraphSkeleton::Edge,int>(),
+  kruskalEdgeMap(skeleton::StaticGraph(),
+		 skeleton::ReadMap<skeleton::StaticGraph::Edge,int>(),
 		 w);
 }
Index: src/test/preflow_test.cc
===================================================================
--- src/test/preflow_test.cc	(revision 859)
+++ src/test/preflow_test.cc	(revision 880)
@@ -14,5 +14,5 @@
 {
   typedef int VType;
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Node Node;
Index: src/work/alpar/list_graph_demo.cc
===================================================================
--- src/work/alpar/list_graph_demo.cc	(revision 426)
+++ src/work/alpar/list_graph_demo.cc	(revision 880)
@@ -8,5 +8,5 @@
 
 typedef ListGraph Graph;
-//typedef GraphSkeleton Graph;
+//typedef Graph Graph;
 
 
Index: src/work/alpar/smart_graph_demo.cc
===================================================================
--- src/work/alpar/smart_graph_demo.cc	(revision 185)
+++ src/work/alpar/smart_graph_demo.cc	(revision 880)
@@ -8,5 +8,5 @@
 
 typedef SmartGraph Graph;
-//typedef GraphSkeleton Graph;
+//typedef Graph Graph;
 
 
Index: src/work/deba/dijkstra.h
===================================================================
--- src/work/deba/dijkstra.h	(revision 698)
+++ src/work/deba/dijkstra.h	(revision 880)
@@ -19,5 +19,5 @@
   ///This class provides an efficient implementation of %Dijkstra algorithm.
   ///The edge lengths are passed to the algorithm using a
-  ///\ref ReadMapSkeleton "readable map",
+  ///\ref ReadMap "readable map",
   ///so it is easy to change it to any kind of length.
   ///
@@ -33,5 +33,5 @@
   ///may involve in relatively time consuming process to compute the edge
   ///length if it is necessary. The default map type is
-  ///\ref GraphSkeleton::EdgeMap "Graph::EdgeMap<int>"
+  ///\ref Graph::EdgeMap "Graph::EdgeMap<int>"
   ///\param Heap The heap type used by the %Dijkstra
   ///algorithm. The default
Index: src/work/deba/list_graph.h
===================================================================
--- src/work/deba/list_graph.h	(revision 703)
+++ src/work/deba/list_graph.h	(revision 880)
@@ -28,6 +28,6 @@
   ///
   ///It conforms to the graph interface documented under
-  ///the description of \ref GraphSkeleton.
-  ///\sa \ref GraphSkeleton.
+  ///the description of \ref Graph.
+  ///\sa \ref Graph.
   class ListGraph {
 
@@ -383,5 +383,5 @@
   ///feature by
   ///storing shared values for the edge pairs. The usual
-  ///\ref GraphSkeleton::EdgeMap "EdgeMap"
+  ///\ref Graph::EdgeMap "EdgeMap"
   ///can be used
   ///as well.
Index: src/work/marci/experiment/graph_wrapper.h
===================================================================
--- src/work/marci/experiment/graph_wrapper.h	(revision 281)
+++ src/work/marci/experiment/graph_wrapper.h	(revision 880)
@@ -162,5 +162,5 @@
 
   template<typename GraphWrapper>
-  class GraphWrapperSkeleton {
+  class GraphWrapper {
   protected:
     GraphWrapper gw;
@@ -185,5 +185,5 @@
 	GraphWrapper::NodeIt(n) { }
       NodeIt(const Invalid& i) : GraphWrapper::NodeIt(i) { }
-      NodeIt(const GraphWrapperSkeleton<GraphWrapper>& _G) : 
+      NodeIt(const GraphWrapper<GraphWrapper>& _G) : 
 	GraphWrapper::NodeIt(_G.gw) { }
     };
@@ -196,5 +196,5 @@
 	GraphWrapper::OutEdgeIt(e) { }
       OutEdgeIt(const Invalid& i) : GraphWrapper::OutEdgeIt(i) { }
-      OutEdgeIt(const GraphWrapperSkeleton<GraphWrapper>& _G, const Node& n) : 
+      OutEdgeIt(const GraphWrapper<GraphWrapper>& _G, const Node& n) : 
 	GraphWrapper::OutEdgeIt(_G.gw, n) { }
     };
@@ -206,5 +206,5 @@
 	GraphWrapper::InEdgeIt(e) { }
       InEdgeIt(const Invalid& i) : GraphWrapper::InEdgeIt(i) { }
-      InEdgeIt(const GraphWrapperSkeleton<GraphWrapper>& _G, const Node& n) : 
+      InEdgeIt(const GraphWrapper<GraphWrapper>& _G, const Node& n) : 
 	GraphWrapper::InEdgeIt(_G.gw, n) { }
     };
@@ -217,11 +217,11 @@
 	GraphWrapper::EdgeIt(e) { }
       EdgeIt(const Invalid& i) : GraphWrapper::EdgeIt(i) { }
-      EdgeIt(const GraphWrapperSkeleton<GraphWrapper>& _G) : 
+      EdgeIt(const GraphWrapper<GraphWrapper>& _G) : 
 	GraphWrapper::EdgeIt(_G.gw) { }
     };
 
 
-    //GraphWrapperSkeleton() : gw() { }
-    GraphWrapperSkeleton(GraphWrapper _gw) : gw(_gw) { }
+    //GraphWrapper() : gw() { }
+    GraphWrapper(GraphWrapper _gw) : gw(_gw) { }
 
     //void setGraph(BaseGraph& _graph) { gw.setGraph(_graph); }
@@ -270,7 +270,7 @@
     template<typename T> class NodeMap : public GraphWrapper::NodeMap<T> { 
     public:
-      NodeMap(const GraphWrapperSkeleton<GraphWrapper>& _G) :  
+      NodeMap(const GraphWrapper<GraphWrapper>& _G) :  
 	GraphWrapper::NodeMap<T>(_G.gw) { }
-      NodeMap(const GraphWrapperSkeleton<GraphWrapper>& _G, T a) : 
+      NodeMap(const GraphWrapper<GraphWrapper>& _G, T a) : 
 	GraphWrapper::NodeMap<T>(_G.gw, a) { }
     };
@@ -278,7 +278,7 @@
     template<typename T> class EdgeMap : public GraphWrapper::EdgeMap<T> { 
     public:
-      EdgeMap(const GraphWrapperSkeleton<GraphWrapper>& _G) :  
+      EdgeMap(const GraphWrapper<GraphWrapper>& _G) :  
 	GraphWrapper::EdgeMap<T>(_G.gw) { }
-      EdgeMap(const GraphWrapperSkeleton<GraphWrapper>& _G, T a) : 
+      EdgeMap(const GraphWrapper<GraphWrapper>& _G, T a) : 
 	GraphWrapper::EdgeMap<T>(_G.gw, a) { }
     };
@@ -366,7 +366,7 @@
 
 //   template<typename /*Graph*/GraphWrapper
-//   /*=typename GraphWrapperSkeleton< TrivGraphWrapper<Graph>*/ >
+//   /*=typename GraphWrapper< TrivGraphWrapper<Graph>*/ >
 //   class RevGraphWrapper : 
-//     public GraphWrapper/*GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/ {
+//     public GraphWrapper/*GraphWrapper< TrivGraphWrapper<Graph> >*/ {
 //   protected:
 //     //Graph* graph;
@@ -379,11 +379,11 @@
   
 //     //typedef typename Graph::Edge Edge;
-//     typedef typename GraphWrapper/*typename GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/::OutEdgeIt InEdgeIt;
-//     typedef typename GraphWrapper/*typename GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/::InEdgeIt OutEdgeIt;
+//     typedef typename GraphWrapper/*typename GraphWrapper< TrivGraphWrapper<Graph> >*/::OutEdgeIt InEdgeIt;
+//     typedef typename GraphWrapper/*typename GraphWrapper< TrivGraphWrapper<Graph> >*/::InEdgeIt OutEdgeIt;
 //     //typedef typename Graph::SymEdgeIt SymEdgeIt;
 //     //typedef typename Graph::EdgeIt EdgeIt;
 
 //     //RevGraphWrapper() : graph(0) { }
-//     RevGraphWrapper(GraphWrapper _gw/*BaseGraph& _graph*/) : GraphWrapper/*GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/(_gw/*TrivGraphWrapper<Graph>(_graph)*/) { }
+//     RevGraphWrapper(GraphWrapper _gw/*BaseGraph& _graph*/) : GraphWrapper/*GraphWrapper< TrivGraphWrapper<Graph> >*/(_gw/*TrivGraphWrapper<Graph>(_graph)*/) { }
     
 //     //void setGraph(Graph& _graph) { graph = &_graph; }
@@ -430,28 +430,28 @@
 
 //     template<typename T> class NodeMap : 
-//       public GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::NodeMap<T> 
+//       public GraphWrapper/*< TrivGraphWrapper<Graph> >*/::NodeMap<T> 
 //     { 
 //     public:
 //       NodeMap(const RevGraphWrapper<GraphWrapper>& _gw) : 
-// 	GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::NodeMap<T>(_gw) { }
+// 	GraphWrapper/*< TrivGraphWrapper<Graph> >*/::NodeMap<T>(_gw) { }
 //       NodeMap(const RevGraphWrapper<GraphWrapper>& _gw, T a) : 
-// 	GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::NodeMap<T>(_gw, a) { }
+// 	GraphWrapper/*< TrivGraphWrapper<Graph> >*/::NodeMap<T>(_gw, a) { }
 //     };
     
 //     template<typename T> class EdgeMap : 
-//       public GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::EdgeMap<T> { 
+//       public GraphWrapper/*< TrivGraphWrapper<Graph> >*/::EdgeMap<T> { 
 //     public:
 //       EdgeMap(const RevGraphWrapper<GraphWrapper>& _gw) : 
-// 	GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::EdgeMap<T>(_gw) { }
+// 	GraphWrapper/*< TrivGraphWrapper<Graph> >*/::EdgeMap<T>(_gw) { }
 //       EdgeMap(const RevGraphWrapper<GraphWrapper>& _gw, T a) : 
-// 	GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::EdgeMap<T>(_gw, a) { }
+// 	GraphWrapper/*< TrivGraphWrapper<Graph> >*/::EdgeMap<T>(_gw, a) { }
 //     };
 //   };
 
   template<typename GraphWrapper>
-  class RevGraphWrapper : public GraphWrapperSkeleton<GraphWrapper> {
+  class RevGraphWrapper : public GraphWrapper<GraphWrapper> {
   public:
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::Node Node;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::Edge Edge;
+    typedef typename GraphWrapper<GraphWrapper>::Node Node;
+    typedef typename GraphWrapper<GraphWrapper>::Edge Edge;
     //FIXME 
     //If GraphWrapper::OutEdgeIt is not defined
@@ -462,31 +462,31 @@
     //Unfortunately all the typedefs are instantiated in templates, 
     //unlike other stuff
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::OutEdgeIt InEdgeIt;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::InEdgeIt OutEdgeIt;
+    typedef typename GraphWrapper<GraphWrapper>::OutEdgeIt InEdgeIt;
+    typedef typename GraphWrapper<GraphWrapper>::InEdgeIt OutEdgeIt;
 
     RevGraphWrapper(GraphWrapper _gw) : 
-      GraphWrapperSkeleton<GraphWrapper>(_gw) { }  
+      GraphWrapper<GraphWrapper>(_gw) { }  
 
     Node head(const Edge& e) const 
-      { return GraphWrapperSkeleton<GraphWrapper>::tail(e); }
+      { return GraphWrapper<GraphWrapper>::tail(e); }
     Node tail(const Edge& e) const 
-      { return GraphWrapperSkeleton<GraphWrapper>::head(e); }
+      { return GraphWrapper<GraphWrapper>::head(e); }
   };
 
   //Subgraph on the same node-set and partial edge-set
   template<typename GraphWrapper, typename EdgeFilterMap>
-  class SubGraphWrapper : public GraphWrapperSkeleton<GraphWrapper> {
+  class SubGraphWrapper : public GraphWrapper<GraphWrapper> {
   protected:
     EdgeFilterMap* filter_map;
   public:
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::Node Node;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::NodeIt NodeIt;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::Edge Edge;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::EdgeIt EdgeIt;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::InEdgeIt InEdgeIt;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::OutEdgeIt OutEdgeIt;
+    typedef typename GraphWrapper<GraphWrapper>::Node Node;
+    typedef typename GraphWrapper<GraphWrapper>::NodeIt NodeIt;
+    typedef typename GraphWrapper<GraphWrapper>::Edge Edge;
+    typedef typename GraphWrapper<GraphWrapper>::EdgeIt EdgeIt;
+    typedef typename GraphWrapper<GraphWrapper>::InEdgeIt InEdgeIt;
+    typedef typename GraphWrapper<GraphWrapper>::OutEdgeIt OutEdgeIt;
 
     SubGraphWrapper(GraphWrapper _gw, EdgeFilterMap& _filter_map) : 
-      GraphWrapperSkeleton<GraphWrapper>(_gw), filter_map(&_filter_map) { }  
+      GraphWrapper<GraphWrapper>(_gw), filter_map(&_filter_map) { }  
 
     template<typename I> I& first(I& i) const { 
@@ -678,5 +678,5 @@
 
   template<typename GraphWrapper>
-  class UndirGraphWrapper : public GraphWrapperSkeleton<GraphWrapper> {
+  class UndirGraphWrapper : public GraphWrapper<GraphWrapper> {
   protected:
 //    GraphWrapper gw;
@@ -685,15 +685,15 @@
     //typedef GraphWrapper BaseGraph;
 
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::Node Node;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::NodeIt NodeIt;
+    typedef typename GraphWrapper<GraphWrapper>::Node Node;
+    typedef typename GraphWrapper<GraphWrapper>::NodeIt NodeIt;
 
     //private:
     //FIXME ezeknek valojaban a GraphWrapper megfelelo dolgai kellene hogy 
     //legyenek, at kell irni
-    typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
+    typedef typename /*GraphWrapper<GraphWrapper>*/
     GraphWrapper::Edge GraphEdge;
-    typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/ 
+    typedef typename /*GraphWrapper<GraphWrapper>*/ 
     GraphWrapper::OutEdgeIt GraphOutEdgeIt;
-    typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/ 
+    typedef typename /*GraphWrapper<GraphWrapper>*/ 
     GraphWrapper::InEdgeIt GraphInEdgeIt;
     //public:
@@ -701,5 +701,5 @@
     //UndirGraphWrapper() : graph(0) { }
     UndirGraphWrapper(GraphWrapper _gw) : 
-      GraphWrapperSkeleton<GraphWrapper>(_gw) { }  
+      GraphWrapper<GraphWrapper>(_gw) { }  
 
     //UndirGraphWrapper(GraphWrapper _gw) : gw(_gw) { }
@@ -865,8 +865,8 @@
 
 //     template<typename T> class EdgeMap : 
-//       public GraphWrapperSkeleton<GraphWrapper>::EdgeMap<T> { 
+//       public GraphWrapper<GraphWrapper>::EdgeMap<T> { 
 //     public:
 //       EdgeMap(const UndirGraphWrapper<GraphWrapper>& _G) : 
-// 	GraphWrapperSkeleton<GraphWrapper>::EdgeMap<T>(_G.gw) { }
+// 	GraphWrapper<GraphWrapper>::EdgeMap<T>(_G.gw) { }
 //       EdgeMap(const UndirGraphWrapper<GraphWrapper>& _G, T a) : 
 // 	GraphWrapper::EdgeMap<T>(_G.gw, a) { }
@@ -948,14 +948,14 @@
 
   template<typename GraphWrapper, typename Number, typename FlowMap, typename CapacityMap>
-  class ResGraphWrapper : public GraphWrapperSkeleton<GraphWrapper>{
+  class ResGraphWrapper : public GraphWrapper<GraphWrapper>{
   public:
     //typedef Graph BaseGraph;
     //typedef TrivGraphWrapper<const Graph> GraphWrapper;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::Node Node;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::NodeIt NodeIt;
+    typedef typename GraphWrapper<GraphWrapper>::Node Node;
+    typedef typename GraphWrapper<GraphWrapper>::NodeIt NodeIt;
   private:
-    typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
+    typedef typename /*GraphWrapper<GraphWrapper>*/
     GraphWrapper::OutEdgeIt OldOutEdgeIt;
-    typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
+    typedef typename /*GraphWrapper<GraphWrapper>*/
     GraphWrapper::InEdgeIt OldInEdgeIt;
   protected:
@@ -968,5 +968,5 @@
     ResGraphWrapper(const GraphWrapper& _gw, FlowMap& _flow, 
 		    const CapacityMap& _capacity) : 
-      GraphWrapperSkeleton<GraphWrapper>(_gw), 
+      GraphWrapper<GraphWrapper>(_gw), 
       flow(&_flow), capacity(&_capacity) { }
 
@@ -1265,17 +1265,17 @@
   //Subgraph on the same node-set and partial edge-set
   template<typename GraphWrapper, typename FirstOutEdgesMap>
-  class ErasingFirstGraphWrapper : public GraphWrapperSkeleton<GraphWrapper> {
+  class ErasingFirstGraphWrapper : public GraphWrapper<GraphWrapper> {
   protected:
     FirstOutEdgesMap* first_out_edges;
   public:
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::Node Node;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::NodeIt NodeIt;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::Edge Edge;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::EdgeIt EdgeIt;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::InEdgeIt InEdgeIt;
-    typedef typename GraphWrapperSkeleton<GraphWrapper>::OutEdgeIt OutEdgeIt;
+    typedef typename GraphWrapper<GraphWrapper>::Node Node;
+    typedef typename GraphWrapper<GraphWrapper>::NodeIt NodeIt;
+    typedef typename GraphWrapper<GraphWrapper>::Edge Edge;
+    typedef typename GraphWrapper<GraphWrapper>::EdgeIt EdgeIt;
+    typedef typename GraphWrapper<GraphWrapper>::InEdgeIt InEdgeIt;
+    typedef typename GraphWrapper<GraphWrapper>::OutEdgeIt OutEdgeIt;
 
     ErasingFirstGraphWrapper(GraphWrapper _gw, FirstOutEdgesMap& _first_out_edges) : 
-      GraphWrapperSkeleton<GraphWrapper>(_gw), first_out_edges(&_first_out_edges) { }  
+      GraphWrapper<GraphWrapper>(_gw), first_out_edges(&_first_out_edges) { }  
 
     template<typename I> I& first(I& i) const { 
Index: src/work/marci/experiment/graph_wrapper_1.h
===================================================================
--- src/work/marci/experiment/graph_wrapper_1.h	(revision 298)
+++ src/work/marci/experiment/graph_wrapper_1.h	(revision 880)
@@ -759,8 +759,8 @@
 
 //     template<typename T> class EdgeMap : 
-//       public GraphWrapperSkeleton<Graph>::EdgeMap<T> { 
+//       public GraphWrapper<Graph>::EdgeMap<T> { 
 //     public:
 //       EdgeMap(const UndirGraphWrapper<Graph>& _G) : 
-// 	GraphWrapperSkeleton<Graph>::EdgeMap<T>(_G.gw) { }
+// 	GraphWrapper<Graph>::EdgeMap<T>(_G.gw) { }
 //       EdgeMap(const UndirGraphWrapper<Graph>& _G, T a) : 
 // 	Graph::EdgeMap<T>(_G.gw, a) { }
Index: src/work/peter/edgepathgraph.h
===================================================================
--- src/work/peter/edgepathgraph.h	(revision 826)
+++ src/work/peter/edgepathgraph.h	(revision 880)
@@ -297,5 +297,5 @@
 
     ///Read/write/reference map of the nodes to type \c T.
-    /// \sa MemoryMapSkeleton
+    /// \sa MemoryMap
     /// \todo We may need copy constructor
     /// \todo We may need conversion from other nodetype
@@ -338,5 +338,5 @@
     ///It behaves exactly in the same way as \ref NodeMap.
     /// \sa NodeMap
-    /// \sa MemoryMapSkeleton
+    /// \sa MemoryMap
     /// \todo We may need copy constructor
     /// \todo We may need conversion from other edgetype
@@ -375,5 +375,5 @@
   ///
   /// \todo This blabla could be replaced by a sepatate description about
-  /// Skeletons.
+  /// s.
   ///
   /// It can be used for checking the interface compatibility,
Index: src/work/peter/hierarchygraph.h
===================================================================
--- src/work/peter/hierarchygraph.h	(revision 826)
+++ src/work/peter/hierarchygraph.h	(revision 880)
@@ -424,5 +424,5 @@
 
     ///Read/write/reference map of the nodes to type \c T.
-    /// \sa MemoryMapSkeleton
+    /// \sa MemoryMap
     /// \todo We may need copy constructor
     /// \todo We may need conversion from other nodetype
@@ -483,5 +483,5 @@
     ///It behaves exactly in the same way as \ref NodeMap.
     /// \sa NodeMap
-    /// \sa MemoryMapSkeleton
+    /// \sa MemoryMap
     /// \todo We may need copy constructor
     /// \todo We may need conversion from other edgetype
@@ -538,5 +538,5 @@
   ///
   /// \todo This blabla could be replaced by a sepatate description about
-  /// Skeletons.
+  /// s.
   ///
   /// It can be used for checking the interface compatibility,