Changeset 774:4297098d9677 in lemon-0.x for src/hugo/skeletons

Timestamp:

08/30/04 14:01:47 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

Merge back the whole branches/hugo++ to trunk.

File:

• src/hugo/skeletons/graph.h (modified) (23 diffs)

src/hugo/skeletons/graph.h

@@ -35 +35 @@
     public:
       /// Defalult constructor.
-      StaticGraphSkeleton() {}
+      StaticGraphSkeleton() { }
       ///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) {}
-
-      /// The base type of the node iterators.
-
-      /// This is the base type of each node iterators,
-      /// thus each kind of node iterator will convert to this.
+      StaticGraphSkeleton(const StaticGraphSkeleton& g) { }
+
+      /// The base type of node iterators, 
+      /// or in other words, the trivial node iterator.
+
+      /// This is the base type of each node iterator,
+      /// thus each kind of node iterator converts to this.
+      /// More precisely each kind of node iterator have to be inherited 
+      /// from the trivial node iterator.
       class Node {
       public:
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
-        Node() {}   //FIXME
+        Node() { }
+        /// Copy constructor.
+        Node(const Node&) { }
         /// Invalid constructor \& conversion.
 
         /// This constructor initializes the iterator to be invalid.
         /// \sa Invalid for more details.
-
-        Node(Invalid) {}
-        //Node(const Node &) {}
-
+        Node(Invalid) { }
         /// Two iterators are equal if and only if they point to the
         /// same object or both are invalid.
@@ -74 +76 @@
       /// This iterator goes through each node.
       /// Its usage is quite simple, for example you can count the number
-      /// of nodes in graph \c G of type \c Graph like this:
+      /// of nodes in graph \c g of type \c Graph like this:
       /// \code
-      ///int count=0;
-      ///for(Graph::NodeIt n(G);G.valid(n);G.next(n)) count++;
+      /// int count=0;
+      /// for (Graph::NodeIt n(g); g.valid(n); ++n) ++count;
       /// \endcode
       class NodeIt : public Node {
@@ -83 +85 @@
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
-        NodeIt() {} //FIXME
+        NodeIt() { }
+        /// Copy constructor.
+        NodeIt(const NodeIt&) { }
         /// Invalid constructor \& conversion.
 
-        /// Initialize the iterator to be invalid
+        /// Initialize the iterator to be invalid.
         /// \sa Invalid for more details.
-        NodeIt(Invalid) {}
-        /// Sets the iterator to the first node of \c G.
-        NodeIt(const StaticGraphSkeleton &) {}
-        /// @warning The default constructor sets the iterator
-        /// to an undefined value.
-        NodeIt(const NodeIt &n) : Node(n) {}
+        NodeIt(Invalid) { }
+        /// Sets the iterator to the first node of \c g.
+        NodeIt(const StaticGraphSkeleton& g) { }
+        /// Sets the iterator to the node of \c g pointed by the trivial 
+        /// iterator n. This feature necessitates that each time we 
+        /// iterate the node-set, the iteration order is the same.
+        NodeIt(const StaticGraphSkeleton& g, const Node& n) { }
+        /// Assign the iterator to the next node.
+        NodeIt& operator++() { return *this; }
       };
     
@@ -102 +109 @@
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
-        Edge() {}   //FIXME
-        /// Initialize the iterator to be invalid
-        Edge(Invalid) {}
+        Edge() { }
+        /// Copy constructor.
+        Edge(const Edge&) { }
+        /// Initialize the iterator to be invalid.
+        Edge(Invalid) { }
         /// Two iterators are equal if and only if they point to the
         /// same object or both are invalid.
@@ -118 +127 @@
       /// Its usage is quite simple, for example you can count the number
       /// of outgoing edges of a node \c n
-      /// in graph \c G of type \c Graph as follows.
+      /// in graph \c g of type \c Graph as follows.
       /// \code
-      ///int count=0;
-      ///for(Graph::OutEdgeIt e(G,n);G.valid(e);G.next(e)) count++;
+      /// int count=0;
+      /// for (Graph::OutEdgeIt e(g, n); g.valid(e); ++e) ++count;
       /// \endcode
     
@@ -128 +137 @@
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
-        OutEdgeIt() {}
-        /// Initialize the iterator to be invalid
-        OutEdgeIt(Invalid) {}
+        OutEdgeIt() { }
+        /// Copy constructor.
+        OutEdgeIt(const OutEdgeIt&) { }
+        /// Initialize the iterator to be invalid.
+        OutEdgeIt(Invalid) { }
         /// This constructor sets the iterator to first outgoing edge.
     
@@ -136 +147 @@
         /// node
         ///@param n the node
-        ///@param G the graph
-        OutEdgeIt(const StaticGraphSkeleton &, Node) {}
+        ///@param g the graph
+        OutEdgeIt(const StaticGraphSkeleton& g, const Node& n) { }
+        /// 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) { }
+        /// Assign the iterator to the next outedge of the corresponding node.
+        OutEdgeIt& operator++() { return *this; }
       };
 
@@ -146 +163 @@
       /// Its usage is quite simple, for example you can count the number
       /// of outgoing edges of a node \c n
-      /// in graph \c G of type \c Graph as follows.
+      /// in graph \c g of type \c Graph as follows.
       /// \code
-      ///int count=0;
-      ///for(Graph::InEdgeIt e(G,n);G.valid(e);G.next(e)) count++;
+      /// int count=0;
+      /// for(Graph::InEdgeIt e(g, n); g.valid(e); ++) ++count;
       /// \endcode
 
@@ -156 +173 @@
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
-        InEdgeIt() {}
-        /// Initialize the iterator to be invalid
-        InEdgeIt(Invalid) {}
-        InEdgeIt(const StaticGraphSkeleton &, Node) {}    
+        InEdgeIt() { }
+        /// Copy constructor.
+        InEdgeIt(const InEdgeIt&) { }
+        /// Initialize the iterator to be invalid.
+        InEdgeIt(Invalid) { }
+        /// .
+        InEdgeIt(const StaticGraphSkeleton&, const Node&) { }
+        /// .
+        InEdgeIt(const StaticGraphSkeleton&, const Edge&) { }
+        /// Assign the iterator to the next inedge of the corresponding node.
+        InEdgeIt& operator++() { return *this; }
       };
       //  class SymEdgeIt : public Edge {};
@@ -167 +191 @@
       /// This iterator goes through each edge of a graph.
       /// Its usage is quite simple, for example you can count the number
-      /// of edges in a graph \c G of type \c Graph as follows:
+      /// of edges in a graph \c g of type \c Graph as follows:
       /// \code
-      ///int count=0;
-      ///for(Graph::EdgeIt e(G);G.valid(e);G.next(e)) count++;
+      /// int count=0;
+      /// for(Graph::EdgeIt e(g); g.valid(e); ++e) ++count;
       /// \endcode
       class EdgeIt : public Edge {
@@ -176 +200 @@
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
-        EdgeIt() {}
-        /// Initialize the iterator to be invalid
-        EdgeIt(Invalid) {}
-        EdgeIt(const StaticGraphSkeleton &) {}
+        EdgeIt() { }
+        /// Copy constructor.
+        EdgeIt(const EdgeIt&) { }
+        /// Initialize the iterator to be invalid.
+        EdgeIt(Invalid) { }
+        /// .
+        EdgeIt(const StaticGraphSkeleton&) { }
+        /// .
+        EdgeIt(const StaticGraphSkeleton&, const Edge&) { } 
+        EdgeIt& operator++() { return *this; }
       };
 
@@ -187 +217 @@
       /// \return the first node.
       ///
-      NodeIt &first(NodeIt &i) const { return i;}
+      NodeIt& first(NodeIt& i) const { return i; }
 
       /// The first incoming edge.
-      InEdgeIt &first(InEdgeIt &i, Node) const { return i;}
+      InEdgeIt& first(InEdgeIt &i, Node) const { return i; }
       /// The first outgoing edge.
-      OutEdgeIt &first(OutEdgeIt &i, Node) const { return i;}
-      //  SymEdgeIt &first(SymEdgeIt &, Node) const { return i;}
+      OutEdgeIt& first(OutEdgeIt& i, Node) const { return i; }
+      //  SymEdgeIt& first(SymEdgeIt&, Node) const { return i; }
       /// The first edge of the Graph.
-      EdgeIt &first(EdgeIt &i) const { return i;}
+      EdgeIt& first(EdgeIt& i) const { return i; }
 
       //     Node getNext(Node) const {}
@@ -204 +234 @@
 
       /// Go to the next node.
-      NodeIt &next(NodeIt &i) const { return i;}
+      NodeIt& next(NodeIt& i) const { return i; }
       /// Go to the next incoming edge.
-      InEdgeIt &next(InEdgeIt &i) const { return i;}
+      InEdgeIt& next(InEdgeIt& i) const { return i; }
       /// Go to the next outgoing edge.
-      OutEdgeIt &next(OutEdgeIt &i) const { return i;}
-      //SymEdgeIt &next(SymEdgeIt &) const {}
+      OutEdgeIt& next(OutEdgeIt& i) const { return i; }
+      //SymEdgeIt& next(SymEdgeIt&) const { }
       /// Go to the next edge.
-      EdgeIt &next(EdgeIt &i) const { return i;}
+      EdgeIt& next(EdgeIt& i) const { return i; }
 
       ///Gives back the head node of an edge.
@@ -230 +260 @@
       ///\todo Maybe, it would be better if iterator converted to
       ///bool directly, as Jacint prefers.
-      bool valid(const Node&) const { return true;}
+      bool valid(const Node&) const { return true; }
       /// Checks if an edge iterator is valid
 
       ///\todo Maybe, it would be better if iterator converted to
       ///bool directly, as Jacint prefers.
-      bool valid(const Edge&) const { return true;}
+      bool valid(const Edge&) const { return true; }
 
       ///Gives back the \e id of a node.
@@ -241 +271 @@
       ///\warning Not all graph structures provide this feature.
       ///
-      int id(const Node&) const { return 0;}
+      int id(const Node&) const { return 0; }
       ///Gives back the \e id of an edge.
 
       ///\warning Not all graph structures provide this feature.
       ///
-      int id(const Edge&) const { return 0;}
+      int id(const Edge&) const { return 0; }
 
       /// Resets the graph.
@@ -252 +282 @@
       /// This function deletes all edges and nodes of the graph.
       /// It also frees the memory allocated to store them.
-      void clear() {}
-
-      int nodeNum() const { return 0;}
-      int edgeNum() const { return 0;}
-
+      void clear() { }
+
+      int nodeNum() const { return 0; }
+      int edgeNum() const { return 0; }
 
 
@@ -271 +300 @@
       public:
 
-        class ReferenceMap<Node,T>;
-
-        NodeMap(const StaticGraphSkeleton &) {}
-        NodeMap(const StaticGraphSkeleton &, T) {}
+        NodeMap(const StaticGraphSkeleton&) { }
+        NodeMap(const StaticGraphSkeleton&, T) { }
 
         ///Copy constructor
-        template<typename TT> NodeMap(const NodeMap<TT> &) {}
+        template<typename TT> NodeMap(const NodeMap<TT>&) { }
         ///Assignment operator
-        template<typename TT> NodeMap &operator=(const NodeMap<TT> &)
-        {return *this;}
+        template<typename TT> NodeMap& operator=(const NodeMap<TT>&)
+        { return *this; }
       };
 
@@ -296 +323 @@
         typedef Edge KeyType;
 
-        EdgeMap(const StaticGraphSkeleton &) {}
-        EdgeMap(const StaticGraphSkeleton &, T ) {}
+        EdgeMap(const StaticGraphSkeleton&) { }
+        EdgeMap(const StaticGraphSkeleton&, T) { }
     
         ///Copy constructor
-        template<typename TT> EdgeMap(const EdgeMap<TT> &) {}
+        template<typename TT> EdgeMap(const EdgeMap<TT>&) { }
         ///Assignment operator
-        template<typename TT> EdgeMap &operator=(const EdgeMap<TT> &)
-        {return *this;}
+        template<typename TT> EdgeMap &operator=(const EdgeMap<TT>&)
+        { return *this; }
       };
     };
@@ -318 +345 @@
     public:
       /// Defalult constructor.
-      GraphSkeleton() {}
+      GraphSkeleton() { }
       ///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?
-      GraphSkeleton(const GraphSkeleton &G) {}
+      GraphSkeleton(const GraphSkeleton&) { }
 
       ///Add a new node to the graph.
@@ -329 +356 @@
       /// \return the new node.
       ///
-      Node addNode() { return INVALID;}
+      Node addNode() { return INVALID; }
       ///Add a new edge to the graph.
 
@@ -335 +362 @@
       ///and head node \c head.
       ///\return the new edge.
-      Edge addEdge(Node, Node) { return INVALID;}
+      Edge addEdge(Node, Node) { return INVALID; }
     
       /// Resets the graph.
@@ -342 +369 @@
       /// It also frees the memory allocated to store them.
       /// \todo It might belong to \c EraseableGraphSkeleton.
-      void clear() {}
+      void clear() { }
     };
 
@@ -353 +380 @@
     public:
       /// Deletes a node.
-      void erase(Node n) {}
+      void erase(Node n) { }
       /// Deletes an edge.
-      void erase(Edge e) {}
+      void erase(Edge e) { }
 
       /// Defalult constructor.
-      EraseableGraphSkeleton() {}
+      EraseableGraphSkeleton() { }
       ///Copy consructor.
-      EraseableGraphSkeleton(const GraphSkeleton &G) {}
+      EraseableGraphSkeleton(const GraphSkeleton&) { }
     };