# HG changeset patch
# User alpar
# Date 1095436310 0
# Node ID 9d0bfd35b97ccb83a4fed8b459ac5860ac7d62b2
# Parent  5e284075b193bc881884bc831b57472635bf2f08
- Name changing: XYZGraphSkeleton -> XYZGraph
- Fix some bad \ref's in the doc.

diff -r 5e284075b193 -r 9d0bfd35b97c doc/graphs.dox
--- a/doc/graphs.dox	Fri Sep 17 15:11:39 2004 +0000
+++ b/doc/graphs.dox	Fri Sep 17 15:51:50 2004 +0000
@@ -9,31 +9,31 @@
 
 
 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
 or delete edges or nodes). Most of the graph algorithms will run on
 these graphs.
 
 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)
 such a graph.
 
 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.
 
 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
 \ref hugo::SymSmartGraph "SymSmartGraph" classes are very similar to
diff -r 5e284075b193 -r 9d0bfd35b97c src/hugo/dijkstra.h
--- a/src/hugo/dijkstra.h	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/hugo/dijkstra.h	Fri Sep 17 15:51:50 2004 +0000
@@ -18,10 +18,11 @@
 
   ///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.
   ///
@@ -32,7 +33,7 @@
   ///lengths of the edges. It is read once for each edge, so the map
   ///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
   ///is using \ref BinHeap "binary heap".
diff -r 5e284075b193 -r 9d0bfd35b97c src/hugo/full_graph.h
--- a/src/hugo/full_graph.h	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/hugo/full_graph.h	Fri Sep 17 15:51:50 2004 +0000
@@ -27,9 +27,9 @@
   ///This is a simple and fast directed full graph implementation.
   ///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?
   ///
diff -r 5e284075b193 -r 9d0bfd35b97c src/hugo/list_graph.h
--- a/src/hugo/list_graph.h	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/hugo/list_graph.h	Fri Sep 17 15:51:50 2004 +0000
@@ -29,10 +29,9 @@
 
   ///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 {
 
     //Nodes are double linked.
@@ -312,7 +311,6 @@
       NodeIt() : Node() { }
       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++() {
 	n=G->nodes[n].next; 
@@ -426,7 +424,7 @@
   ///that complements this
   ///feature by
   ///storing shared values for the edge pairs. The usual
-  ///\ref GraphSkeleton::EdgeMap "EdgeMap"
+  ///\ref Graph::EdgeMap "EdgeMap"
   ///can be used
   ///as well.
   ///
@@ -494,12 +492,13 @@
   ///The most useful application of this class is to be the node set of an
   ///\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 {
 
     //Nodes are double linked.
@@ -790,12 +789,13 @@
   ///(and from \ref EdgeSet, as well)
   ///
   ///\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 {
 
@@ -897,15 +897,14 @@
     
     ///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) {}
     ///Copy constructor
 
     ///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) {}
     
diff -r 5e284075b193 -r 9d0bfd35b97c src/hugo/skeletons/graph.h
--- a/src/hugo/skeletons/graph.h	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/hugo/skeletons/graph.h	Fri Sep 17 15:51:50 2004 +0000
@@ -4,7 +4,7 @@
 
 ///\ingroup skeletons
 ///\file
-///\brief Declaration of GraphSkeleton.
+///\brief Declaration of Graph.
 
 #include <hugo/invalid.h>
 #include <hugo/skeletons/maps.h>
@@ -31,19 +31,19 @@
     /// feature, the documentation of a real graph imlementation
     /// like @ref ListGraph or
     /// @ref SmartGraph will just refer to this structure.
-    class StaticGraphSkeleton
+    class StaticGraph
     {
     public:
       /// Defalult constructor.
 
       /// 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, 
       /// or in other words, the trivial node iterator.
@@ -122,14 +122,14 @@
 
 	/// Sets the iterator to the first node of \c g.
 	///
-	NodeIt(const StaticGraphSkeleton& g) { }
+	NodeIt(const StaticGraph& g) { }
 	/// Node -> NodeIt conversion.
 
 	/// Sets the iterator to the node of \c g pointed by the trivial 
 	/// iterator n.
 	/// 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.
 
 	/// Assign the iterator to the next node.
@@ -214,13 +214,13 @@
 	/// node
 	///@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
 
 	/// Sets the iterator to the value of the trivial iterator \c e.
 	/// 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
 	
 	/// Assign the iterator to the next 
@@ -263,13 +263,13 @@
 	/// node
 	///@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
 
 	/// Sets the iterator to the value of the trivial iterator \c e.
 	/// 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
 
 	/// Assign the iterator to the next inedge of the corresponding node.
@@ -307,13 +307,13 @@
 	/// This constructor set the iterator to the first edge of
 	/// node
 	///@param g the graph
-	EdgeIt(const StaticGraphSkeleton& g) { }
+	EdgeIt(const StaticGraph& g) { }
 	/// Edge -> EdgeIt conversion
 
 	/// Sets the iterator to the value of the trivial iterator \c e.
 	/// 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
 	
 	/// Assign the iterator to the next 
@@ -370,29 +370,31 @@
 
       /// .
       
-      ///\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; }
 
 
       ///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
 	template<typename TT> NodeMap(const NodeMap<TT>&) { }
@@ -403,8 +405,9 @@
 
       ///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!
       template<class T> class EdgeMap
@@ -413,9 +416,9 @@
       public:
 
 	/// .
-	EdgeMap(const StaticGraphSkeleton&) { }
+	EdgeMap(const StaticGraph&) { }
 	/// .
-	EdgeMap(const StaticGraphSkeleton&, T) { }
+	EdgeMap(const StaticGraph&, T) { }
     
 	///Copy constructor
 	template<typename TT> EdgeMap(const EdgeMap<TT>&) { }
@@ -429,17 +432,17 @@
   
     /// 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:
       /// Defalult constructor.
 
       /// Defalult constructor.
       ///
-      ExtendableGraphSkeleton() { }
+      ExtendableGraph() { }
       ///Add a new node to the graph.
 
       /// \return the new node.
@@ -447,31 +450,31 @@
       Node addNode() { return INVALID; }
       ///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.
 
       /// 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() { }
     };
 
     /// 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:
       /// Defalult constructor.
 
       /// Defalult constructor.
       ///
-      ErasableGraphSkeleton() { }
+      ErasableGraph() { }
       /// Deletes a node.
 
       /// Deletes node \c n node.
diff -r 5e284075b193 -r 9d0bfd35b97c src/hugo/smart_graph.h
--- a/src/hugo/smart_graph.h	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/hugo/smart_graph.h	Fri Sep 17 15:51:50 2004 +0000
@@ -30,9 +30,9 @@
   ///This is a simple and fast graph implementation.
   ///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.
   ///
@@ -302,7 +302,7 @@
   ///that complements this
   ///feature by
   ///storing shared values for the edge pairs. The usual
-  ///\ref GraphSkeleton::EdgeMap "EdgeMap"
+  ///\ref Graph::EdgeMap "EdgeMap"
   ///can be used
   ///as well.
   ///
@@ -310,7 +310,7 @@
   ///using \ref opposite.
   ///\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
   {
diff -r 5e284075b193 -r 9d0bfd35b97c src/test/bfs_test.cc
--- a/src/test/bfs_test.cc	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/test/bfs_test.cc	Fri Sep 17 15:51:50 2004 +0000
@@ -10,7 +10,7 @@
 
 void check_Bfs_Compile() 
 {
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Edge Edge;
   typedef Graph::Node Node;
diff -r 5e284075b193 -r 9d0bfd35b97c src/test/dfs_test.cc
--- a/src/test/dfs_test.cc	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/test/dfs_test.cc	Fri Sep 17 15:51:50 2004 +0000
@@ -10,7 +10,7 @@
 
 void check_Dfs_SmartGraph_Compile() 
 {
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Edge Edge;
   typedef Graph::Node Node;
diff -r 5e284075b193 -r 9d0bfd35b97c src/test/dijkstra_test.cc
--- a/src/test/dijkstra_test.cc	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/test/dijkstra_test.cc	Fri Sep 17 15:51:50 2004 +0000
@@ -11,7 +11,7 @@
 void check_Dijkstra_BinHeap_Compile() 
 {
   typedef int VType;
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Edge Edge;
   typedef Graph::Node Node;
diff -r 5e284075b193 -r 9d0bfd35b97c src/test/graph_test.cc
--- a/src/test/graph_test.cc	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/test/graph_test.cc	Fri Sep 17 15:51:50 2004 +0000
@@ -51,15 +51,15 @@
   }  
 }
 
-//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
 template void hugo::checkCompileGraph<SmartGraph>(SmartGraph &);
diff -r 5e284075b193 -r 9d0bfd35b97c src/test/kruskal_test.cc
--- a/src/test/kruskal_test.cc	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/test/kruskal_test.cc	Fri Sep 17 15:51:50 2004 +0000
@@ -14,10 +14,10 @@
 
 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);
 }
 
diff -r 5e284075b193 -r 9d0bfd35b97c src/test/preflow_test.cc
--- a/src/test/preflow_test.cc	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/test/preflow_test.cc	Fri Sep 17 15:51:50 2004 +0000
@@ -13,7 +13,7 @@
 void check_Preflow() 
 {
   typedef int VType;
-  typedef skeleton::StaticGraphSkeleton Graph;
+  typedef skeleton::StaticGraph Graph;
 
   typedef Graph::Node Node;
   typedef Graph::Edge Edge;
diff -r 5e284075b193 -r 9d0bfd35b97c src/work/alpar/list_graph_demo.cc
--- a/src/work/alpar/list_graph_demo.cc	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/work/alpar/list_graph_demo.cc	Fri Sep 17 15:51:50 2004 +0000
@@ -7,7 +7,7 @@
 using namespace hugo;
 
 typedef ListGraph Graph;
-//typedef GraphSkeleton Graph;
+//typedef Graph Graph;
 
 
 Graph::OutEdgeIt safeFirstOut(const Graph &G, Graph::Node n)
diff -r 5e284075b193 -r 9d0bfd35b97c src/work/alpar/smart_graph_demo.cc
--- a/src/work/alpar/smart_graph_demo.cc	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/work/alpar/smart_graph_demo.cc	Fri Sep 17 15:51:50 2004 +0000
@@ -7,7 +7,7 @@
 using namespace hugo;
 
 typedef SmartGraph Graph;
-//typedef GraphSkeleton Graph;
+//typedef Graph Graph;
 
 
 Graph::OutEdgeIt safeFirstOut(const Graph &G, Graph::Node n)
diff -r 5e284075b193 -r 9d0bfd35b97c src/work/deba/dijkstra.h
--- a/src/work/deba/dijkstra.h	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/work/deba/dijkstra.h	Fri Sep 17 15:51:50 2004 +0000
@@ -18,7 +18,7 @@
 
   ///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.
   ///
   ///The type of the length is determined by the \c ValueType of the length map.
@@ -32,7 +32,7 @@
   ///lengths of the edges. It is read once for each edge, so the map
   ///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
   ///is using \ref BinHeap "binary heap".
diff -r 5e284075b193 -r 9d0bfd35b97c src/work/deba/list_graph.h
--- a/src/work/deba/list_graph.h	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/work/deba/list_graph.h	Fri Sep 17 15:51:50 2004 +0000
@@ -27,8 +27,8 @@
   ///This is a simple and fast erasable graph implementation.
   ///
   ///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 {
 
     //Nodes are double linked.
@@ -382,7 +382,7 @@
   ///that complements this
   ///feature by
   ///storing shared values for the edge pairs. The usual
-  ///\ref GraphSkeleton::EdgeMap "EdgeMap"
+  ///\ref Graph::EdgeMap "EdgeMap"
   ///can be used
   ///as well.
   ///
diff -r 5e284075b193 -r 9d0bfd35b97c src/work/marci/experiment/graph_wrapper.h
--- a/src/work/marci/experiment/graph_wrapper.h	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/work/marci/experiment/graph_wrapper.h	Fri Sep 17 15:51:50 2004 +0000
@@ -161,7 +161,7 @@
   };
 
   template<typename GraphWrapper>
-  class GraphWrapperSkeleton {
+  class GraphWrapper {
   protected:
     GraphWrapper gw;
   
@@ -184,7 +184,7 @@
       NodeIt(const typename GraphWrapper::NodeIt& n) : 
 	GraphWrapper::NodeIt(n) { }
       NodeIt(const Invalid& i) : GraphWrapper::NodeIt(i) { }
-      NodeIt(const GraphWrapperSkeleton<GraphWrapper>& _G) : 
+      NodeIt(const GraphWrapper<GraphWrapper>& _G) : 
 	GraphWrapper::NodeIt(_G.gw) { }
     };
     typedef typename GraphWrapper::Edge Edge;
@@ -195,7 +195,7 @@
       OutEdgeIt(const typename GraphWrapper::OutEdgeIt& e) : 
 	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) { }
     };
     //typedef typename GraphWrapper::InEdgeIt InEdgeIt;
@@ -205,7 +205,7 @@
       InEdgeIt(const typename GraphWrapper::InEdgeIt& e) : 
 	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) { }
     };
     //typedef typename GraphWrapper::SymEdgeIt SymEdgeIt;
@@ -216,13 +216,13 @@
       EdgeIt(const typename GraphWrapper::EdgeIt& e) : 
 	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); }
     //BaseGraph& getGraph() const { return gw.getGraph(); }
@@ -269,17 +269,17 @@
     
     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) { }
     };
 
     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) { }
     };
   };
@@ -365,9 +365,9 @@
 //   };
 
 //   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;
     
@@ -378,13 +378,13 @@
 //     //typedef typename Graph::NodeIt NodeIt;
   
 //     //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; }
 //     //Graph& getGraph() const { return (*graph); }
@@ -429,30 +429,30 @@
 //     //void clear() const { graph->clear(); }
 
 //     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
     //and we do not want to use RevGraphWrapper::InEdgeIt,
@@ -461,33 +461,33 @@
     //graphs have to define their non-existing iterators to void
     //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 { 
       gw.first(i); 
@@ -677,30 +677,30 @@
 
 
   template<typename GraphWrapper>
-  class UndirGraphWrapper : public GraphWrapperSkeleton<GraphWrapper> {
+  class UndirGraphWrapper : public GraphWrapper<GraphWrapper> {
   protected:
 //    GraphWrapper gw;
 
   public:
     //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:
 
     //UndirGraphWrapper() : graph(0) { }
     UndirGraphWrapper(GraphWrapper _gw) : 
-      GraphWrapperSkeleton<GraphWrapper>(_gw) { }  
+      GraphWrapper<GraphWrapper>(_gw) { }  
 
     //UndirGraphWrapper(GraphWrapper _gw) : gw(_gw) { }
 
@@ -864,10 +864,10 @@
 //     };
 
 //     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) { }
 //     };
@@ -947,16 +947,16 @@
 
 
   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:
     //const Graph* graph;
@@ -967,7 +967,7 @@
 
     ResGraphWrapper(const GraphWrapper& _gw, FlowMap& _flow, 
 		    const CapacityMap& _capacity) : 
-      GraphWrapperSkeleton<GraphWrapper>(_gw), 
+      GraphWrapper<GraphWrapper>(_gw), 
       flow(&_flow), capacity(&_capacity) { }
 
     //void setGraph(const Graph& _graph) { graph = &_graph; }
@@ -1264,19 +1264,19 @@
 
   //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 { 
       gw.first(i); 
diff -r 5e284075b193 -r 9d0bfd35b97c src/work/marci/experiment/graph_wrapper_1.h
--- a/src/work/marci/experiment/graph_wrapper_1.h	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/work/marci/experiment/graph_wrapper_1.h	Fri Sep 17 15:51:50 2004 +0000
@@ -758,10 +758,10 @@
 //     };
 
 //     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) { }
 //     };
diff -r 5e284075b193 -r 9d0bfd35b97c src/work/peter/edgepathgraph.h
--- a/src/work/peter/edgepathgraph.h	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/work/peter/edgepathgraph.h	Fri Sep 17 15:51:50 2004 +0000
@@ -296,7 +296,7 @@
     ///Read/write/reference map of the nodes to type \c T.
 
     ///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
     /// \todo We may need operator=
@@ -337,7 +337,7 @@
     ///Read/write/reference map of the edges to type \c T.
     ///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
     /// \todo We may need operator=
@@ -374,7 +374,7 @@
   /// run properly, of course.
   ///
   /// \todo This blabla could be replaced by a sepatate description about
-  /// Skeletons.
+  /// s.
   ///
   /// It can be used for checking the interface compatibility,
   /// or it can serve as a skeleton of a new graph structure.
diff -r 5e284075b193 -r 9d0bfd35b97c src/work/peter/hierarchygraph.h
--- a/src/work/peter/hierarchygraph.h	Fri Sep 17 15:11:39 2004 +0000
+++ b/src/work/peter/hierarchygraph.h	Fri Sep 17 15:51:50 2004 +0000
@@ -423,7 +423,7 @@
     ///Read/write/reference map of the nodes to type \c T.
 
     ///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
     /// \todo We may need operator=
@@ -482,7 +482,7 @@
     ///Read/write/reference map of the edges to type \c T.
     ///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
     /// \todo We may need operator=
@@ -537,7 +537,7 @@
   /// run properly, of course.
   ///
   /// \todo This blabla could be replaced by a sepatate description about
-  /// Skeletons.
+  /// s.
   ///
   /// It can be used for checking the interface compatibility,
   /// or it can serve as a skeleton of a new graph structure.