COIN-OR::LEMON - Graph Library

Changeset 203:fc4699a76a6f in lemon-0.x for doc


Ignore:
Timestamp:
03/19/04 08:40:00 (16 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@291
Message:

.

Location:
doc
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • doc/Doxyfile

    r186 r203  
    6161                         ../src/doxy/invalid.h \
    6262                         ../src/demo/alpar/smart_graph.h \
    63                          ../src/demo/alpar/mapskeleton.h
     63                         ../src/demo/alpar/mapskeleton.h \
     64                         maps.dox
    6465FILE_PATTERNS          =
    6566RECURSIVE              = NO
  • doc/flf-graph.texi

    r70 r203  
    2222@subsection Types
    2323
    24 @deftp {Type} Graph::NodeType
    25 @deftpx {Type} Graph::EdgeType
    26 The type of the data stored statically for each node and edge.
    27 @end deftp
     24@c @deftp {Type} Graph::NodeType
     25@c @deftpx {Type} Graph::EdgeType
     26@c The type of the data stored statically for each node and edge.
     27@c @end deftp
    2828
    2929@anchor{Graph-NodeIterator}
    3030@deftp {Type} Graph::NodeIt
    31 @deftpx {Type} Graph::NodeIterator
     31@c @deftpx {Type} Graph::NodeIterator
    3232These types points a node uniquely. The difference between the
    3333@code{NodeIt} and the @code{NodeIterator} is that @code{NodeIt}
     
    5959@deftpx {Type} Graph::InEdgeIt
    6060@deftpx {Type} Graph::OutEdgeIt
    61 @deftpx {Type} Graph::BiEdgeIt
    62 @deftpx {Type} Graph::SymEdgeIt
     61@deftpx {Type} Graph::EachEdgeIt
     62@c @deftpx {Type} Graph::BiEdgeIt
     63@c @deftpx {Type} Graph::SymEdgeIt
    6364Each of these types points an edge uniquely. The difference between the
    6465@code{EdgeIt} and the
     
    7172
    7273@anchor{Graph-EdgeIterator}
    73 @deftp {Type} Graph::EdgeIterator
    74 @deftpx {Type} Graph::InEdgeIterator
    75 @deftpx {Type} Graph::OutEdgeIterator
    76 @deftpx {Type} Graph::BiEdgeIterator
    77 @deftpx {Type} Graph::SymEdgeIterator
    78 @deftpx {Type} Graph::EachEdgeIterator
    79 Each of these types points an edge uniquely. The difference between the
    80 @code{EdgeIt} and the @code{EdgeIterator} series is that
    81 @code{EdgeIt} requires the graph structure itself for most of the
    82 operations.
    83 
    84 For the @code{EdgeIterator} types you can use operator @code{++}
    85 (both the prefix and the posfix one) to obtain the next edge.
    86 @end deftp
    87 
    88 @deftp {Type} Graph::NodeMap
    89 @deftpx {Type} Graph::EdgeMap
     74@c @deftp {Type} Graph::EdgeIterator
     75@c @deftpx {Type} Graph::InEdgeIterator
     76@c @deftpx {Type} Graph::OutEdgeIterator
     77@c @deftpx {Type} Graph::BiEdgeIterator
     78@c @deftpx {Type} Graph::SymEdgeIterator
     79@c @deftpx {Type} Graph::EachEdgeIterator
     80@c Each of these types points an edge uniquely. The difference between the
     81@c @code{EdgeIt} and the @code{EdgeIterator} series is that
     82@c @code{EdgeIt} requires the graph structure itself for most of the
     83@c operations.
     84
     85@c For the @code{EdgeIterator} types you can use operator @code{++}
     86@c (both the prefix and the posfix one) to obtain the next edge.
     87@c @end deftp
     88
     89@deftp {Type} Graph::NodeMap<typename T>
     90@deftpx {Type} Graph::EdgeMap<typename T>
    9091There are the default property maps for the edges and the nodes.
    9192@end deftp
    9293
     94@deftp {Type} Graph::DynNodeMap<typename T>
     95@deftpx {Type} Graph::DynEdgeMap<typename T>
     96There are the default @emph{dynamic} property maps for the edges and the nodes.
     97@end deftp
    9398
    9499@subsection Member Functions
    95100
    96101@subsubsection Constructors
    97 
    98102
    99103@deftypefun { } Graph::Graph ()
     
    103107@c @deftypefun { } Graph::Graph (Graph@tie{}&)
    104108@deftypefun { } Graph::Graph (Graph &)
    105 The copy constructor. Not yet implemented.
     109The copy constructor.
    106110@end deftypefun
    107111
    108112@subsubsection Graph Maintenence Operations
    109113
    110 @deftypefun NodeIterator Graph::addNode ()
    111 Adds a new node to the graph and returns a @code{NodeIterator} pointing to it.
    112 @end deftypefun
    113 
    114 @deftypefun EdgeIterator Graph::addEdge (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{from}}, @w{const @mref{Graph-NodeIterator,NodeIterator} @var{to}})
     114@deftypefun NodeIt Graph::addNode ()
     115Adds a new node to the graph and returns a @code{NodeIt} pointing to it.
     116@end deftypefun
     117
     118@deftypefun EdgeIt Graph::addEdge (@w{const @mref{Graph-NodeIterator,NodeIt} @var{from}}, @w{const @mref{Graph-NodeIterator,NodeIt} @var{to}})
    115119Adds a new edge with tail @var{from} and head @var{to} to the graph
    116 and returns an @code{EdgeIterator} pointing to it.
    117 @end deftypefun
    118 
    119 @deftypefun void Graph::delete (@w{const @mref{Graph-NodeIterator,NodeIterator} @var{n}})
     120and returns an @code{EdgeIt} pointing to it.
     121@end deftypefun
     122
     123@deftypefun void Graph::delete (@w{const @mref{Graph-NodeIterator,NodeIt} @var{n}})
    120124Deletes the node @var{n}. It also deletes the adjacent edges.
    121125@end deftypefun
    122126
    123 @deftypefun void Graph::delete (@w{const @mref{Graph-EdgeIterator,EdgeIterator} @var{e}})
     127@deftypefun void Graph::delete (@w{const @mref{Graph-EdgeIterator,EdgeIt} @var{e}})
    124128Deletes the edge @var{n}.
    125129@end deftypefun
    126130
    127 @deftypefun void Graph::clean ()
     131@deftypefun void Graph::clear ()
    128132Deletes all edges and nodes from the graph.
    129133@end deftypefun
     
    131135@deftypefun int Graph::nodeNum ()
    132136Returns the number of the nodes in the graph.
     137??? Is it necessary???
    133138@end deftypefun
    134139
    135140@subsubsection NodeIt Operations
    136141
    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 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 subsequent
    142 node. @code{Next(n)} is equivalent to @code{n=Next(n)}, though it
     142@deftypefun NodeIt Graph::getFirst (NodeIt &@var{n}) const
     143@deftypefunx NodeIt Graph::getNext (NodeIt @var{n}) const
     144@deftypefunx {NodeIt &} Graph::next (NodeIt &@var{n})
     145The nodes in the graph forms a list. @code{getFirst(n)} sets @var{n} to
     146be the first node. @code{getNext(n)} gives back the subsequent
     147node. @code{next(n)} is equivalent to @code{n=getNext(n)}, though it
    143148might be faster.  ??? What should be the return value ???
    144149@end deftypefun
    145150
    146151@deftypefun bool Graph::valid (NodeIt &@var{e})
    147 @deftypefunx bool NodeIt::valid ()
     152@c @deftypefunx bool NodeIt::valid ()
    148153These functions check if and NodeIt is valid or not.
    149 ??? Which one should be implemented ???
     154@c ??? Which one should be implemented ???
    150155@end deftypefun
    151156
    152157@subsubsection EdgeIt Operations
    153158
    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})
     159@deftypefun EachEdgeIt Graph::getFirst (const EachEdgeIt & @var{e}) const
     160@deftypefunx EachEdgeIt Graph::getNext (EachEdgeIt @var{n}) const
     161@deftypefunx {EachEdgeIt &} Graph::next (EachEdgeIt &@var{n})
    157162With these functions you can go though all the edges of the graph.
    158 ??? What should be the return value ???
    159 @end deftypefun
    160 
    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 The edges leaving from, arriving at or adjacent with a node forms a
     163@c ??? What should be the return value ???
     164@end deftypefun
     165
     166@deftypefun InEdgeIt &Graph::getFirst (InEdgeIt & @var{e}, const NodeIt @var{n})
     167@deftypefunx OutEdgeIt &Graph::getFirst (OutEdgeIt & @var{e}, const NodeIt @var{n})
     168@c @deftypefunx SymEdgeIt &Graph::getFirst (SymEdgeIt & @var{e}, const NodeIt @var{n})
     169The edges leaving from
     170or
     171arriving at
     172@c or adjacent with
     173a node forms a
    165174list.  These functions give back the first elements of these
    166175lists. The exact behavior depends on the type of @var{e}.
     
    170179of the node @var{n}, respectively.
    171180
    172 If @var{e} is a @code{SymEdgeIt} then
    173 @code{getFirst} sets @var{e} to be the first incoming if there exists one
    174 otherwise the first outgoing edge.
     181@c If @var{e} is a @code{SymEdgeIt} then
     182@c @code{getFirst} sets @var{e} to be the first incoming if there exists one
     183@c otherwise the first outgoing edge.
    175184
    176185If there are no such edges, @var{e} will be invalid.
     
    219228@code{bNode(e)} is the other end of the edge.
    220229
    221 ???It is implemented in an other way now. (Member function <-> Graph global)???
     230@deftypefun void Graph::setInvalid (EdgeIt &@var{e})
     231@deftypefunx void Graph::setInvalid (EdgeIt &@var{e})
     232These functions set the corresponding iterator to be invalid.
     233@end deftypefun
     234
     235@c ???It is implemented in an other way now. (Member function <-> Graph global)???
    222236@end deftypefun
    223237
Note: See TracChangeset for help on using the changeset viewer.