COIN-OR::LEMON - Graph Library

Changeset 1631:e15162d8eca1 in lemon-0.x


Ignore:
Timestamp:
08/16/05 21:06:59 (14 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2139
Message:

Fixed most (but not all) of Doxygen warnings

Files:
13 edited

Legend:

Unmodified
Added
Removed
  • doc/graph_io.dox

    r1540 r1631  
    123123\subsection write Writing a graph
    124124
    125 The \c GraphWriter class provides the graph output. To write a graph
     125The \ref lemon::GraphWriter "GraphWriter" template class
     126provides the graph output. To write a graph
    126127you should first give writing commands to the writer. You can declare
    127128writing command as \c NodeMap or \c EdgeMap writing and labeled Node and
     
    132133\endcode
    133134
    134 The \c writeNodeMap() function declares a \c NodeMap writing command in the
    135 \c GraphWriter. You should give a name to the map and the map
     135The \ref lemon::GraphWriter::writeNodeMap() "writeNodeMap()"
     136function declares a \c NodeMap writing command in the
     137\ref lemon::GraphWriter "GraphWriter".
     138You should give a name to the map and the map
    136139object as parameters. The NodeMap writing command with name "id" should write a
    137140unique map because it will be regarded as an ID map.
     
    148151\endcode
    149152
    150 With the \c writeEdgeMap() member function you can give an edge map
     153With the \ref lemon::GraphWriter::writeEdgeMap() "writeEdgeMap()"
     154member function you can give an edge map
    151155writing command similar to the NodeMaps.
    152156
     
    161165\endcode
    162166
    163 With \c writeNode() and \c writeEdge() functions you can designate Nodes and
     167With \ref lemon::GraphWriter::writeNode() "writeNode()"
     168and \ref lemon::GraphWriter::writeEdge() "writeEdge()"
     169functions you can designate Nodes and
    164170Edges in the graph. For example, you can write out the source and target node
    165171of a maximum flow instance.
     
    172178\endcode
    173179
    174 With \c writeAttribute() function you can write an attribute to the file.
     180With \ref lemon::GraphWriter::writeAttribute() "writeAttribute()"
     181function you can write an attribute to the file.
    175182
    176183\code
     
    179186\endcode
    180187
    181 After you give all write commands you must call the \c run() member
     188After you give all write commands you must call the
     189\ref lemon::GraphWriter::run() "run()" member
    182190function, which executes all the writing commands.
    183191
     
    190198The file to be read may contain several maps and labeled nodes or edges.
    191199If you read a graph you need not read all the maps and items just those
    192 that you need. The interface of the \c GraphReader is very similar to
    193 the GraphWriter but the reading method does not depend on the order of the
     200that you need. The interface of the \ref lemon::GraphReader "GraphReader"
     201is very similar to
     202the \ref lemon::GraphWriter "GraphWriter"
     203but the reading method does not depend on the order of the
    194204given commands.
    195205
     
    202212\endcode
    203213
    204 The \c readNodeMap() function reads a map from the \c nodeset section.
     214The \ref lemon::GraphReader::readNodeMap() "readNodeMap()"
     215function reads a map from the \c nodeset section.
    205216If there is a map that you do not want to read from the file and there are
    206217whitespaces in the string represenation of the values then you should
    207 call the \c skipNodeMap() template member function with proper parameters.
     218call the \ref lemon::GraphReader::skipNodeMap() "skipNodeMap()"
     219template member function with proper parameters.
    208220
    209221\see QuotedStringReader
     
    219231\endcode
    220232
    221 With the \c readEdgeMap() member function you can give an edge map
     233With the \ref lemon::GraphReader::readEdgeMap() "readEdgeMap()"
     234member function you can give an edge map
    222235reading command similar to the NodeMaps.
    223236
     
    227240\endcode
    228241
    229 With \c readNode() and \c readEdge() functions you can read labeled Nodes and
     242With \ref lemon::GraphReader::readNode() "readNode()"
     243and \ref lemon::GraphReader::readEdge() "readEdge()"
     244functions you can read labeled Nodes and
    230245Edges.
    231246
     
    237252\endcode
    238253
    239 With \c readAttribute() function you can read an attribute from the file.
     254With \ref lemon::GraphReader::readAttribute() "readAttribute()"
     255function you can read an attribute from the file.
    240256
    241257\code
     
    246262\endcode
    247263
    248 After you give all read commands you must call the \c run() member
     264After you give all read commands you must call the
     265\ref lemon::GraphReader::run() "run()" member
    249266function, which executes all the commands.
    250267
     
    258275
    259276To read a map (on the nodes or edges)
    260 the \c GraphReader should know how to read a Value from the given map.
     277the \ref lemon::GraphReader "GraphReader"
     278should know how to read a Value from the given map.
    261279By the default implementation the input operator reads a value from
    262280the stream and the type of the readed value is the value type of the given map.
     
    338356\endcode
    339357
    340 There are similar classes to the \c GraphReader ans \c GraphWriter
    341 which handle the undirected graphs. These classes are the
    342 \c UndirGraphReader and \UndirGraphWriter.
    343 
    344 The \c readUndirMap() function reads an undirected map and the
    345 \c readUndirEdge() reads an undirected edge from the file,
     358There are similar classes to the \ref lemon::GraphReader "GraphReader" and
     359\ref lemon::GraphWriter "GraphWriter" which
     360handle the undirected graphs. These classes are
     361the \ref lemon::UndirGraphReader "UndirGraphReader"
     362and \ref lemon::UndirGraphWriter "UndirGraphWriter".
     363
     364The \ref lemon::UndirGraphReader::readUndirMap() "readUndirMap()"
     365function reads an undirected map and the
     366\ref lemon::UndirGraphReader::readUndirEdge() "readUndirEdge()"
     367reads an undirected edge from the file,
    346368
    347369\code
     
    365387character. The file may contains comment lines with \c # first character.
    366388
    367 The \c LemonReader and \c LemonWriter gives a framework to read and
     389The \ref lemon::LemonReader "LemonReader"
     390and \ref lemon::LemonWriter "LemonWriter"
     391gives a framework to read and
    368392write sections. There are various section reader and section writer
    369 classes which can be attached to a \c LemonReader or a \c LemonWriter.
     393classes which can be attached to a \ref lemon::LemonReader "LemonReader"
     394or a \ref lemon::LemonWriter "LemonWriter".
    370395
    371396There are default section readers and writers for reading and writing
     
    373398the format described above. Other type of data can be handled with own
    374399section reader and writer classes which are inherited from the
    375 \c LemonReader::SectionReader or the \c LemonWriter::SectionWriter classes.
     400\c LemonReader::SectionReader or the
     401\ref lemon::LemonWriter::SectionWriter "LemonWriter::SectionWriter"
     402classes.
    376403
    377404The next example defines a special section reader which reads the
     
    415442In our example there is a network with symmetric links and there are assymetric
    416443traffic request on the network. This construction can be stored in an
    417 undirected graph and in a directed NewEdgeSetAdaptor class. The example
    418 shows the input with the LemonReader class:
     444undirected graph and in a directed \c NewEdgeSetAdaptor class. The example
     445shows the input with the \ref lemon::LemonReader "LemonReader" class:
    419446
    420447\code
     
    434461\endcode
    435462
    436 Because the GraphReader and the UndirGraphReader can be converted
    437 to LemonReader and it can resolve the ID's of the items, the previous
    438 result can be achived with the UndirGraphReader class, too.
     463Because both the \ref lemon::GraphReader "GraphReader"
     464and the \ref lemon::UndirGraphReader "UndirGraphReader" can be converted
     465to \ref lemon::LemonReader "LemonReader"
     466and it can resolve the ID's of the items, the previous
     467result can be achived with the \ref lemon::UndirGraphReader "UndirGraphReader"
     468class, too.
    439469
    440470
  • doc/graphs.dox

    r1200 r1631  
    3535\ref lemon::concept::ExtendableGraph "ExtendableGraph" concept,
    3636so you cannot delete individual edges or nodes.
    37 \li \ref lemon::SymListGraph "SymListGraph" and
    38 \ref lemon::SymSmartGraph "SymSmartGraph" classes are very similar to
    39 \ref lemon::ListGraph "ListGraph" and \ref lemon::SmartGraph "SmartGraph".
    40 The difference is that whenever you add a
    41 new edge to the graph, it actually adds a pair of oppositely directed edges.
    42 They are linked together so it is possible to access the counterpart of an
    43 edge. An even more important feature is that using these classes you can also
    44 attach data to the edges in such a way that the stored data
    45 are shared by the edge pairs.
    4637\li \ref lemon::FullGraph "FullGraph"
    4738implements a complete graph. It is a
  • doc/license.dox

    r1536 r1631  
    33\page license License Terms
    44
    5 \verbinclude ../LICENSE
     5\verbinclude LICENSE
    66
    77*/
  • lemon/bfs.h

    r1624 r1631  
    699699    ///if \c v is unreachable from the root(s) or \c v is a root. The
    700700    ///shortest path tree used here is equal to the shortest path tree used in
    701     ///\ref predNode(Node v).
     701    ///\ref predNode().
    702702    ///\pre Either \ref run() or \ref start() must be called before using
    703703    ///this function.
     
    714714    ///if \c v itself a root.
    715715    ///The shortest path tree used here is equal to the shortest path
    716     ///tree used in \ref pred(Node v).
     716    ///tree used in \ref pred().
    717717    ///\pre Either \ref run() or \ref start() must be called before
    718718    ///using this function.
  • lemon/concept/graph.h

    r1630 r1631  
    405405        /// This constructor sets the iterator to the first edge of \c g.
    406406        ///@param g the graph
    407         EdgeIt(const StaticGraph&) { }
     407        EdgeIt(const StaticGraph& g) { }
    408408        /// Edge -> EdgeIt conversion
    409409
  • lemon/concept/graph_component.h

    r1627 r1631  
    764764
    765765    /// This class describes the common interface of the graph maps
    766     /// (NodeMap, EdgeMap), that is \ref maps-pages "maps" which can be used to
     766    /// (NodeMap, EdgeMap), that is \ref maps-page "maps" which can be used to
    767767    /// associate data to graph descriptors (nodes or edges).
    768768    template <typename Graph, typename Item, typename _Value>
  • lemon/concept/undir_graph.h

    r1630 r1631  
    233233    ///
    234234    /// In LEMON undirected graphs also fulfill the concept of directed
    235     /// graphs (\ref lemon::concept::Graph "Graph Concept"). For
     235    /// graphs (\ref lemon::concept::StaticGraph "Graph Concept"). For
    236236    /// explanation of this and more see also the page \ref undir_graphs,
    237237    /// a tutorial about undirected graphs.
     
    558558        /// This constructor sets the iterator to the first edge of \c g.
    559559        ///@param g the graph
    560         EdgeIt(const UndirGraph&) { }
     560        EdgeIt(const UndirGraph &g) { }
    561561        /// Edge -> EdgeIt conversion
    562562
     
    606606        ///@param n the node
    607607        ///@param g the graph
    608         OutEdgeIt(const UndirGraph&, const Node&) { }
     608        OutEdgeIt(const UndirGraph& n, const Node& g) { }
    609609        /// Edge -> OutEdgeIt conversion
    610610
     
    655655        ///@param n the node
    656656        ///@param g the graph
    657         InEdgeIt(const UndirGraph&, const Node&) { }
     657        InEdgeIt(const UndirGraph& g, const Node& n) { }
    658658        /// Edge -> InEdgeIt conversion
    659659
  • lemon/dfs.h

    r1540 r1631  
    709709    ///if \c v is unreachable from the root(s) or \c v is a root. The
    710710    ///%DFS tree used here is equal to the %DFS tree used in
    711     ///\ref predNode(Node v).
     711    ///\ref predNode().
    712712    ///\pre Either \ref run() or \ref start() must be called before using
    713713    ///this function.
     
    724724    ///if \c v itself a root.
    725725    ///The %DFS tree used here is equal to the %DFS
    726     ///tree used in \ref pred(Node v).
     726    ///tree used in \ref pred().
    727727    ///\pre Either \ref run() or \ref start() must be called before
    728728    ///using this function.
  • lemon/dijkstra.h

    r1536 r1631  
    703703    ///if \c v is unreachable from the root or if \c v=s. The
    704704    ///shortest path tree used here is equal to the shortest path tree used in
    705     ///\ref predNode(Node v).  \pre \ref run() must be called before using
     705    ///\ref predNode().  \pre \ref run() must be called before using
    706706    ///this function.
    707707    ///\todo predEdge could be a better name.
     
    714714    ///root to \c /v. It is INVALID if \c v is unreachable from the root or if
    715715    ///\c v=s. The shortest path tree used here is equal to the shortest path
    716     ///tree used in \ref pred(Node v).  \pre \ref run() must be called before
     716    ///tree used in \ref pred().  \pre \ref run() must be called before
    717717    ///using this function.
    718718    Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
  • lemon/graph_adaptor.h

    r1627 r1631  
    14211421  ///
    14221422  /// \param _Graph The type of the graph which shares its node set with
    1423   /// this class. Its interface must conform to the \ref skeleton::StaticGraph
     1423  /// this class. Its interface must conform to the \ref concept::StaticGraph
    14241424  /// "StaticGraph" concept.
    14251425  ///
    14261426  /// In the edge extension and removing it conforms to the
    1427   /// \ref skeleton::ExtendableGraph "ExtendableGraph" concept.
     1427  /// \ref concept::ExtendableGraph "ExtendableGraph" concept.
    14281428  template <typename _Graph>
    14291429  class NewEdgeSetAdaptor :
     
    15131513  ///
    15141514  /// \param _Graph The type of the graph which shares its node set with
    1515   /// this class. Its interface must conform to the \ref skeleton::StaticGraph
     1515  /// this class. Its interface must conform to the \ref concept::StaticGraph
    15161516  /// "StaticGraph" concept.
    15171517  ///
    15181518  /// In the edge extension and removing it conforms to the
    1519   /// \ref skeleton::ExtendableGraph "ExtendableGraph" concept.
     1519  /// \ref concept::ExtendableGraph "ExtendableGraph" concept.
    15201520  template <typename _Graph>
    15211521  class NewUndirEdgeSetAdaptor :
  • lemon/kruskal.h

    r1603 r1631  
    5252  /// \param g The graph the algorithm runs on.
    5353  /// It can be either \ref concept::StaticGraph "directed" or
    54   /// \ref concept::UndirStaticGraph "undirected".
     54  /// \ref concept::UndirGraph "undirected".
    5555  /// If the graph is directed, the algorithm consider it to be
    5656  /// undirected by disregarding the direction of the edges.
     
    8989  /// \return The cost of the found tree.
    9090  ///
    91   /// \warning If kruskal is run on an \ref undirected graph, be sure that the
     91  /// \warning If kruskal is run on an
     92  /// \ref lemon::concept::UndirGraph "undirected graph", be sure that the
    9293  /// map storing the tree is also undirected
    9394  /// (e.g. UndirListGraph::UndirEdgeMap<bool>, otherwise the values of the
  • lemon/preflow.h

    r1435 r1631  
    284284
    285285    ///The preflow algorithm consists of two phases, this method runs
    286     ///the second phase. After calling \ref phase1 and then \ref
    287     ///phase2, \ref flow contains a maximum flow, \ref flowValue
     286    ///the second phase. After calling \ref phase1() and then
     287    ///\ref phase2(),
     288    /// \ref flowMap() return a maximum flow, \ref flowValue
    288289    ///returns the value of a maximum flow, \ref minCut returns a
    289290    ///minimum cut, while the methods \ref minMinCut and \ref
  • lemon/smart_graph.h

    r1537 r1631  
    9090    /// Maximum node ID.
    9191    ///\sa id(Node)
    92     int maxId(Node = INVALID) const { return nodes.size()-1; }
     92    int maxId(Node) const { return nodes.size()-1; }
    9393    /// Maximum edge ID.
    9494   
    9595    /// Maximum edge ID.
    9696    ///\sa id(Edge)
    97     int maxId(Edge = INVALID) const { return edges.size()-1; }
     97    int maxId(Edge) const { return edges.size()-1; }
    9898
    9999    Node source(Edge e) const { return edges[e.n].source; }
     
    103103   
    104104    /// The ID of a valid Node is a nonnegative integer not greater than
    105     /// \ref maxNodeId(). The range of the ID's is not surely continuous
    106     /// and the greatest node ID can be actually less then \ref maxNodeId().
     105    /// \ref maxId(Node). The range of the ID's is not surely continuous
     106    /// and the greatest node ID can be actually less then \ref maxId(Node).
    107107    ///
    108108    /// The ID of the \ref INVALID node is -1.
     
    112112   
    113113    /// The ID of a valid Edge is a nonnegative integer not greater than
    114     /// \ref maxEdgeId(). The range of the ID's is not surely continuous
    115     /// and the greatest edge ID can be actually less then \ref maxEdgeId().
     114    /// \ref maxId(Edge). The range of the ID's is not surely continuous
     115    /// and the greatest edge ID can be actually less then \ref maxId(Edge).
    116116    ///
    117117    /// The ID of the \ref INVALID edge is -1.
Note: See TracChangeset for help on using the changeset viewer.