Changeset 2117:96efb4fa0736 in lemon-0.x

Timestamp:

07/04/06 19:49:01 (19 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

• Revised "Concepts" group documentation
• Other minor doc improvements

Files:

• doc/groups.dox (modified) (7 diffs)
• lemon/concept/graph.h (modified) (1 diff)
• lemon/list_graph.h (modified) (3 diffs)

doc/groups.dox

@@ -26 +26 @@
 Alteration of standard containers need a very limited number of 
 operations, these together satisfy the everyday requirements. 
-In the case of graph strutures, different operations are needed which do 
+In the case of graph structures, different operations are needed which do 
 not alter the physical graph, but gives another view. If some nodes or 
 edges have to be hidden or the reverse oriented graph have to be used, then 
-this is the case. It also may happen that in a flow implemenation 
+this is the case. It also may happen that in a flow implementation 
 the residual graph can be accessed by another algorithm, or a node-set 
 is to be shrunk for another algorithm. 
@@ -46 +46 @@
 \brief Graph types between real graphs and graph adaptors.
 
-Graph types between real graphs and graph adaptors. These classes
-wrap graphs to give new functionality as the adaptors do it. But the
-other way they are not light-weigth structures as the adaptors.
+Graph types between real graphs and graph adaptors. These classes wrap
+graphs to give new functionality as the adaptors do it. On the other
+hand they are not light-weight structures as the adaptors.
 */
 
@@ -78 +78 @@
 
 Most of them are \ref lemon::concept::ReadMap "ReadMap"s. They can
-make arithmetic oprerations between one or two maps (negation, scaling,
+make arithmetic operations between one or two maps (negation, scaling,
 addition, multiplication etc.) or e.g. convert a map to another one
 of different Value type.
@@ -186 +186 @@
 @defgroup spantree Minimum Cost Spanning Tree Algorithms
 @ingroup algs
-\brief This group containes the algorithms for finding a minimum cost spanning
+\brief This group contains the algorithms for finding a minimum cost spanning
 tree in a graph
 
-This group containes the algorithms for finding a minimum cost spanning
+This group contains the algorithms for finding a minimum cost spanning
 tree in a graph
 */
@@ -233 +233 @@
 Here you can find tools for importing and exporting graphs 
 and graph related data. Now it supports the LEMON format, the
-dimacs format and the encapsulated postscript format.
+\c DIMACS format and the encapsulated postscript format.
 */
 
@@ -269 +269 @@
 @defgroup eps_io Postscript exporting
 @ingroup io_group
-\brief General EPS drawer and graph exporter
-
-This group contains general EPS drawing methods and special
+\brief General \c EPS drawer and graph exporter
+
+This group contains general \c EPS drawing methods and special
 graph exporting tools. 
 */
@@ -287 +287 @@
 classes implemented in LEMON.
 
-One aim of these classes is to make it easier to check if a certain
-class or template function is correctly implemented.
-
-The other (sometimes even more important) aim is to document the concepts.
+The purpose of the classes in this group is fourfold.
+ 
+- These classes contain the documentations of the concepts. In order
+  to avoid document multiplications, an implementation of a concept
+  simply refers to the corresponding concept class.
+
+- These classes declare every functions, <tt>typedef<tt>s etc. an
+  implementation of the concepts should provide, however completely
+  without implementations and real data structures behind the
+  interface. On the other hand they should provide nothing else. All
+  the algorithms working on a data structure meeting a certain concept
+  should compile with these classes. (Though it will not run properly,
+  of course.) In this way it is easily to check if an algorithm
+  doesn't use any extra feature of a certain implementation.
+
+- The concept descriptor classes also provide a <em>checker class<em>
+  that makes it possible check whether a certain implementation of a
+  concept indeed provides all the required features.
+
+- Finally, They can serve as a skeleton of a new implementation of a concept.
 
 */

lemon/concept/graph.h

@@ -60 +60 @@
     /// @{
 
-    /// An empty graph class.
-  
-    /// This class provides all the common features of a graph structure,
-    /// however completely without implementations and real data structures
-    /// behind the interface.
-    /// All graph algorithms should compile with this class, but it will not
-    /// run properly, of course.
+    /// The directed graph concept
+
+    /// This class describes the \ref concept "concept" of the
+    /// immutable directed graphs.
     ///
-    /// It can be used for checking the interface compatibility,
-    /// or it can serve as a skeleton of a new graph structure.
-    /// 
-    /// Also, you will find here the full documentation of a certain graph
-    /// feature, the documentation of a real graph imlementation
-    /// like @ref ListGraph or
-    /// @ref SmartGraph will just refer to this structure.
+    /// Note that actual graph implementation like @ref ListGraph or
+    /// @ref SmartGraph may have several additional functionality.
     ///
-    /// \todo A pages describing the concept of concept description would
-    /// be nice.
+    /// \sa concept
     class Graph {
     public:

lemon/list_graph.h

@@ -315 +315 @@
   ///A list graph class.
 
-  ///This is a simple and fast erasable graph implementation.
+  ///This is a simple and fast graph implementation.
   ///
-  ///It conforms to the \ref concept::Graph "Graph" concept and it
+  ///It conforms to the \ref concept::Graph "Graph concept" and it
   ///also provides several additional useful extra functionalities.
   ///The most of the member functions and nested classes are
@@ -718 +718 @@
   ///An undirected list graph class.
 
-  ///This is a simple and fast erasable undirected graph implementation.
+  ///This is a simple and fast undirected graph implementation.
   ///
   ///It conforms to the
-  ///\ref concept::UGraph "UGraph" concept.
+  ///\ref concept::UGraph "UGraph concept".
   ///
   ///\sa concept::UGraph.
@@ -1146 +1146 @@
   ///
   /// This is a bipartite undirected graph implementation.
-  /// It is conforms to the \ref concept::ErasableBpUGraph "ErasableBpUGraph" 
-  /// concept.
+  /// It is conforms to the \ref concept::BpUGraph "BpUGraph concept".
   /// \sa concept::BpUGraph.
   ///