-                      r224
+                      r242
 #ifndef BIN_HEAP_HH
 #define BIN_HEAP_HH
+///\file
+///\brief Binary Heap implementation.
 #include <vector>

src/work/alpar/dijkstra/dijkstra.h

-                      r229
+                      r242
 // -*- C++ -*-
 /*
  *template <Graph, T, Heap=FibHeap, LengthMap=Graph::EdgeMap<T> >
 …
 #ifndef HUGO_DIJKSTRA_H
 #define HUGO_DIJKSTRA_H
+///\file
+///\brief Dijkstra algorithm.
 #include <fib_heap.h>
 …
   ///The type of the length is determined by the \c ValueType of the length map.
   ///
   ///It is also posible to change the underlying priority heap.
+  ///It is also possible to change the underlying priority heap.
   ///
   ///\param Graph The graph type the algorithm runs on.
+  ///\param LengthMap This read-only EdgeMap determines the
+  ///\param LengthMap This read-only
+  ///EdgeMap
+  ///determines the
   ///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.
+  ///length if it is necessary. The default map type is
+  ///\ref GraphSkeleton::EdgeMap "Graph::EdgeMap<int>"
   ///\param Heap The heap type used by the %Dijkstra
   ///algorithm. The default
   ///is using \ref BinHeap "binary heap".
+#ifdef DOXYGEN
+  template <typename Graph,
+            typename LengthMap,
+            typename Heap>
+#else
   template <typename Graph,
             typename LengthMap=typename Graph::EdgeMap<int>,
 …
                                    typename LengthMap::ValueType,
                                    typename Graph::NodeMap<int> > >
+#endif
   class Dijkstra{
   public:
 …
     //    bool reached(Node v) { return reach[v]; }
     ///Chechs if a node is reachable from the source.
+    ///Checks if a node is reachable from the source.
     ///Returns \c true if \c v is reachable from the source.

src/work/alpar/dijkstra/fib_heap.h

-                      r224
+                      r242
 #define FIB_HEAP_H
+///\file
+///\brief Fibonacci Heap implementation.
 #include <vector>
 #include <functional>
 …
     ///\todo It is use nowhere
     ///\todo It doesn't conforms to the naming conventions.
+    ///\todo It doesn't conform to the naming conventions.
   public:
     enum state_enum {

src/work/alpar/emptygraph.h

-                      r216
+                      r242
 #define HUGO_EMPTYGRAPH_H
+///\file
+///\brief Declaration of GraphSkeleton.
 #include <invalid.h>
 …
   /// An empty graph class.
-  /// When you read this for the first time,
-  /// please send an e-mail to alpar\@cs.elte.hu.
-  ///
   /// This class provides all the common features of a graph structure,
   /// however completely without implementations and real data structures
 …
     };
     /// This iterator goes trought the outgoing edges of a node.
     /// This iterator goes trought the \e outgoing edges of a certain node
+    /// This iterator goes trough the outgoing edges of a node.
+    /// This iterator goes trough the \e outgoing edges of a certain node
     /// of a graph.
     /// Its usage is quite simple, for example you can count the number
 …
     };
     /// This iterator goes trought the incoming edges of a node.
     /// This iterator goes trought the \e incoming edges of a certain node
+    /// This iterator goes trough the incoming edges of a node.
+    /// This iterator goes trough the \e incoming edges of a certain node
     /// of a graph.
     /// Its usage is quite simple, for example you can count the number
 …
     NodeIt &first(NodeIt &i) const { return i;}
+    /// The first incoming edge.
+    InEdgeIt &first(InEdgeIt &i, Node n) const { return i;}
     /// The first outgoing edge.
-    InEdgeIt &first(InEdgeIt &i, Node n) const { return i;}
-    /// The first incoming edge.
     OutEdgeIt &first(OutEdgeIt &i, Node n) const { return i;}
     //  SymEdgeIt &first(SymEdgeIt &, Node) const { return i;}
 …
     ///Gives back the \e id of a node.
     ///\warning Not all graph structure provide this feature.
+    ///\warning Not all graph structures provide this feature.
     ///
     int id(const Node) const { return 0;}
     ///Gives back the \e id of an edge.
     ///\warning Not all graph structure provide this feature.
+    ///\warning Not all graph structures provide this feature.
     ///
     int id(const Edge) const { return 0;}
 …
     Edge addEdge(Node tail, Node head) { return INVALID;}
+    /// Deletes a node.
+    ///\warning Not all graph structure provide this feature.
+    ///
+    void erase(Node n) {}
+    /// Deletes an edge.
+    ///\warning Not all graph structure provide this feature.
+    ///
+    void erase(Edge e) {}
+    /// Reset the graph.
+    /// Resets the graph.
     /// This function deletes all edges and nodes of the graph.
 …
     int nodeNum() const { return 0;}
     int edgeNum() const { return 0;}
+    /// Defalult constructor.
     GraphSkeleton() {}
+    ///Copy consructor.
     GraphSkeleton(const GraphSkeleton &G) {}
     ///Read/write/reference map of the nodes to type \c T.
 …
   };
+  /// An empty eraseable graph class.
+  /// This class provides all the common features of an \e eraseable 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.
+  ///
+  /// \todo This blabla could be replaced by a sepatate description about
+  /// Skeletons.
+  ///
+  /// 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.
+  class EraseableGraphSkeleton : public GraphSkeleton
+  {
+  public:
+    /// Deletes a node.
+    void erase(Node n) {}
+    /// Deletes an edge.
+    void erase(Edge e) {}
+    /// Defalult constructor.
+    GraphSkeleton() {}
+    ///Copy consructor.
+    GraphSkeleton(const GraphSkeleton &G) {}
+  };
   // @}

src/work/alpar/invalid.h

-                      r184
+                      r242
 #ifndef HUGO_INVALID_H
 #define HUGO_INVALID_H
+///\file
+///\brief Definition of INVALID.
 namespace hugo {

src/work/alpar/mapskeleton.h

-                      r209
+                      r242
 #ifndef HUGO_MAPSKELETON_H
 #define HUGO_MAPSKELETON_H
+///\file
+///\brief Map concepts checking classes for testing and documenting.
 namespace hugo {

src/work/alpar/smart_graph.h

-                      r215
+                      r242
 #define HUGO_SMART_GRAPH_H
+///\file
+///\brief SmartGraph and SymSmartGraph classes.
 #include <vector>
 #include <limits.h>
 …
   ///A smart graph class.
-  /// When you read this for the first time,
-  /// please send an e-mail to alpar\@cs.elte.hu.
-  ///
   ///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>.
   ///Apart from this it conforms to the graph interface documented under
+  ///It conforms to the graph interface documented under
   ///the description of \ref GraphSkeleton.
   ///\sa \ref GraphSkeleton.

src/work/athos/xy/boundingbox.h

-                      r240
+                      r242
 // -*- c++ -*-
-/**
-Implementation of a bounding box of plainvectors.
-*/
 #ifndef HUGO_BOUNDINGBOX_H
 #define HUGO_BOUNDINGBOX_H
 …
 namespace hugo {
+  /** \brief
+     Implementation of a bounding box of plainvectors.
+  */
   template<typename T>
     class BoundingBox {

src/work/athos/xy/xy.h

-                      r240
+                      r242
 // -*- c++ -*-
-/**
-dimensional vector (plainvector) implementation
-*/
 #ifndef HUGO_XY_H
 #define HUGO_XY_H
 …
 namespace hugo {
+/** \brief
+dimensional vector (plainvector) implementation
+*/
   template<typename T>
     class xy {

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 242:b255f25ad394 in lemon-0.x for src/work

Legend:

Download in other formats: