COIN-OR::LEMON - Graph Library

Changeset 1534:b86aad11f842 in lemon-0.x for lemon/graph_reader.h


Ignore:
Timestamp:
07/04/05 18:11:33 (14 years ago)
Author:
athos
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2026
Message:

Doc.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/graph_reader.h

    r1476 r1534  
    3434  /// \brief The graph reader class.
    3535  ///
     36  /// The \c GraphReader class provides the graph input.
     37  /// Before you read this documentation it might be useful to read the general
     38  /// description of  \ref graph-io-page "Graph Input-Output".
     39  /// If you don't need very sophisticated
     40  /// behaviour then you can use the versions of the public function
     41  /// \ref readGraph() to read a graph (or a max flow instance etc).
     42  ///
    3643  /// The given file format may contain several maps and labeled nodes or
    3744  /// edges.
     
    333340  };
    334341
    335   /// \brief Read a graph from the input.
    336   ///
    337   /// Read a graph from the input.
     342
     343  ///\anchor readGraph()
     344  ///
     345  /// \brief Read a graph from an input stream.
     346  ///
     347  /// Read a graph from an input stream.
     348  /// \param is The input stream.
     349  /// \param g The graph.
     350  template<typename Graph>
     351  void readGraph(std::istream& is, Graph &g) {
     352    GraphReader<Graph> reader(is, g);
     353    reader.run();
     354  }
     355
     356  /// \brief Read a capacitated graph instance from an input stream.
     357  ///
     358  /// Read a capacitated graph (graph+capacity on the
     359  /// edges) from an input stream.
     360  /// \param is The input stream.
     361  /// \param g The graph.
     362  /// \param capacity The capacity map.
     363  template<typename Graph, typename CapacityMap>
     364  void readGraph(std::istream& is, Graph &g, CapacityMap& capacity) {
     365    GraphReader<Graph> reader(is, g);
     366    reader.readEdgeMap("capacity", capacity);
     367    reader.run();
     368  }
     369
     370  /// \brief Read a shortest path instance from an input stream.
     371  ///
     372  /// Read a shortest path instance (graph+capacity on the
     373  /// edges+designated source) from an input stream.
     374  /// \param is The input stream.
     375  /// \param g The graph.
     376  /// \param capacity The capacity map.
     377  /// \param s The source node.
     378  template<typename Graph, typename CapacityMap>
     379  void readGraph(std::istream& is, Graph &g, CapacityMap& capacity,
     380                  typename Graph::Node &s) {
     381    GraphReader<Graph> reader(is, g);
     382    reader.readEdgeMap("capacity", capacity);
     383    reader.readNode("source", s);
     384    reader.run();
     385  }
     386
     387
     388
     389  /// \brief Read a max flow instance from an input stream.
     390  ///
     391  /// Read a max flow instance (graph+capacity on the
     392  /// edges+designated source and target) from an input stream.
     393  ///
     394  /// \param is The input stream.
     395  /// \param g The graph.
     396  /// \param capacity The capacity map.
     397  /// \param s The source node.
     398  /// \param t The target node.
     399  template<typename Graph, typename CapacityMap>
     400  void readGraph(std::istream& is, Graph &g, CapacityMap& capacity,
     401                  typename Graph::Node &s, typename Graph::Node &t) {
     402    GraphReader<Graph> reader(is, g);
     403    reader.readEdgeMap("capacity", capacity);
     404    reader.readNode("source", s);
     405    reader.readNode("target", t);
     406    reader.run();
     407  }
     408
     409  /// \brief Read a min cost flow instance from an input stream.
     410  ///
     411  /// Read a min cost flow instance (graph+capacity on the edges+cost
     412  /// function on the edges+designated source and target) from an input stream.
     413  ///
    338414  /// \param is The input stream.
    339415  /// \param g The graph.
     
    354430  }
    355431
    356   /// \brief Read a graph from the input.
    357   ///
    358   /// Read a graph from the input.
    359   /// \param is The input stream.
    360   /// \param g The graph.
    361   /// \param capacity The capacity map.
    362   /// \param s The source node.
    363   /// \param t The target node.
    364   template<typename Graph, typename CapacityMap>
    365   void readGraph(std::istream& is, Graph &g, CapacityMap& capacity,
    366                   typename Graph::Node &s, typename Graph::Node &t) {
    367     GraphReader<Graph> reader(is, g);
    368     reader.readEdgeMap("capacity", capacity);
    369     reader.readNode("source", s);
    370     reader.readNode("target", t);
    371     reader.run();
    372   }
    373 
    374   /// \brief Read a graph from the input.
    375   ///
    376   /// Read a graph from the input.
    377   /// \param is The input stream.
    378   /// \param g The graph.
    379   /// \param capacity The capacity map.
    380   /// \param s The source node.
    381   template<typename Graph, typename CapacityMap>
    382   void readGraph(std::istream& is, Graph &g, CapacityMap& capacity,
    383                   typename Graph::Node &s) {
    384     GraphReader<Graph> reader(is, g);
    385     reader.readEdgeMap("capacity", capacity);
    386     reader.readNode("source", s);
    387     reader.run();
    388   }
    389 
    390   /// \brief Read a graph from the input.
    391   ///
    392   /// Read a graph from the input.
    393   /// \param is The input stream.
    394   /// \param g The graph.
    395   /// \param capacity The capacity map.
    396   template<typename Graph, typename CapacityMap>
    397   void readGraph(std::istream& is, Graph &g, CapacityMap& capacity) {
    398     GraphReader<Graph> reader(is, g);
    399     reader.readEdgeMap("capacity", capacity);
    400     reader.run();
    401   }
    402 
    403   /// \brief Read a graph from the input.
    404   ///
    405   /// Read a graph from the input.
    406   /// \param is The input stream.
    407   /// \param g The graph.
    408   template<typename Graph>
    409   void readGraph(std::istream& is, Graph &g) {
    410     GraphReader<Graph> reader(is, g);
    411     reader.run();
    412   }
    413432
    414433  /// \brief The undir graph reader class.
     
    780799  };
    781800
    782   /// \brief Read an undir graph from the input.
    783   ///
    784   /// Read an undir graph from the input.
     801  /// \brief Read an undirected graph from an input stream.
     802  ///
     803  /// Read an undirected graph from an input stream.
     804  /// \param is The input stream.
     805  /// \param g The graph.
     806  template<typename Graph>
     807  void readUndirGraph(std::istream& is, Graph &g) {
     808    UndirGraphReader<Graph> reader(is, g);
     809    reader.run();
     810  }
     811
     812  /// \brief Read an undirected multigraph (undirected graph + capacity
     813  /// map on the edges) from an input stream.
     814  ///
     815  /// Read an undirected multigraph (undirected graph + capacity
     816  /// map on the edges) from an input stream.
    785817  /// \param is The input stream.
    786818  /// \param g The graph.
     
    793825  }
    794826
    795   /// \brief Read an undir graph from the input.
    796   ///
    797   /// Read an undir graph from the input.
    798   /// \param is The input stream.
    799   /// \param g The graph.
    800   template<typename Graph>
    801   void readUndirGraph(std::istream& is, Graph &g) {
    802     UndirGraphReader<Graph> reader(is, g);
    803     reader.run();
    804   }
    805827
    806828  /// @}
Note: See TracChangeset for help on using the changeset viewer.