Changeset 880:9d0bfd35b97c in lemon-0.x for src/hugo

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.

Location:

src/hugo

Files:

• dijkstra.h (modified) (2 diffs)
• full_graph.h (modified) (1 diff)
• list_graph.h (modified) (7 diffs)
• skeletons/graph.h (modified) (21 diffs)
• smart_graph.h (modified) (3 diffs)

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