COIN-OR::LEMON - Graph Library

Changeset 1946:17eb3eaad9f8 in lemon-0.x for lemon/concept


Ignore:
Timestamp:
02/02/06 18:43:24 (14 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2521
Message:
  • workaround for a Doxygen 1.4.6 bug
  • other doc fixes
Location:
lemon/concept
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • lemon/concept/bpugraph.h

    r1933 r1946  
    245245      /// Its usage is quite simple, for example you can count the number
    246246      /// of nodes in graph \c g of type \c Graph like this:
    247       /// \code
     247      ///\code
    248248      /// int count=0;
    249249      /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
    250       /// \endcode
     250      ///\endcode
    251251      class NodeIt : public Node {
    252252      public:
     
    290290      /// Its usage is quite simple, for example you can count the number
    291291      /// of nodes in graph \c g of type \c Graph like this:
    292       /// \code
     292      ///\code
    293293      /// int count=0;
    294294      /// for (Graph::ANodeIt n(g); n!=INVALID; ++n) ++count;
    295       /// \endcode
     295      ///\endcode
    296296      class ANodeIt : public ANode {
    297297      public:
     
    335335      /// Its usage is quite simple, for example you can count the number
    336336      /// of nodes in graph \c g of type \c Graph like this:
    337       /// \code
     337      ///\code
    338338      /// int count=0;
    339339      /// for (Graph::BNodeIt n(g); n!=INVALID; ++n) ++count;
    340       /// \endcode
     340      ///\endcode
    341341      class BNodeIt : public BNode {
    342342      public:
     
    426426      /// Its usage is quite simple, for example you can count the number
    427427      /// of undirected edges in a graph \c g of type \c Graph as follows:
    428       /// \code
     428      ///\code
    429429      /// int count=0;
    430430      /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count;
    431       /// \endcode
     431      ///\endcode
    432432      class UEdgeIt : public UEdge {
    433433      public:
     
    474474      /// of incident edges of a node \c n
    475475      /// in graph \c g of type \c Graph as follows.
    476       /// \code
     476      ///\code
    477477      /// int count=0;
    478478      /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    479       /// \endcode
     479      ///\endcode
    480480      class IncEdgeIt : public UEdge {
    481481      public:
     
    563563      /// Its usage is quite simple, for example you can count the number
    564564      /// of edges in a graph \c g of type \c Graph as follows:
    565       /// \code
     565      ///\code
    566566      /// int count=0;
    567567      /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
    568       /// \endcode
     568      ///\endcode
    569569      class EdgeIt : public Edge {
    570570      public:
     
    608608      /// of outgoing edges of a node \c n
    609609      /// in graph \c g of type \c Graph as follows.
    610       /// \code
     610      ///\code
    611611      /// int count=0;
    612612      /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    613       /// \endcode
     613      ///\endcode
    614614   
    615615      class OutEdgeIt : public Edge {
     
    660660      /// of outgoing edges of a node \c n
    661661      /// in graph \c g of type \c Graph as follows.
    662       /// \code
     662      ///\code
    663663      /// int count=0;
    664664      /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    665       /// \endcode
     665      ///\endcode
    666666
    667667      class InEdgeIt : public Edge {
  • lemon/concept/graph.h

    r1909 r1946  
    193193      /// Its usage is quite simple, for example you can count the number
    194194      /// of nodes in graph \c g of type \c Graph like this:
    195       /// \code
     195      ///\code
    196196      /// int count=0;
    197197      /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
    198       /// \endcode
     198      ///\endcode
    199199      class NodeIt : public Node {
    200200      public:
     
    286286      /// of outgoing edges of a node \c n
    287287      /// in graph \c g of type \c Graph as follows.
    288       /// \code
     288      ///\code
    289289      /// int count=0;
    290290      /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    291       /// \endcode
     291      ///\endcode
    292292   
    293293      class OutEdgeIt : public Edge {
     
    333333      /// of outgoing edges of a node \c n
    334334      /// in graph \c g of type \c Graph as follows.
    335       /// \code
     335      ///\code
    336336      /// int count=0;
    337337      /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    338       /// \endcode
     338      ///\endcode
    339339
    340340      class InEdgeIt : public Edge {
     
    377377      /// Its usage is quite simple, for example you can count the number
    378378      /// of edges in a graph \c g of type \c Graph as follows:
    379       /// \code
     379      ///\code
    380380      /// int count=0;
    381381      /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
    382       /// \endcode
     382      ///\endcode
    383383      class EdgeIt : public Edge {
    384384      public:
  • lemon/concept/ugraph.h

    r1910 r1946  
    305305      /// Its usage is quite simple, for example you can count the number
    306306      /// of nodes in graph \c g of type \c Graph like this:
    307       /// \code
     307      ///\code
    308308      /// int count=0;
    309309      /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
    310       /// \endcode
     310      ///\endcode
    311311      class NodeIt : public Node {
    312312      public:
     
    396396      /// Its usage is quite simple, for example you can count the number
    397397      /// of undirected edges in a graph \c g of type \c Graph as follows:
    398       /// \code
     398      ///\code
    399399      /// int count=0;
    400400      /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count;
    401       /// \endcode
     401      ///\endcode
    402402      class UEdgeIt : public UEdge {
    403403      public:
     
    444444      /// of incident edges of a node \c n
    445445      /// in graph \c g of type \c Graph as follows.
    446       /// \code
     446      ///\code
    447447      /// int count=0;
    448448      /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    449       /// \endcode
     449      ///\endcode
    450450      class IncEdgeIt : public UEdge {
    451451      public:
     
    533533      /// Its usage is quite simple, for example you can count the number
    534534      /// of edges in a graph \c g of type \c Graph as follows:
    535       /// \code
     535      ///\code
    536536      /// int count=0;
    537537      /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
    538       /// \endcode
     538      ///\endcode
    539539      class EdgeIt : public Edge {
    540540      public:
     
    578578      /// of outgoing edges of a node \c n
    579579      /// in graph \c g of type \c Graph as follows.
    580       /// \code
     580      ///\code
    581581      /// int count=0;
    582582      /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    583       /// \endcode
     583      ///\endcode
    584584   
    585585      class OutEdgeIt : public Edge {
     
    630630      /// of outgoing edges of a node \c n
    631631      /// in graph \c g of type \c Graph as follows.
    632       /// \code
     632      ///\code
    633633      /// int count=0;
    634634      /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    635       /// \endcode
     635      ///\endcode
    636636
    637637      class InEdgeIt : public Edge {
Note: See TracChangeset for help on using the changeset viewer.