Changeset 70:851ca9a60e90 in lemon0.x for doc/flfgraph.texi
 Timestamp:
 02/10/04 14:29:15 (16 years ago)
 Branch:
 default
 Phase:
 public
 Convert:
 svn:c9d7d8f590d60310b91f818b3a526b0e/lemon/trunk@86
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

doc/flfgraph.texi
r26 r70 28 28 29 29 @anchor{GraphNodeIterator} 30 @deftp {Type} Graph::Node Point30 @deftp {Type} Graph::NodeIt 31 31 @deftpx {Type} Graph::NodeIterator 32 32 These types points a node uniquely. The difference between the 33 @code{Node Point} and the @code{NodeIterator} is that @code{NodePoint}33 @code{NodeIt} and the @code{NodeIterator} is that @code{NodeIt} 34 34 requires the graph structure itself for most of the operations. 35 35 For examples using iterators you can go through all nodes as follows. … … 38 38 Graph G; 39 39 int nodenum=0; 40 for(Graph::NodeIterator n(G);n. Valid();++n) ++nodenum;40 for(Graph::NodeIterator n(G);n.valid();++n) ++nodenum; 41 41 @end verbatim 42 42 @end quotation 43 Using @code{Node Point} the last line looks like this.43 Using @code{NodeIt} the last line looks like this. 44 44 @quotation 45 45 @verbatim 46 for( MyGraph::NodePoint n(G);n.Valid();n=G.Next(n)) ++nodenum;46 for(Graph::NodeIt n(G);n.valid();n=G.next(n)) ++nodenum; 47 47 @end verbatim 48 48 @end quotation … … 50 50 @quotation 51 51 @verbatim 52 MyGraph::Node Point n;53 for(G. GetFirst(n);G.Valid(n);G.GoNext(n)) ++nodenum;52 MyGraph::NodeIt n; 53 for(G.getFirst(n);G.valid(n);G.goNext(n)) ++nodenum; 54 54 @end verbatim 55 55 @end quotation 56 56 @end deftp 57 57 58 @deftp {Type} Graph::Edge Point59 @deftpx {Type} Graph::InEdge Point60 @deftpx {Type} Graph::OutEdge Point61 @deftpx {Type} Graph::BiEdge Point62 @deftpx {Type} Graph::SymEdge Point58 @deftp {Type} Graph::EdgeIt 59 @deftpx {Type} Graph::InEdgeIt 60 @deftpx {Type} Graph::OutEdgeIt 61 @deftpx {Type} Graph::BiEdgeIt 62 @deftpx {Type} Graph::SymEdgeIt 63 63 Each of these types points an edge uniquely. The difference between the 64 @code{Edge Point} and the64 @code{EdgeIt} and the 65 65 @c @mref{GraphNodeIterator,@code{EdgeIterator}} 66 66 @mref{GraphNodeIterator , EdgeIterator} 67 67 series is that 68 @code{Edge Point} requires the graph structure itself for most of the68 @code{EdgeIt} requires the graph structure itself for most of the 69 69 operations. 70 70 @end deftp … … 76 76 @deftpx {Type} Graph::BiEdgeIterator 77 77 @deftpx {Type} Graph::SymEdgeIterator 78 @deftpx {Type} Graph:: AllEdgeIterator78 @deftpx {Type} Graph::EachEdgeIterator 79 79 Each of these types points an edge uniquely. The difference between the 80 @code{Edge Point} and the @code{EdgeIterator} series is that81 @code{Edge Point} requires the graph structure itself for most of the80 @code{EdgeIt} and the @code{EdgeIterator} series is that 81 @code{EdgeIt} requires the graph structure itself for most of the 82 82 operations. 83 83 … … 108 108 @subsubsection Graph Maintenence Operations 109 109 110 @deftypefun NodeIterator Graph:: AddNode ()110 @deftypefun NodeIterator Graph::addNode () 111 111 Adds a new node to the graph and returns a @code{NodeIterator} pointing to it. 112 112 @end deftypefun 113 113 114 @deftypefun EdgeIterator Graph:: AddEdge (@w{const @mref{GraphNodeIterator,NodeIterator} @var{from}}, @w{const @mref{GraphNodeIterator,NodeIterator} @var{to}})114 @deftypefun EdgeIterator Graph::addEdge (@w{const @mref{GraphNodeIterator,NodeIterator} @var{from}}, @w{const @mref{GraphNodeIterator,NodeIterator} @var{to}}) 115 115 Adds a new edge with tail @var{from} and head @var{to} to the graph 116 116 and returns an @code{EdgeIterator} pointing to it. 117 117 @end deftypefun 118 118 119 @deftypefun void Graph:: Delete (@w{const @mref{GraphNodeIterator,NodeIterator} @var{n}})119 @deftypefun void Graph::delete (@w{const @mref{GraphNodeIterator,NodeIterator} @var{n}}) 120 120 Deletes the node @var{n}. It also deletes the adjacent edges. 121 121 @end deftypefun 122 122 123 @deftypefun void Graph:: Delete (@w{const @mref{GraphEdgeIterator,EdgeIterator} @var{e}})123 @deftypefun void Graph::delete (@w{const @mref{GraphEdgeIterator,EdgeIterator} @var{e}}) 124 124 Deletes the edge @var{n}. 125 125 @end deftypefun 126 126 127 @deftypefun void Graph:: Clean ()127 @deftypefun void Graph::clean () 128 128 Deletes all edges and nodes from the graph. 129 129 @end deftypefun 130 130 131 @deftypefun int Graph:: NodeNum ()131 @deftypefun int Graph::nodeNum () 132 132 Returns the number of the nodes in the graph. 133 133 @end deftypefun 134 134 135 @subsubsection Node Point Operations136 137 @deftypefun Node Point Graph::GetFirst (NodePoint &@var{n})138 @deftypefunx Node Point Graph::Next (const NodePoint @var{n})139 @deftypefunx {Node Point &} Graph::GoNext (NodePoint &@var{n})135 @subsubsection NodeIt Operations 136 137 @deftypefun NodeIt Graph::getFirst (NodeIt &@var{n}) 138 @deftypefunx NodeIt Graph::next (const NodeIt @var{n}) 139 @deftypefunx {NodeIt &} Graph::goNext (NodeIt &@var{n}) 140 140 The nodes in the graph forms a list. @code{GetFirst(n)} sets @var{n} to 141 be the first node. @code{ Next(n)} gives back the subsequent141 be the first node. @code{next(n)} gives back the subsequent 142 142 node. @code{Next(n)} is equivalent to @code{n=Next(n)}, though it 143 143 might be faster. ??? What should be the return value ??? 144 144 @end deftypefun 145 145 146 @deftypefun bool Graph:: Valid (NodePoint &@var{e})147 @deftypefunx bool Node Point::Valid ()148 These functions check if and Node Point is valid or not.146 @deftypefun bool Graph::valid (NodeIt &@var{e}) 147 @deftypefunx bool NodeIt::valid () 148 These functions check if and NodeIt is valid or not. 149 149 ??? Which one should be implemented ??? 150 150 @end deftypefun 151 151 152 @subsubsection Edge Point Operations153 154 @deftypefun AllEdgePoint Graph::GetFirst (const AllEdgePoint & @var{e})155 @deftypefunx AllEdgePoint Graph::Next (const AllEdgePoint @var{n})156 @deftypefunx { AllEdgePoint &} Graph::GoNext (AllEdgePoint &@var{n})152 @subsubsection EdgeIt Operations 153 154 @deftypefun EachEdgeIt Graph::getFirst (const EachEdgeIt & @var{e}) 155 @deftypefunx EachEdgeIt Graph::next (const EachEdgeIt @var{n}) 156 @deftypefunx {EachEdgeIt &} Graph::goNext (EachEdgeIt &@var{n}) 157 157 With these functions you can go though all the edges of the graph. 158 158 ??? What should be the return value ??? 159 159 @end deftypefun 160 160 161 @deftypefun InEdge Point Graph::GetFirst (const InEdgePoint & @var{e}, const NodePoint @var{n})162 @deftypefunx OutEdge Point Graph::GetFirst (const OutEdgePoint & @var{e}, const NodePoint @var{n})163 @deftypefunx SymEdge Point Graph::GetFirst (const SymEdgePoint & @var{e}, const NodePoint @var{n})161 @deftypefun InEdgeIt Graph::getFirst (const InEdgeIt & @var{e}, const NodeIt @var{n}) 162 @deftypefunx OutEdgeIt Graph::getFirst (const OutEdgeIt & @var{e}, const NodeIt @var{n}) 163 @deftypefunx SymEdgeIt Graph::getFirst (const SymEdgeIt & @var{e}, const NodeIt @var{n}) 164 164 The edges leaving from, arriving at or adjacent with a node forms a 165 165 list. These functions give back the first elements of these 166 166 lists. The exact behavior depends on the type of @var{e}. 167 167 168 If @var{e} is an @code{InEdge Point} or an @code{OutEdgePoint} then169 @code{ GetFirst} sets @var{e} to be the first incoming or outgoing edge168 If @var{e} is an @code{InEdgeIt} or an @code{OutEdgeIt} then 169 @code{getFirst} sets @var{e} to be the first incoming or outgoing edge 170 170 of the node @var{n}, respectively. 171 171 172 If @var{e} is a @code{SymEdge Point} then173 @code{ GetFirst} sets @var{e} to be the first incoming if there exists one172 If @var{e} is a @code{SymEdgeIt} then 173 @code{getFirst} sets @var{e} to be the first incoming if there exists one 174 174 otherwise the first outgoing edge. 175 175 … … 178 178 @end deftypefun 179 179 180 @deftypefun InEdge Point Graph::Next (const InEdgePoint @var{e})181 @deftypefunx OutEdge Point Graph::Next (const OutEdgePoint @var{e})182 @deftypefunx SymEdge Point Graph::Next (const SymEdgePoint @var{e})180 @deftypefun InEdgeIt Graph::next (const InEdgeIt @var{e}) 181 @deftypefunx OutEdgeIt Graph::next (const OutEdgeIt @var{e}) 182 @deftypefunx SymEdgeIt Graph::next (const SymEdgeIt @var{e}) 183 183 These functions give back the edge that follows @var{e} 184 184 @end deftypefun 185 185 186 @deftypefun {InEdge Point &} Graph::GoNext (InEdgePoint &@var{e})187 @deftypefunx {OutEdge Point &} Graph::GoNext (OutEdgePoint &@var{e})188 @deftypefunx {SymEdge Point &} Graph::GoNext (SymEdgePoint &@var{e})189 @code{G. GoNext(e)} is equivalent to @code{e=G.Next(e)}, though it186 @deftypefun {InEdgeIt &} Graph::goNext (InEdgeIt &@var{e}) 187 @deftypefunx {OutEdgeIt &} Graph::goNext (OutEdgeIt &@var{e}) 188 @deftypefunx {SymEdgeIt &} Graph::goNext (SymEdgeIt &@var{e}) 189 @code{G.goNext(e)} is equivalent to @code{e=G.next(e)}, though it 190 190 might be faster. 191 191 ??? What should be the return value ??? 192 192 @end deftypefun 193 193 194 @deftypefun bool Graph:: Valid (EdgePoint &@var{e})195 @deftypefunx bool Edge Point::Valid ()196 These functions check if and Edge Point is valid or not.194 @deftypefun bool Graph::valid (EdgeIt &@var{e}) 195 @deftypefunx bool EdgeIt::valid () 196 These functions check if and EdgeIt is valid or not. 197 197 ??? Which one should be implemented ??? 198 198 @end deftypefun 199 199 200 @deftypefun Node Point Graph::From (const EdgePoint @var{e})201 @deftypefunx Node Point Graph::To (const EdgePoint @var{e})202 @deftypefunx Node Point Graph::ANode (const InEdgePoint @var{e})203 @deftypefunx Node Point Graph::ANode (const OutEdgePoint @var{e})204 @deftypefunx Node Point Graph::ANode (const SymEdgePoint @var{e})205 @deftypefunx Node Point Graph::BNode (const InEdgePoint @var{e})206 @deftypefunx Node Point Graph::BNode (const OutEdgePoint @var{e})207 @deftypefunx Node Point Graph::BNode (const SymEdgePoint @var{e})200 @deftypefun NodeIt Graph::tail (const EdgeIt @var{e}) 201 @deftypefunx NodeIt Graph::head (const EdgeIt @var{e}) 202 @deftypefunx NodeIt Graph::aNode (const InEdgeIt @var{e}) 203 @deftypefunx NodeIt Graph::aNode (const OutEdgeIt @var{e}) 204 @deftypefunx NodeIt Graph::aNode (const SymEdgeIt @var{e}) 205 @deftypefunx NodeIt Graph::bNode (const InEdgeIt @var{e}) 206 @deftypefunx NodeIt Graph::bNode (const OutEdgeIt @var{e}) 207 @deftypefunx NodeIt Graph::bNode (const SymEdgeIt @var{e}) 208 208 There queries give back the two endpoints of the edge @var{e}. For a 209 directed edge @var{e}, @code{ From(e)} and @code{To(e)} is its tail and209 directed edge @var{e}, @code{tail(e)} and @code{head(e)} is its tail and 210 210 its head, respectively. For an undirected @var{e}, they are two 211 211 endpoints, but you should not rely on which end is which. 212 212 213 @code{ ANode(e)} is the node which @var{e} is bounded to, i.e. it is214 equal to @code{ From(e)} if @var{e} is an @code{OutEdgePoint} and215 @code{ To(e)} if @var{e} is an @code{InEdgePoint}. If @var{e} is a216 @code{SymEdge Point} and it or its first preceding edge was created by217 @code{ GetFirst(e,n)}, then @code{ANode(e)} is equal to @var{n}.218 219 @code{ BNode(e)} is the other end of the edge.220 221 ???It i timplemented in an other way now. (Member function <> Graph global)???213 @code{aNode(e)} is the node which @var{e} is bounded to, i.e. it is 214 equal to @code{tail(e)} if @var{e} is an @code{OutEdgeIt} and 215 @code{head(e)} if @var{e} is an @code{InEdgeIt}. If @var{e} is a 216 @code{SymEdgeIt} and it or its first preceding edge was created by 217 @code{getFirst(e,n)}, then @code{aNode(e)} is equal to @var{n}. 218 219 @code{bNode(e)} is the other end of the edge. 220 221 ???It is implemented in an other way now. (Member function <> Graph global)??? 222 222 @end deftypefun 223 223
Note: See TracChangeset
for help on using the changeset viewer.