COIN-OR::LEMON - Graph Library

Changeset 646:f63e87b9748e in lemon


Ignore:
Timestamp:
04/21/09 11:34:49 (16 years ago)
Author:
Alpar Juttner <alpar@…>
Branch:
default
Parents:
645:a3402913cffe (diff), 644:2ca0cdb5f366 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Phase:
public
Message:

Merge

Location:
lemon
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • lemon/lgf_reader.h

    r631 r646  
    102102    };
    103103
    104     template <typename _Graph, bool _dir, typename _Map,
     104    template <typename _GR, bool _dir, typename _Map,
    105105              typename _Converter = DefaultConverter<typename _Map::Value> >
    106     class GraphArcMapStorage : public MapStorageBase<typename _Graph::Edge> {
     106    class GraphArcMapStorage : public MapStorageBase<typename _GR::Edge> {
    107107    public:
    108108      typedef _Map Map;
    109109      typedef _Converter Converter;
    110       typedef _Graph Graph;
    111       typedef typename Graph::Edge Item;
     110      typedef _GR GR;
     111      typedef typename GR::Edge Item;
    112112      static const bool dir = _dir;
    113113
    114114    private:
    115       const Graph& _graph;
     115      const GR& _graph;
    116116      Map& _map;
    117117      Converter _converter;
    118118
    119119    public:
    120       GraphArcMapStorage(const Graph& graph, Map& map,
     120      GraphArcMapStorage(const GR& graph, Map& map,
    121121                         const Converter& converter = Converter())
    122122        : _graph(graph), _map(map), _converter(converter) {}
     
    174174    };
    175175
    176     template <typename Graph>
     176    template <typename GR>
    177177    struct GraphArcLookUpConverter {
    178       const Graph& _graph;
    179       const std::map<std::string, typename Graph::Edge>& _map;
    180 
    181       GraphArcLookUpConverter(const Graph& graph,
     178      const GR& _graph;
     179      const std::map<std::string, typename GR::Edge>& _map;
     180
     181      GraphArcLookUpConverter(const GR& graph,
    182182                              const std::map<std::string,
    183                                              typename Graph::Edge>& map)
     183                                             typename GR::Edge>& map)
    184184        : _graph(graph), _map(map) {}
    185185
    186       typename Graph::Arc operator()(const std::string& str) {
     186      typename GR::Arc operator()(const std::string& str) {
    187187        if (str.empty() || (str[0] != '+' && str[0] != '-')) {
    188188          throw FormatError("Item must start with '+' or '-'");
    189189        }
    190         typename std::map<std::string, typename Graph::Edge>
     190        typename std::map<std::string, typename GR::Edge>
    191191          ::const_iterator it = _map.find(str.substr(1));
    192192        if (it == _map.end()) {
     
    388388  }
    389389
    390   template <typename Digraph>
     390  template <typename DGR>
    391391  class DigraphReader;
    392392
    393   template <typename Digraph>
    394   DigraphReader<Digraph> digraphReader(Digraph& digraph,
    395                                        std::istream& is = std::cin);
    396   template <typename Digraph>
    397   DigraphReader<Digraph> digraphReader(Digraph& digraph, const std::string& fn);
    398   template <typename Digraph>
    399   DigraphReader<Digraph> digraphReader(Digraph& digraph, const char *fn);
     393  template <typename TDGR>
     394  DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is = std::cin);
     395  template <typename TDGR>
     396  DigraphReader<TDGR> digraphReader(TDGR& digraph, const std::string& fn);
     397  template <typename TDGR>
     398  DigraphReader<TDGR> digraphReader(TDGR& digraph, const char *fn);
    400399
    401400  /// \ingroup lemon_io
     
    420419  ///
    421420  ///\code
    422   /// DigraphReader<Digraph>(digraph, std::cin).
     421  /// DigraphReader<DGR>(digraph, std::cin).
    423422  ///   nodeMap("coordinates", coord_map).
    424423  ///   arcMap("capacity", cap_map).
     
    449448  /// a single pass, because the arcs are not constructed when the node
    450449  /// maps are read.
    451   template <typename GR>
     450  template <typename DGR>
    452451  class DigraphReader {
    453452  public:
    454453
    455     typedef GR Digraph;
     454    typedef DGR Digraph;
    456455
    457456  private:
    458457
    459     TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     458    TEMPLATE_DIGRAPH_TYPEDEFS(DGR);
    460459
    461460    std::istream* _is;
     
    463462    std::string _filename;
    464463
    465     Digraph& _digraph;
     464    DGR& _digraph;
    466465
    467466    std::string _nodes_caption;
     
    501500    /// Construct a directed graph reader, which reads from the given
    502501    /// input stream.
    503     DigraphReader(Digraph& digraph, std::istream& is = std::cin)
     502    DigraphReader(DGR& digraph, std::istream& is = std::cin)
    504503      : _is(&is), local_is(false), _digraph(digraph),
    505504        _use_nodes(false), _use_arcs(false),
     
    510509    /// Construct a directed graph reader, which reads from the given
    511510    /// file.
    512     DigraphReader(Digraph& digraph, const std::string& fn)
     511    DigraphReader(DGR& digraph, const std::string& fn)
    513512      : _is(new std::ifstream(fn.c_str())), local_is(true),
    514513        _filename(fn), _digraph(digraph),
     
    525524    /// Construct a directed graph reader, which reads from the given
    526525    /// file.
    527     DigraphReader(Digraph& digraph, const char* fn)
     526    DigraphReader(DGR& digraph, const char* fn)
    528527      : _is(new std::ifstream(fn)), local_is(true),
    529528        _filename(fn), _digraph(digraph),
     
    561560  private:
    562561
    563     template <typename DGR>
    564     friend DigraphReader<DGR> digraphReader(DGR& digraph, std::istream& is);
    565     template <typename DGR>
    566     friend DigraphReader<DGR> digraphReader(DGR& digraph,
    567                                             const std::string& fn);
    568     template <typename DGR>
    569     friend DigraphReader<DGR> digraphReader(DGR& digraph, const char *fn);
     562    template <typename TDGR>
     563    friend DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is);
     564    template <typename TDGR>
     565    friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
     566                                             const std::string& fn);
     567    template <typename TDGR>
     568    friend DigraphReader<TDGR> digraphReader(TDGR& digraph, const char *fn);
    570569
    571570    DigraphReader(DigraphReader& other)
     
    11891188
    11901189  };
     1190 
     1191  /// \ingroup lemon_io
     1192  ///
     1193  /// \brief Return a \ref DigraphReader class
     1194  ///
     1195  /// This function just returns a \ref DigraphReader class.
     1196  ///
     1197  /// With this function a digraph can be read from an
     1198  /// \ref lgf-format "LGF" file or input stream with several maps and
     1199  /// attributes. For example, there is network flow problem on a
     1200  /// digraph, i.e. a digraph with a \e capacity map on the arcs and
     1201  /// \e source and \e target nodes. This digraph can be read with the
     1202  /// following code:
     1203  ///
     1204  ///\code
     1205  ///ListDigraph digraph;
     1206  ///ListDigraph::ArcMap<int> cm(digraph);
     1207  ///ListDigraph::Node src, trg;
     1208  ///digraphReader(digraph, std::cin).
     1209  ///  arcMap("capacity", cap).
     1210  ///  node("source", src).
     1211  ///  node("target", trg).
     1212  ///  run();
     1213  ///\endcode
     1214  ///
     1215  /// For a complete documentation, please see the \ref DigraphReader
     1216  /// class documentation.
     1217  /// \warning Don't forget to put the \ref DigraphReader::run() "run()"
     1218  /// to the end of the parameter list.
     1219  /// \relates DigraphReader
     1220  /// \sa digraphReader(TDGR& digraph, const std::string& fn)
     1221  /// \sa digraphReader(TDGR& digraph, const char* fn)
     1222  template <typename TDGR>
     1223  DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is) {
     1224    DigraphReader<TDGR> tmp(digraph, is);
     1225    return tmp;
     1226  }
    11911227
    11921228  /// \brief Return a \ref DigraphReader class
     
    11941230  /// This function just returns a \ref DigraphReader class.
    11951231  /// \relates DigraphReader
    1196   template <typename Digraph>
    1197   DigraphReader<Digraph> digraphReader(Digraph& digraph, std::istream& is) {
    1198     DigraphReader<Digraph> tmp(digraph, is);
     1232  /// \sa digraphReader(TDGR& digraph, std::istream& is)
     1233  template <typename TDGR>
     1234  DigraphReader<TDGR> digraphReader(TDGR& digraph, const std::string& fn) {
     1235    DigraphReader<TDGR> tmp(digraph, fn);
    11991236    return tmp;
    12001237  }
     
    12041241  /// This function just returns a \ref DigraphReader class.
    12051242  /// \relates DigraphReader
    1206   template <typename Digraph>
    1207   DigraphReader<Digraph> digraphReader(Digraph& digraph,
    1208                                        const std::string& fn) {
    1209     DigraphReader<Digraph> tmp(digraph, fn);
     1243  /// \sa digraphReader(TDGR& digraph, std::istream& is)
     1244  template <typename TDGR>
     1245  DigraphReader<TDGR> digraphReader(TDGR& digraph, const char* fn) {
     1246    DigraphReader<TDGR> tmp(digraph, fn);
    12101247    return tmp;
    12111248  }
    12121249
    1213   /// \brief Return a \ref DigraphReader class
    1214   ///
    1215   /// This function just returns a \ref DigraphReader class.
    1216   /// \relates DigraphReader
    1217   template <typename Digraph>
    1218   DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) {
    1219     DigraphReader<Digraph> tmp(digraph, fn);
    1220     return tmp;
    1221   }
    1222 
    1223   template <typename Graph>
     1250  template <typename GR>
    12241251  class GraphReader;
    12251252 
    1226   template <typename Graph>
    1227   GraphReader<Graph> graphReader(Graph& graph,
    1228                                  std::istream& is = std::cin);
    1229   template <typename Graph>
    1230   GraphReader<Graph> graphReader(Graph& graph, const std::string& fn);
    1231   template <typename Graph>
    1232   GraphReader<Graph> graphReader(Graph& graph, const char *fn);
     1253  template <typename TGR>
     1254  GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin);
     1255  template <typename TGR>
     1256  GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
     1257  template <typename TGR>
     1258  GraphReader<TGR> graphReader(TGR& graph, const char *fn);
    12331259
    12341260  /// \ingroup lemon_io
     
    12551281  private:
    12561282
    1257     TEMPLATE_GRAPH_TYPEDEFS(Graph);
     1283    TEMPLATE_GRAPH_TYPEDEFS(GR);
    12581284
    12591285    std::istream* _is;
     
    12611287    std::string _filename;
    12621288
    1263     Graph& _graph;
     1289    GR& _graph;
    12641290
    12651291    std::string _nodes_caption;
     
    12991325    /// Construct an undirected graph reader, which reads from the given
    13001326    /// input stream.
    1301     GraphReader(Graph& graph, std::istream& is = std::cin)
     1327    GraphReader(GR& graph, std::istream& is = std::cin)
    13021328      : _is(&is), local_is(false), _graph(graph),
    13031329        _use_nodes(false), _use_edges(false),
     
    13081334    /// Construct an undirected graph reader, which reads from the given
    13091335    /// file.
    1310     GraphReader(Graph& graph, const std::string& fn)
     1336    GraphReader(GR& graph, const std::string& fn)
    13111337      : _is(new std::ifstream(fn.c_str())), local_is(true),
    13121338        _filename(fn), _graph(graph),
     
    13231349    /// Construct an undirected graph reader, which reads from the given
    13241350    /// file.
    1325     GraphReader(Graph& graph, const char* fn)
     1351    GraphReader(GR& graph, const char* fn)
    13261352      : _is(new std::ifstream(fn)), local_is(true),
    13271353        _filename(fn), _graph(graph),
     
    13581384
    13591385  private:
    1360     template <typename Graph>
    1361     friend GraphReader<Graph> graphReader(Graph& graph, std::istream& is);
    1362     template <typename Graph>
    1363     friend GraphReader<Graph> graphReader(Graph& graph, const std::string& fn);
    1364     template <typename Graph>
    1365     friend GraphReader<Graph> graphReader(Graph& graph, const char *fn);
     1386    template <typename TGR>
     1387    friend GraphReader<TGR> graphReader(TGR& graph, std::istream& is);
     1388    template <typename TGR>
     1389    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
     1390    template <typename TGR>
     1391    friend GraphReader<TGR> graphReader(TGR& graph, const char *fn);
    13661392
    13671393    GraphReader(GraphReader& other)
     
    14551481      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
    14561482      _reader_bits::MapStorageBase<Edge>* backward_storage =
    1457         new _reader_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
     1483        new _reader_bits::GraphArcMapStorage<GR, false, Map>(_graph, map);
    14581484      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
    14591485      return *this;
     
    14691495      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
    14701496      _reader_bits::MapStorageBase<Edge>* forward_storage =
    1471         new _reader_bits::GraphArcMapStorage<Graph, true, Map, Converter>
     1497        new _reader_bits::GraphArcMapStorage<GR, true, Map, Converter>
    14721498        (_graph, map, converter);
    14731499      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
    14741500      _reader_bits::MapStorageBase<Edge>* backward_storage =
    1475         new _reader_bits::GraphArcMapStorage<Graph, false, Map, Converter>
     1501        new _reader_bits::GraphArcMapStorage<GR, false, Map, Converter>
    14761502        (_graph, map, converter);
    14771503      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
     
    15311557    /// Add an arc reading rule to reader.
    15321558    GraphReader& arc(const std::string& caption, Arc& arc) {
    1533       typedef _reader_bits::GraphArcLookUpConverter<Graph> Converter;
     1559      typedef _reader_bits::GraphArcLookUpConverter<GR> Converter;
    15341560      Converter converter(_graph, _edge_index);
    15351561      _reader_bits::ValueStorageBase* storage =
     
    20342060  };
    20352061
     2062  /// \ingroup lemon_io
     2063  ///
     2064  /// \brief Return a \ref GraphReader class
     2065  ///
     2066  /// This function just returns a \ref GraphReader class.
     2067  ///
     2068  /// With this function a graph can be read from an
     2069  /// \ref lgf-format "LGF" file or input stream with several maps and
     2070  /// attributes. For example, there is weighted matching problem on a
     2071  /// graph, i.e. a graph with a \e weight map on the edges. This
     2072  /// graph can be read with the following code:
     2073  ///
     2074  ///\code
     2075  ///ListGraph graph;
     2076  ///ListGraph::EdgeMap<int> weight(graph);
     2077  ///graphReader(graph, std::cin).
     2078  ///  edgeMap("weight", weight).
     2079  ///  run();
     2080  ///\endcode
     2081  ///
     2082  /// For a complete documentation, please see the \ref GraphReader
     2083  /// class documentation.
     2084  /// \warning Don't forget to put the \ref GraphReader::run() "run()"
     2085  /// to the end of the parameter list.
     2086  /// \relates GraphReader
     2087  /// \sa graphReader(TGR& graph, const std::string& fn)
     2088  /// \sa graphReader(TGR& graph, const char* fn)
     2089  template <typename TGR>
     2090  GraphReader<TGR> graphReader(TGR& graph, std::istream& is) {
     2091    GraphReader<TGR> tmp(graph, is);
     2092    return tmp;
     2093  }
     2094
    20362095  /// \brief Return a \ref GraphReader class
    20372096  ///
    20382097  /// This function just returns a \ref GraphReader class.
    20392098  /// \relates GraphReader
    2040   template <typename Graph>
    2041   GraphReader<Graph> graphReader(Graph& graph, std::istream& is) {
    2042     GraphReader<Graph> tmp(graph, is);
     2099  /// \sa graphReader(TGR& graph, std::istream& is)
     2100  template <typename TGR>
     2101  GraphReader<TGR> graphReader(TGR& graph, const std::string& fn) {
     2102    GraphReader<TGR> tmp(graph, fn);
    20432103    return tmp;
    20442104  }
     
    20482108  /// This function just returns a \ref GraphReader class.
    20492109  /// \relates GraphReader
    2050   template <typename Graph>
    2051   GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) {
    2052     GraphReader<Graph> tmp(graph, fn);
    2053     return tmp;
    2054   }
    2055 
    2056   /// \brief Return a \ref GraphReader class
    2057   ///
    2058   /// This function just returns a \ref GraphReader class.
    2059   /// \relates GraphReader
    2060   template <typename Graph>
    2061   GraphReader<Graph> graphReader(Graph& graph, const char* fn) {
    2062     GraphReader<Graph> tmp(graph, fn);
     2110  /// \sa graphReader(TGR& graph, std::istream& is)
     2111  template <typename TGR>
     2112  GraphReader<TGR> graphReader(TGR& graph, const char* fn) {
     2113    GraphReader<TGR> tmp(graph, fn);
    20632114    return tmp;
    20642115  }
     
    23172368  };
    23182369
     2370  /// \ingroup lemon_io
     2371  ///
    23192372  /// \brief Return a \ref SectionReader class
    23202373  ///
    23212374  /// This function just returns a \ref SectionReader class.
     2375  ///
     2376  /// Please see SectionReader documentation about the custom section
     2377  /// input.
     2378  ///
    23222379  /// \relates SectionReader
     2380  /// \sa sectionReader(const std::string& fn)
     2381  /// \sa sectionReader(const char *fn)
    23232382  inline SectionReader sectionReader(std::istream& is) {
    23242383    SectionReader tmp(is);
     
    23302389  /// This function just returns a \ref SectionReader class.
    23312390  /// \relates SectionReader
     2391  /// \sa sectionReader(std::istream& is)
    23322392  inline SectionReader sectionReader(const std::string& fn) {
    23332393    SectionReader tmp(fn);
     
    23392399  /// This function just returns a \ref SectionReader class.
    23402400  /// \relates SectionReader
     2401  /// \sa sectionReader(std::istream& is)
    23412402  inline SectionReader sectionReader(const char* fn) {
    23422403    SectionReader tmp(fn);
  • lemon/lgf_reader.h

    r645 r646  
    593593  public:
    594594
    595     /// \name Reading rules
     595    /// \name Reading Rules
    596596    /// @{
    597597
     
    698698    /// @}
    699699
    700     /// \name Select section by name
     700    /// \name Select Section by Name
    701701    /// @{
    702702
     
    727727    /// @}
    728728
    729     /// \name Using previously constructed node or arc set
     729    /// \name Using Previously Constructed Node or Arc Set
    730730    /// @{
    731731
     
    11161116  public:
    11171117
    1118     /// \name Execution of the reader
     1118    /// \name Execution of the Reader
    11191119    /// @{
    11201120
     
    14161416  public:
    14171417
    1418     /// \name Reading rules
     1418    /// \name Reading Rules
    14191419    /// @{
    14201420
     
    15671567    /// @}
    15681568
    1569     /// \name Select section by name
     1569    /// \name Select Section by Name
    15701570    /// @{
    15711571
     
    15961596    /// @}
    15971597
    1598     /// \name Using previously constructed node or edge set
     1598    /// \name Using Previously Constructed Node or Edge Set
    15991599    /// @{
    16001600
     
    19861986  public:
    19871987
    1988     /// \name Execution of the reader
     1988    /// \name Execution of the Reader
    19891989    /// @{
    19901990
     
    22102210  public:
    22112211
    2212     /// \name Section readers
     2212    /// \name Section Readers
    22132213    /// @{
    22142214
     
    23092309
    23102310
    2311     /// \name Execution of the reader
     2311    /// \name Execution of the Reader
    23122312    /// @{
    23132313
     
    25012501
    25022502
    2503     /// \name Node sections
     2503    /// \name Node Sections
    25042504    /// @{
    25052505
     
    25272527    /// @}
    25282528
    2529     /// \name Arc/Edge sections
     2529    /// \name Arc/Edge Sections
    25302530    /// @{
    25312531
     
    25852585    /// @}
    25862586
    2587     /// \name Attribute sections
     2587    /// \name Attribute Sections
    25882588    /// @{
    25892589
     
    26112611    /// @}
    26122612
    2613     /// \name Extra sections
     2613    /// \name Extra Sections
    26142614    /// @{
    26152615
     
    26872687  public:
    26882688
    2689     /// \name Execution of the contents reader
     2689    /// \name Execution of the Contents Reader
    26902690    /// @{
    26912691
  • lemon/lgf_writer.h

    r631 r646  
    348348  }
    349349
    350   template <typename Digraph>
     350  template <typename DGR>
    351351  class DigraphWriter;
    352352
    353   template <typename Digraph>
    354   DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    355                                        std::ostream& os = std::cout);
    356   template <typename Digraph>
    357   DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    358                                        const std::string& fn);
    359 
    360   template <typename Digraph>
    361   DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    362                                        const char* fn);
     353  template <typename TDGR>
     354  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
     355                                   std::ostream& os = std::cout);
     356  template <typename TDGR>
     357  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const std::string& fn);
     358
     359  template <typename TDGR>
     360  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const char* fn);
    363361
    364362
     
    382380  ///
    383381  ///\code
    384   /// DigraphWriter<Digraph>(digraph, std::cout).
     382  /// DigraphWriter<DGR>(digraph, std::cout).
    385383  ///   nodeMap("coordinates", coord_map).
    386384  ///   nodeMap("size", size).
     
    407405  /// the \c ostream() function, hence the second pass can append its
    408406  /// output to the output of the first pass.
    409   template <typename GR>
     407  template <typename DGR>
    410408  class DigraphWriter {
    411409  public:
    412410
    413     typedef GR Digraph;
    414     TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     411    typedef DGR Digraph;
     412    TEMPLATE_DIGRAPH_TYPEDEFS(DGR);
    415413
    416414  private:
     
    420418    bool local_os;
    421419
    422     const Digraph& _digraph;
     420    const DGR& _digraph;
    423421
    424422    std::string _nodes_caption;
     
    452450    /// Construct a directed graph writer, which writes to the given
    453451    /// output stream.
    454     DigraphWriter(const Digraph& digraph, std::ostream& os = std::cout)
     452    DigraphWriter(const DGR& digraph, std::ostream& os = std::cout)
    455453      : _os(&os), local_os(false), _digraph(digraph),
    456454        _skip_nodes(false), _skip_arcs(false) {}
     
    460458    /// Construct a directed graph writer, which writes to the given
    461459    /// output file.
    462     DigraphWriter(const Digraph& digraph, const std::string& fn)
     460    DigraphWriter(const DGR& digraph, const std::string& fn)
    463461      : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),
    464462        _skip_nodes(false), _skip_arcs(false) {
     
    473471    /// Construct a directed graph writer, which writes to the given
    474472    /// output file.
    475     DigraphWriter(const Digraph& digraph, const char* fn)
     473    DigraphWriter(const DGR& digraph, const char* fn)
    476474      : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),
    477475        _skip_nodes(false), _skip_arcs(false) {
     
    506504  private:
    507505
    508     template <typename DGR>
    509     friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
    510                                             std::ostream& os);
    511     template <typename DGR>
    512     friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
    513                                             const std::string& fn);
    514     template <typename DGR>
    515     friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
    516                                             const char *fn);
     506    template <typename TDGR>
     507    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
     508                                             std::ostream& os);
     509    template <typename TDGR>
     510    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
     511                                             const std::string& fn);
     512    template <typename TDGR>
     513    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
     514                                             const char *fn);
    517515
    518516    DigraphWriter(DigraphWriter& other)
     
    725723
    726724      if (label == 0) {
    727         IdMap<Digraph, Node> id_map(_digraph);
    728         _writer_bits::MapLess<IdMap<Digraph, Node> > id_less(id_map);
     725        IdMap<DGR, Node> id_map(_digraph);
     726        _writer_bits::MapLess<IdMap<DGR, Node> > id_less(id_map);
    729727        std::sort(nodes.begin(), nodes.end(), id_less);
    730728      } else {
     
    810808
    811809      if (label == 0) {
    812         IdMap<Digraph, Arc> id_map(_digraph);
    813         _writer_bits::MapLess<IdMap<Digraph, Arc> > id_less(id_map);
     810        IdMap<DGR, Arc> id_map(_digraph);
     811        _writer_bits::MapLess<IdMap<DGR, Arc> > id_less(id_map);
    814812        std::sort(arcs.begin(), arcs.end(), id_less);
    815813      } else {
     
    916914  };
    917915
     916  /// \ingroup lemon_io
     917  ///
     918  /// \brief Return a \ref DigraphWriter class
     919  ///
     920  /// This function just returns a \ref DigraphWriter class.
     921  ///
     922  /// With this function a digraph can be write to a file or output
     923  /// stream in \ref lgf-format "LGF" format with several maps and
     924  /// attributes. For example, with the following code a network flow
     925  /// problem can be written to the standard output, i.e. a digraph
     926  /// with a \e capacity map on the arcs and \e source and \e target
     927  /// nodes:
     928  ///
     929  ///\code
     930  ///ListDigraph digraph;
     931  ///ListDigraph::ArcMap<int> cap(digraph);
     932  ///ListDigraph::Node src, trg;
     933  ///  // Setting the capacity map and source and target nodes
     934  ///digraphWriter(digraph, std::cout).
     935  ///  arcMap("capacity", cap).
     936  ///  node("source", src).
     937  ///  node("target", trg).
     938  ///  run();
     939  ///\endcode
     940  ///
     941  /// For a complete documentation, please see the \ref DigraphWriter
     942  /// class documentation.
     943  /// \warning Don't forget to put the \ref DigraphWriter::run() "run()"
     944  /// to the end of the parameter list.
     945  /// \relates DigraphWriter
     946  /// \sa digraphWriter(const TDGR& digraph, const std::string& fn)
     947  /// \sa digraphWriter(const TDGR& digraph, const char* fn)
     948  template <typename TDGR>
     949  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, std::ostream& os) {
     950    DigraphWriter<TDGR> tmp(digraph, os);
     951    return tmp;
     952  }
     953
    918954  /// \brief Return a \ref DigraphWriter class
    919955  ///
    920956  /// This function just returns a \ref DigraphWriter class.
    921957  /// \relates DigraphWriter
    922   template <typename Digraph>
    923   DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    924                                        std::ostream& os) {
    925     DigraphWriter<Digraph> tmp(digraph, os);
     958  /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
     959  template <typename TDGR>
     960  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
     961                                    const std::string& fn) {
     962    DigraphWriter<TDGR> tmp(digraph, fn);
    926963    return tmp;
    927964  }
     
    931968  /// This function just returns a \ref DigraphWriter class.
    932969  /// \relates DigraphWriter
    933   template <typename Digraph>
    934   DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    935                                        const std::string& fn) {
    936     DigraphWriter<Digraph> tmp(digraph, fn);
     970  /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
     971  template <typename TDGR>
     972  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const char* fn) {
     973    DigraphWriter<TDGR> tmp(digraph, fn);
    937974    return tmp;
    938975  }
    939976
    940   /// \brief Return a \ref DigraphWriter class
    941   ///
    942   /// This function just returns a \ref DigraphWriter class.
    943   /// \relates DigraphWriter
    944   template <typename Digraph>
    945   DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
    946                                        const char* fn) {
    947     DigraphWriter<Digraph> tmp(digraph, fn);
    948     return tmp;
    949   }
    950 
    951   template <typename Graph>
     977  template <typename GR>
    952978  class GraphWriter;
    953979
    954   template <typename Graph>
    955   GraphWriter<Graph> graphWriter(const Graph& graph,
    956                                  std::ostream& os = std::cout);
    957   template <typename Graph>
    958   GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn);
    959   template <typename Graph>
    960   GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn);
     980  template <typename TGR>
     981  GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os = std::cout);
     982  template <typename TGR>
     983  GraphWriter<TGR> graphWriter(const TGR& graph, const std::string& fn);
     984  template <typename TGR>
     985  GraphWriter<TGR> graphWriter(const TGR& graph, const char* fn);
    961986
    962987  /// \ingroup lemon_io
     
    9801005
    9811006    typedef GR Graph;
    982     TEMPLATE_GRAPH_TYPEDEFS(Graph);
     1007    TEMPLATE_GRAPH_TYPEDEFS(GR);
    9831008
    9841009  private:
     
    9881013    bool local_os;
    9891014
    990     const Graph& _graph;
     1015    const GR& _graph;
    9911016
    9921017    std::string _nodes_caption;
     
    10201045    /// Construct a directed graph writer, which writes to the given
    10211046    /// output stream.
    1022     GraphWriter(const Graph& graph, std::ostream& os = std::cout)
     1047    GraphWriter(const GR& graph, std::ostream& os = std::cout)
    10231048      : _os(&os), local_os(false), _graph(graph),
    10241049        _skip_nodes(false), _skip_edges(false) {}
     
    10281053    /// Construct a directed graph writer, which writes to the given
    10291054    /// output file.
    1030     GraphWriter(const Graph& graph, const std::string& fn)
     1055    GraphWriter(const GR& graph, const std::string& fn)
    10311056      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
    10321057        _skip_nodes(false), _skip_edges(false) {
     
    10411066    /// Construct a directed graph writer, which writes to the given
    10421067    /// output file.
    1043     GraphWriter(const Graph& graph, const char* fn)
     1068    GraphWriter(const GR& graph, const char* fn)
    10441069      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
    10451070        _skip_nodes(false), _skip_edges(false) {
     
    10741099  private:
    10751100
    1076     template <typename Graph>
    1077     friend GraphWriter<Graph> graphWriter(const Graph& graph,
    1078                                           std::ostream& os);
    1079     template <typename Graph>
    1080     friend GraphWriter<Graph> graphWriter(const Graph& graph,
    1081                                           const std::string& fn);
    1082     template <typename Graph>
    1083     friend GraphWriter<Graph> graphWriter(const Graph& graph,
    1084                                           const char *fn);
     1101    template <typename TGR>
     1102    friend GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os);
     1103    template <typename TGR>
     1104    friend GraphWriter<TGR> graphWriter(const TGR& graph,
     1105                                        const std::string& fn);
     1106    template <typename TGR>
     1107    friend GraphWriter<TGR> graphWriter(const TGR& graph, const char *fn);
    10851108   
    10861109    GraphWriter(GraphWriter& other)
     
    11691192      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
    11701193      _writer_bits::MapStorageBase<Edge>* forward_storage =
    1171         new _writer_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
     1194        new _writer_bits::GraphArcMapStorage<GR, true, Map>(_graph, map);
    11721195      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
    11731196      _writer_bits::MapStorageBase<Edge>* backward_storage =
    1174         new _writer_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
     1197        new _writer_bits::GraphArcMapStorage<GR, false, Map>(_graph, map);
    11751198      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
    11761199      return *this;
     
    11861209      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
    11871210      _writer_bits::MapStorageBase<Edge>* forward_storage =
    1188         new _writer_bits::GraphArcMapStorage<Graph, true, Map, Converter>
     1211        new _writer_bits::GraphArcMapStorage<GR, true, Map, Converter>
    11891212        (_graph, map, converter);
    11901213      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
    11911214      _writer_bits::MapStorageBase<Edge>* backward_storage =
    1192         new _writer_bits::GraphArcMapStorage<Graph, false, Map, Converter>
     1215        new _writer_bits::GraphArcMapStorage<GR, false, Map, Converter>
    11931216        (_graph, map, converter);
    11941217      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
     
    12481271    /// Add an arc writing rule to writer.
    12491272    GraphWriter& arc(const std::string& caption, const Arc& arc) {
    1250       typedef _writer_bits::GraphArcLookUpConverter<Graph> Converter;
     1273      typedef _writer_bits::GraphArcLookUpConverter<GR> Converter;
    12511274      Converter converter(_graph, _edge_index);
    12521275      _writer_bits::ValueStorageBase* storage =
     
    13391362
    13401363      if (label == 0) {
    1341         IdMap<Graph, Node> id_map(_graph);
    1342         _writer_bits::MapLess<IdMap<Graph, Node> > id_less(id_map);
     1364        IdMap<GR, Node> id_map(_graph);
     1365        _writer_bits::MapLess<IdMap<GR, Node> > id_less(id_map);
    13431366        std::sort(nodes.begin(), nodes.end(), id_less);
    13441367      } else {
     
    14241447
    14251448      if (label == 0) {
    1426         IdMap<Graph, Edge> id_map(_graph);
    1427         _writer_bits::MapLess<IdMap<Graph, Edge> > id_less(id_map);
     1449        IdMap<GR, Edge> id_map(_graph);
     1450        _writer_bits::MapLess<IdMap<GR, Edge> > id_less(id_map);
    14281451        std::sort(edges.begin(), edges.end(), id_less);
    14291452      } else {
     
    15301553  };
    15311554
     1555  /// \ingroup lemon_io
     1556  ///
     1557  /// \brief Return a \ref GraphWriter class
     1558  ///
     1559  /// This function just returns a \ref GraphWriter class.
     1560  ///
     1561  /// With this function a graph can be write to a file or output
     1562  /// stream in \ref lgf-format "LGF" format with several maps and
     1563  /// attributes. For example, with the following code a weighted
     1564  /// matching problem can be written to the standard output, i.e. a
     1565  /// graph with a \e weight map on the edges:
     1566  ///
     1567  ///\code
     1568  ///ListGraph graph;
     1569  ///ListGraph::EdgeMap<int> weight(graph);
     1570  ///  // Setting the weight map
     1571  ///graphWriter(graph, std::cout).
     1572  ///  edgeMap("weight", weight).
     1573  ///  run();
     1574  ///\endcode
     1575  ///
     1576  /// For a complete documentation, please see the \ref GraphWriter
     1577  /// class documentation.
     1578  /// \warning Don't forget to put the \ref GraphWriter::run() "run()"
     1579  /// to the end of the parameter list.
     1580  /// \relates GraphWriter
     1581  /// \sa graphWriter(const TGR& graph, const std::string& fn)
     1582  /// \sa graphWriter(const TGR& graph, const char* fn)
     1583  template <typename TGR>
     1584  GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os) {
     1585    GraphWriter<TGR> tmp(graph, os);
     1586    return tmp;
     1587  }
     1588
    15321589  /// \brief Return a \ref GraphWriter class
    15331590  ///
    15341591  /// This function just returns a \ref GraphWriter class.
    15351592  /// \relates GraphWriter
    1536   template <typename Graph>
    1537   GraphWriter<Graph> graphWriter(const Graph& graph,
    1538                                  std::ostream& os) {
    1539     GraphWriter<Graph> tmp(graph, os);
     1593  /// \sa graphWriter(const TGR& graph, std::ostream& os)
     1594  template <typename TGR>
     1595  GraphWriter<TGR> graphWriter(const TGR& graph, const std::string& fn) {
     1596    GraphWriter<TGR> tmp(graph, fn);
    15401597    return tmp;
    15411598  }
     
    15451602  /// This function just returns a \ref GraphWriter class.
    15461603  /// \relates GraphWriter
    1547   template <typename Graph>
    1548   GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
    1549     GraphWriter<Graph> tmp(graph, fn);
    1550     return tmp;
    1551   }
    1552 
    1553   /// \brief Return a \ref GraphWriter class
    1554   ///
    1555   /// This function just returns a \ref GraphWriter class.
    1556   /// \relates GraphWriter
    1557   template <typename Graph>
    1558   GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
    1559     GraphWriter<Graph> tmp(graph, fn);
     1604  /// \sa graphWriter(const TGR& graph, std::ostream& os)
     1605  template <typename TGR>
     1606  GraphWriter<TGR> graphWriter(const TGR& graph, const char* fn) {
     1607    GraphWriter<TGR> tmp(graph, fn);
    15601608    return tmp;
    15611609  }
     
    17471795  };
    17481796
     1797  /// \ingroup lemon_io
     1798  ///
    17491799  /// \brief Return a \ref SectionWriter class
    17501800  ///
    17511801  /// This function just returns a \ref SectionWriter class.
     1802  ///
     1803  /// Please see SectionWriter documentation about the custom section
     1804  /// output.
     1805  ///
    17521806  /// \relates SectionWriter
     1807  /// \sa sectionWriter(const std::string& fn)
     1808  /// \sa sectionWriter(const char *fn)
    17531809  inline SectionWriter sectionWriter(std::ostream& os) {
    17541810    SectionWriter tmp(os);
     
    17601816  /// This function just returns a \ref SectionWriter class.
    17611817  /// \relates SectionWriter
     1818  /// \sa sectionWriter(std::ostream& os)
    17621819  inline SectionWriter sectionWriter(const std::string& fn) {
    17631820    SectionWriter tmp(fn);
     
    17691826  /// This function just returns a \ref SectionWriter class.
    17701827  /// \relates SectionWriter
     1828  /// \sa sectionWriter(std::ostream& os)
    17711829  inline SectionWriter sectionWriter(const char* fn) {
    17721830    SectionWriter tmp(fn);
  • lemon/lgf_writer.h

    r645 r646  
    537537  public:
    538538
    539     /// \name Writing rules
     539    /// \name Writing Rules
    540540    /// @{
    541541
     
    640640    }
    641641
    642     /// \name Section captions
     642    /// \name Section Captions
    643643    /// @{
    644644
     
    667667    }
    668668
    669     /// \name Skipping section
     669    /// \name Skipping Section
    670670    /// @{
    671671
     
    884884  public:
    885885
    886     /// \name Execution of the writer
     886    /// \name Execution of the Writer
    887887    /// @{
    888888
     
    11301130  public:
    11311131
    1132     /// \name Writing rules
     1132    /// \name Writing Rules
    11331133    /// @{
    11341134
     
    12791279    }
    12801280
    1281     /// \name Section captions
     1281    /// \name Section Captions
    12821282    /// @{
    12831283
     
    13061306    }
    13071307
    1308     /// \name Skipping section
     1308    /// \name Skipping Section
    13091309    /// @{
    13101310
     
    15231523  public:
    15241524
    1525     /// \name Execution of the writer
     1525    /// \name Execution of the Writer
    15261526    /// @{
    15271527
     
    17001700  public:
    17011701
    1702     /// \name Section writers
     1702    /// \name Section Writers
    17031703    /// @{
    17041704
     
    17671767
    17681768
    1769     /// \name Execution of the writer
     1769    /// \name Execution of the Writer
    17701770    /// @{
    17711771
Note: See TracChangeset for help on using the changeset viewer.