Changeset 686:fc8a3393e0d9 in lemon-0.x for src/work

Timestamp:

06/16/04 11:44:30 (21 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

src/work/alpar/path.h (docs) is merged into src/work/klao/path.h
(and removed)

Location:

src/work

Files:

• alpar/path.h (deleted)
• klao/path.h (modified) (18 diffs)

src/work/klao/path.h

@@ -1 +1 @@
 // -*- c++ -*- //
 
-///\ingroup datas
+/**
+@defgroup paths Path Structures
+@ingroup datas
+\brief Path structures implemented in Hugo.
+
+Hugolib provides flexible data structures
+to work with paths.
+
+All of them have the same interface, especially they can be built or extended
+using a standard Builder subclass. This make is easy to have e.g. the Dijkstra
+algorithm to store its result in any kind of path structure.
+
+*/
+
+///\ingroup paths
 ///\file
 ///\brief Classes for representing paths in graphs.
@@ -18 +32 @@
 namespace hugo {
 
-  /// \addtogroup datas
+  /// \addtogroup paths
   /// @{
 
@@ -36 +50 @@
   class DirPath {
   public:
-    typedef typename Graph::Edge GraphEdge;
+    /// Edge type of the underlying graph.
+    typedef typename Graph::Edge GraphEdge; 
+    /// Node type of the underlying graph.
     typedef typename Graph::Node GraphNode;
     class NodeIt;
@@ -153 +169 @@
 
 
-    /*** Iterator classes ***/
+    /* Iterator classes */
+
+    /**
+     * \brief Iterator class to iterate on the edges of the paths
+     * 
+     * \ingroup paths
+     * This class is used to iterate on the edges of the paths
+     *
+     * Of course it converts to Graph::Edge
+     * 
+     * \todo Its interface differs from the standard edge iterator.
+     * Yes, it shouldn't.
+     */
     class EdgeIt {
       friend class DirPath;
@@ -160 +188 @@
       const DirPath *p;
     public:
+      /// Default constructor
       EdgeIt() {}
+      /// Invalid constructor
       EdgeIt(Invalid) : idx(-1), p(0) {}
+      /// Constructor with starting point
       EdgeIt(const DirPath &_p, int _idx = 0) :
         idx(_idx), p(&_p) { validate(); }
 
+      ///Validity check
       bool valid() const { return idx!=-1; }
 
+      ///Conversion to Graph::Edge
       operator GraphEdge () const {
         return valid() ? p->edges[idx] : INVALID;
       }
+
+      /// Next edge
       EdgeIt& operator++() { ++idx; validate(); return *this; }
 
+      /// Comparison operator
       bool operator==(const EdgeIt& e) const { return idx==e.idx; }
+      /// Comparison operator
       bool operator!=(const EdgeIt& e) const { return idx!=e.idx; }
+      /// Comparison operator
       bool operator<(const EdgeIt& e) const { return idx<e.idx; }
 
@@ -182 +220 @@
     };
 
+    /**
+     * \brief Iterator class to iterate on the nodes of the paths
+     * 
+     * \ingroup paths
+     * This class is used to iterate on the nodes of the paths
+     *
+     * Of course it converts to Graph::Node
+     * 
+     * \todo Its interface differs from the standard node iterator.
+     * Yes, it shouldn't.
+     */
     class NodeIt {
       friend class DirPath;
@@ -188 +237 @@
       const DirPath *p;
     public:
+      /// Default constructor
       NodeIt() {}
+      /// Invalid constructor
       NodeIt(Invalid) : idx(-1), p(0) {}
+      /// Constructor with starting point
       NodeIt(const DirPath &_p, int _idx = 0) :
         idx(_idx), p(&_p) { validate(); }
 
+      ///Validity check
       bool valid() const { return idx!=-1; }
 
+      ///Conversion to Graph::Node
       operator const GraphNode& () const {
         if(idx >= p->length())
@@ -203 +257 @@
           return INVALID;
       }
+      /// Next node
       NodeIt& operator++() { ++idx; validate(); return *this; }
 
+      /// Comparison operator
       bool operator==(const NodeIt& e) const { return idx==e.idx; }
+      /// Comparison operator
       bool operator!=(const NodeIt& e) const { return idx!=e.idx; }
+      /// Comparison operator
       bool operator<(const NodeIt& e) const { return idx<e.idx; }
 
@@ -218 +276 @@
      * \brief Class to build paths
      * 
-     * \ingroup datas
+     * \ingroup paths
      * This class is used to fill a path with edges.
      *
@@ -286 +344 @@
       // FIXME: Hmm, pontosan hogy is kene ezt csinalni?
       // Hogy kenyelmes egy ilyet hasznalni?
+  
+      ///Reserve storage in advance for the builder
+
+      ///If you know an reasonable upper bound of the number of the edges
+      ///to add, using this function you can speed up the building.
       void reserve(size_t r) {
         front.reserve(r);
@@ -350 +413 @@
   class UndirPath {
   public:
+    /// Edge type of the underlying graph.
     typedef typename Graph::Edge GraphEdge;
-    typedef typename Graph::Node GraphNode;
+     /// Node type of the underlying graph.
+   typedef typename Graph::Node GraphNode;
     class NodeIt;
     class EdgeIt;
@@ -467 +532 @@
 
 
-    /*** Iterator classes ***/
+
+    /**
+     * \brief Iterator class to iterate on the edges of the paths
+     * 
+     * \ingroup paths
+     * This class is used to iterate on the edges of the paths
+     *
+     * Of course it converts to Graph::Edge
+     * 
+     * \todo Its interface differs from the standard edge iterator.
+     * Yes, it shouldn't.
+     */
     class EdgeIt {
       friend class UndirPath;
@@ -474 +550 @@
       const UndirPath *p;
     public:
+      /// Default constructor
       EdgeIt() {}
+      /// Invalid constructor
       EdgeIt(Invalid) : idx(-1), p(0) {}
+      /// Constructor with starting point
       EdgeIt(const UndirPath &_p, int _idx = 0) :
         idx(_idx), p(&_p) { validate(); }
 
+      ///Validity check
       bool valid() const { return idx!=-1; }
 
+      ///Conversion to Graph::Edge
       operator GraphEdge () const {
         return valid() ? p->edges[idx] : INVALID;
       }
-      EdgeIt& operator++() { ++idx; validate(); return *this; }
-
+      /// Next edge
+     EdgeIt& operator++() { ++idx; validate(); return *this; }
+
+      /// Comparison operator
       bool operator==(const EdgeIt& e) const { return idx==e.idx; }
+      /// Comparison operator
       bool operator!=(const EdgeIt& e) const { return idx!=e.idx; }
+      /// Comparison operator
       bool operator<(const EdgeIt& e) const { return idx<e.idx; }
 
@@ -496 +581 @@
     };
 
+    /**
+     * \brief Iterator class to iterate on the nodes of the paths
+     * 
+     * \ingroup paths
+     * This class is used to iterate on the nodes of the paths
+     *
+     * Of course it converts to Graph::Node
+     * 
+     * \todo Its interface differs from the standard node iterator.
+     * Yes, it shouldn't.
+     */
     class NodeIt {
       friend class UndirPath;
@@ -502 +598 @@
       const UndirPath *p;
     public:
+      /// Default constructor
       NodeIt() {}
+      /// Invalid constructor
       NodeIt(Invalid) : idx(-1), p(0) {}
+      /// Constructor with starting point
       NodeIt(const UndirPath &_p, int _idx = 0) :
         idx(_idx), p(&_p) { validate(); }
 
+      ///Validity check
       bool valid() const { return idx!=-1; }
 
+      ///Conversion to Graph::Node
       operator const GraphNode& () const {
         if(idx >= p->length())
@@ -517 +618 @@
           return INVALID;
       }
+      /// Next node
       NodeIt& operator++() { ++idx; validate(); return *this; }
 
+      /// Comparison operator
       bool operator==(const NodeIt& e) const { return idx==e.idx; }
+      /// Comparison operator
       bool operator!=(const NodeIt& e) const { return idx!=e.idx; }
-      bool operator<(const NodeIt& e) const { return idx<e.idx; }
+       /// Comparison operator
+     bool operator<(const NodeIt& e) const { return idx<e.idx; }
 
     private:
@@ -532 +637 @@
      * \brief Class to build paths
      * 
-     * \ingroup datas
+     * \ingroup paths
      * This class is used to fill a path with edges.
      *
@@ -600 +705 @@
       // FIXME: Hmm, pontosan hogy is kene ezt csinalni?
       // Hogy kenyelmes egy ilyet hasznalni?
-      void reserve(size_t r) {
+
+      ///Reserve storage in advance for the builder
+
+      ///If you know an reasonable upper bound of the number of the edges
+      ///to add, using this function you can speed up the building.
+       void reserve(size_t r) {
         front.reserve(r);
         back.reserve(r);