Changeset 880:9d0bfd35b97c in lemon-0.x

Timestamp:

09/17/04 17:51:50 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1188

Message:

• Name changing: XYZGraphSkeleton -> XYZGraph
• Fix some bad \ref's in the doc.

Files:

• doc/graphs.dox (modified) (4 diffs)
• src/hugo/dijkstra.h (modified) (2 diffs)
• src/hugo/full_graph.h (modified) (1 diff)
• src/hugo/list_graph.h (modified) (7 diffs)
• src/hugo/skeletons/graph.h (modified) (21 diffs)
• src/hugo/smart_graph.h (modified) (3 diffs)
• src/test/bfs_test.cc (modified) (1 diff)
• src/test/dfs_test.cc (modified) (1 diff)
• src/test/dijkstra_test.cc (modified) (1 diff)
• src/test/graph_test.cc (modified) (1 diff)
• src/test/kruskal_test.cc (modified) (1 diff)
• src/test/preflow_test.cc (modified) (1 diff)
• src/work/alpar/list_graph_demo.cc (modified) (1 diff)
• src/work/alpar/smart_graph_demo.cc (modified) (1 diff)
• src/work/deba/dijkstra.h (modified) (2 diffs)
• src/work/deba/list_graph.h (modified) (2 diffs)
• src/work/marci/experiment/graph_wrapper.h (modified) (18 diffs)
• src/work/marci/experiment/graph_wrapper_1.h (modified) (1 diff)
• src/work/peter/edgepathgraph.h (modified) (3 diffs)
• src/work/peter/hierarchygraph.h (modified) (3 diffs)

doc/graphs.dox

@@ -10 +10 @@
 
 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 +17 @@
 
 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 +23 @@
 
 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 +29 @@
 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

src/hugo/dijkstra.h

@@ -19 +19 @@
   ///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 +34 @@
   ///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

src/hugo/full_graph.h

@@ -28 +28 @@
   ///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?

src/hugo/list_graph.h

@@ -30 +30 @@
   ///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 +312 @@
       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 +425 @@
   ///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 +493 @@
   ///\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 +790 @@
   ///
   ///\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 +898 @@
     ///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 +905 @@
     ///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) {}

src/hugo/skeletons/graph.h

@@ -5 +5 @@
 ///\ingroup skeletons
 ///\file
-///\brief Declaration of GraphSkeleton.
+///\brief Declaration of Graph.
 
 #include <hugo/invalid.h>
@@ -32 +32 @@
     /// like @ref ListGraph or
     /// @ref SmartGraph will just refer to this structure.
-    class StaticGraphSkeleton
+    class StaticGraph
     {
     public:
@@ -39 +39 @@
       /// 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 +123 @@
         /// Sets the iterator to the first node of \c g.
         ///
-        NodeIt(const StaticGraphSkeleton& g) { }
+        NodeIt(const StaticGraph& g) { }
         /// Node -> NodeIt conversion.
 
@@ -130 +130 @@
         /// 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 +215 @@
         ///@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 +221 @@
         /// 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 +264 @@
         ///@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 +270 @@
         /// 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 +308 @@
         /// node
         ///@param g the graph
-        EdgeIt(const StaticGraphSkeleton& g) { }
+        EdgeIt(const StaticGraph& g) { }
         /// Edge -> EdgeIt conversion
 
@@ -314 +314 @@
         /// 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 +371 @@
       /// .
       
-      ///\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 +383 @@
       ///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 +406 @@
       ///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 +417 @@
 
         /// .
-        EdgeMap(const StaticGraphSkeleton&) { }
+        EdgeMap(const StaticGraph&) { }
         /// .
-        EdgeMap(const StaticGraphSkeleton&, T) { }
+        EdgeMap(const StaticGraph&, T) { }
     
         ///Copy constructor
@@ -430 +433 @@
     /// 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 +443 @@
       /// Defalult constructor.
       ///
-      ExtendableGraphSkeleton() { }
+      ExtendableGraph() { }
       ///Add a new node to the graph.
 
@@ -448 +451 @@
       ///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 +460 @@
       /// 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 +466 @@
     /// 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 +475 @@
       /// Defalult constructor.
       ///
-      ErasableGraphSkeleton() { }
+      ErasableGraph() { }
       /// Deletes a node.
 

src/hugo/smart_graph.h

@@ -31 +31 @@
   ///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 +303 @@
   ///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 +311 @@
   ///\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

src/test/bfs_test.cc

@@ -11 +11 @@
 void check_Bfs_Compile() 
 {
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Edge Edge;

src/test/dfs_test.cc

@@ -11 +11 @@
 void check_Dfs_SmartGraph_Compile() 
 {
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Edge Edge;

src/test/dijkstra_test.cc

@@ -12 +12 @@
 {
   typedef int VType;
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Edge Edge;

src/test/graph_test.cc

@@ -52 +52 @@
 }
 
-//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

src/test/kruskal_test.cc

@@ -15 +15 @@
 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);
 }

src/test/preflow_test.cc

@@ -14 +14 @@
 {
   typedef int VType;
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Node Node;

src/work/alpar/list_graph_demo.cc

@@ -8 +8 @@
 
 typedef ListGraph Graph;
-//typedef GraphSkeleton Graph;
+//typedef Graph Graph;
 
 

src/work/alpar/smart_graph_demo.cc

@@ -8 +8 @@
 
 typedef SmartGraph Graph;
-//typedef GraphSkeleton Graph;
+//typedef Graph Graph;
 
 

src/work/deba/dijkstra.h

@@ -19 +19 @@
   ///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 +33 @@
   ///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

src/work/deba/list_graph.h

@@ -28 +28 @@
   ///
   ///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 +383 @@
   ///feature by
   ///storing shared values for the edge pairs. The usual
-  ///\ref GraphSkeleton::EdgeMap "EdgeMap"
+  ///\ref Graph::EdgeMap "EdgeMap"
   ///can be used
   ///as well.

src/work/marci/experiment/graph_wrapper.h

@@ -162 +162 @@
 
   template<typename GraphWrapper>
-  class GraphWrapperSkeleton {
+  class GraphWrapper {
   protected:
     GraphWrapper gw;
@@ -185 +185 @@
         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 +196 @@
         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 +206 @@
         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 +217 @@
         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 +270 @@
     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 +278 @@
     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 +366 @@
 
 //   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 +379 @@
   
 //     //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 +430 @@
 
 //     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 +462 @@
     //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 +678 @@
 
   template<typename GraphWrapper>
-  class UndirGraphWrapper : public GraphWrapperSkeleton<GraphWrapper> {
+  class UndirGraphWrapper : public GraphWrapper<GraphWrapper> {
   protected:
 //    GraphWrapper gw;
@@ -685 +685 @@
     //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 +701 @@
     //UndirGraphWrapper() : graph(0) { }
     UndirGraphWrapper(GraphWrapper _gw) : 
-      GraphWrapperSkeleton<GraphWrapper>(_gw) { }  
+      GraphWrapper<GraphWrapper>(_gw) { }  
 
     //UndirGraphWrapper(GraphWrapper _gw) : gw(_gw) { }
@@ -865 +865 @@
 
 //     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 +948 @@
 
   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 +968 @@
     ResGraphWrapper(const GraphWrapper& _gw, FlowMap& _flow, 
                     const CapacityMap& _capacity) : 
-      GraphWrapperSkeleton<GraphWrapper>(_gw), 
+      GraphWrapper<GraphWrapper>(_gw), 
       flow(&_flow), capacity(&_capacity) { }
 
@@ -1265 +1265 @@
   //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 { 

src/work/marci/experiment/graph_wrapper_1.h

@@ -759 +759 @@
 
 //     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) { }

src/work/peter/edgepathgraph.h

@@ -297 +297 @@
 
     ///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 +338 @@
     ///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 +375 @@
   ///
   /// \todo This blabla could be replaced by a sepatate description about
-  /// Skeletons.
+  /// s.
   ///
   /// It can be used for checking the interface compatibility,

src/work/peter/hierarchygraph.h

@@ -424 +424 @@
 
     ///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 +483 @@
     ///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 +538 @@
   ///
   /// \todo This blabla could be replaced by a sepatate description about
-  /// Skeletons.
+  /// s.
   ///
   /// It can be used for checking the interface compatibility,