COIN-OR::LEMON - Graph Library

Ticket #91: 1e6af6f0843c.patch

File 1e6af6f0843c.patch, 16.8 KB (added by Balazs Dezso, 12 years ago)
  • lemon/lgf_reader.h

    # HG changeset patch
    # User Balazs Dezso <deba@inf.elte.hu>
    # Date 1215180751 -7200
    # Node ID 1e6af6f0843c373a0579fc699ac4a83bb4f5948a
    # Parent  a63ed81c57babfd26265bcf154436fb8600c13c3
    Move to private copy constrcutors
    
    diff -r a63ed81c57ba -r 1e6af6f0843c lemon/lgf_reader.h
    a b  
    386386   
    387387  }
    388388
     389  template <typename Digraph>
     390  class DigraphReader;
     391
     392  template <typename Digraph>
     393  DigraphReader<Digraph> digraphReader(std::istream& is, Digraph& digraph);
     394
     395  template <typename Digraph>
     396  DigraphReader<Digraph> digraphReader(const std::string& fn, Digraph& digraph);
     397
     398  template <typename Digraph>
     399  DigraphReader<Digraph> digraphReader(const char *fn, Digraph& digraph);
     400
    389401  /// \ingroup lemon_io
    390402  /// 
    391403  /// \brief LGF reader for directed graphs
     
    509521        _use_nodes(false), _use_arcs(false),
    510522        _skip_nodes(false), _skip_arcs(false) {}
    511523
    512     /// \brief Copy constructor
    513     ///
    514     /// The copy constructor transfers all data from the other reader,
    515     /// therefore the copied reader will not be usable more.
    516     DigraphReader(DigraphReader& other)
    517       : _is(other._is), local_is(other.local_is), _digraph(other._digraph),
    518         _use_nodes(other._use_nodes), _use_arcs(other._use_arcs),
    519         _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
    520 
    521       other._is = 0;
    522       other.local_is = false;
    523      
    524       _node_index.swap(other._node_index);
    525       _arc_index.swap(other._arc_index);
    526 
    527       _node_maps.swap(other._node_maps);
    528       _arc_maps.swap(other._arc_maps);
    529       _attributes.swap(other._attributes);
    530 
    531       _nodes_caption = other._nodes_caption;
    532       _arcs_caption = other._arcs_caption;
    533       _attributes_caption = other._attributes_caption;
    534 
    535     }
    536 
    537524    /// \brief Destructor
    538525    ~DigraphReader() {
    539526      for (typename NodeMaps::iterator it = _node_maps.begin();
     
    558545    }
    559546
    560547  private:
    561    
     548
     549    friend DigraphReader<Digraph> digraphReader<>(std::istream& is,
     550                                                  Digraph& digraph);   
     551    friend DigraphReader<Digraph> digraphReader<>(const std::string& fn,
     552                                                  Digraph& digraph);   
     553    friend DigraphReader<Digraph> digraphReader<>(const char *fn,
     554                                                  Digraph& digraph);   
     555
     556    DigraphReader(DigraphReader& other)
     557      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),
     558        _use_nodes(other._use_nodes), _use_arcs(other._use_arcs),
     559        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
     560
     561      other._is = 0;
     562      other.local_is = false;
     563     
     564      _node_index.swap(other._node_index);
     565      _arc_index.swap(other._arc_index);
     566
     567      _node_maps.swap(other._node_maps);
     568      _arc_maps.swap(other._arc_maps);
     569      _attributes.swap(other._attributes);
     570
     571      _nodes_caption = other._nodes_caption;
     572      _arcs_caption = other._arcs_caption;
     573      _attributes_caption = other._attributes_caption;
     574
     575    }
     576
    562577    DigraphReader& operator=(const DigraphReader&);
    563578
    564579  public:
     
    11821197    return tmp;
    11831198  }
    11841199
     1200  template <typename Graph>
     1201  class GraphReader;
     1202
     1203  template <typename Graph>
     1204  GraphReader<Graph> graphReader(std::istream& is, Graph& graph);   
     1205
     1206  template <typename Graph>
     1207  GraphReader<Graph> graphReader(const std::string& fn, Graph& graph);   
     1208
     1209  template <typename Graph>
     1210  GraphReader<Graph> graphReader(const char *fn, Graph& graph);   
     1211
    11851212  /// \ingroup lemon_io
    11861213  /// 
    11871214  /// \brief LGF reader for undirected graphs
     
    12601287        _use_nodes(false), _use_edges(false),
    12611288        _skip_nodes(false), _skip_edges(false) {}
    12621289
    1263     /// \brief Copy constructor
    1264     ///
    1265     /// The copy constructor transfers all data from the other reader,
    1266     /// therefore the copied reader will not be usable more.
    1267     GraphReader(GraphReader& other)
    1268       : _is(other._is), local_is(other.local_is), _graph(other._graph),
    1269         _use_nodes(other._use_nodes), _use_edges(other._use_edges),
    1270         _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
    1271 
    1272       other._is = 0;
    1273       other.local_is = false;
    1274      
    1275       _node_index.swap(other._node_index);
    1276       _edge_index.swap(other._edge_index);
    1277 
    1278       _node_maps.swap(other._node_maps);
    1279       _edge_maps.swap(other._edge_maps);
    1280       _attributes.swap(other._attributes);
    1281 
    1282       _nodes_caption = other._nodes_caption;
    1283       _edges_caption = other._edges_caption;
    1284       _attributes_caption = other._attributes_caption;
    1285 
    1286     }
    1287 
    12881290    /// \brief Destructor
    12891291    ~GraphReader() {
    12901292      for (typename NodeMaps::iterator it = _node_maps.begin();
     
    13091311    }
    13101312
    13111313  private:
    1312    
     1314    friend GraphReader<Graph> graphReader<>(std::istream& is, Graph& graph);   
     1315    friend GraphReader<Graph> graphReader<>(const std::string& fn,
     1316                                            Graph& graph);   
     1317    friend GraphReader<Graph> graphReader<>(const char *fn, Graph& graph);   
     1318
     1319    GraphReader(GraphReader& other)
     1320      : _is(other._is), local_is(other.local_is), _graph(other._graph),
     1321        _use_nodes(other._use_nodes), _use_edges(other._use_edges),
     1322        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
     1323
     1324      other._is = 0;
     1325      other.local_is = false;
     1326     
     1327      _node_index.swap(other._node_index);
     1328      _edge_index.swap(other._edge_index);
     1329
     1330      _node_maps.swap(other._node_maps);
     1331      _edge_maps.swap(other._edge_maps);
     1332      _attributes.swap(other._attributes);
     1333
     1334      _nodes_caption = other._nodes_caption;
     1335      _edges_caption = other._edges_caption;
     1336      _attributes_caption = other._attributes_caption;
     1337
     1338    }
     1339
    13131340    GraphReader& operator=(const GraphReader&);
    13141341
    13151342  public:
     
    19772004    return tmp;
    19782005  }
    19792006
     2007  class SectionReader;
     2008
     2009  SectionReader sectionReader(std::istream& is);
     2010  SectionReader sectionReader(const std::string& fn);
     2011  SectionReader sectionReader(const char* fn);
     2012 
    19802013  /// \brief Section reader class
    19812014  ///
    19822015  /// In the \e LGF file extra sections can be placed, which contain
     
    20192052    SectionReader(const char* fn)
    20202053      : _is(new std::ifstream(fn)), local_is(true) {}
    20212054
    2022     /// \brief Copy constructor
    2023     ///
    2024     /// The copy constructor transfers all data from the other reader,
    2025     /// therefore the copied reader will not be usable more.
    2026     SectionReader(SectionReader& other)
    2027       : _is(other._is), local_is(other.local_is) {
    2028 
    2029       other._is = 0;
    2030       other.local_is = false;
    2031      
    2032       _sections.swap(other._sections);
    2033     }
    2034 
    20352055    /// \brief Destructor
    20362056    ~SectionReader() {
    20372057      for (Sections::iterator it = _sections.begin();
     
    20462066    }
    20472067
    20482068  private:
     2069
     2070    friend SectionReader sectionReader(std::istream& is);
     2071    friend SectionReader sectionReader(const std::string& fn);
     2072    friend SectionReader sectionReader(const char* fn);
     2073
     2074    SectionReader(SectionReader& other)
     2075      : _is(other._is), local_is(other.local_is) {
     2076
     2077      other._is = 0;
     2078      other.local_is = false;
     2079     
     2080      _sections.swap(other._sections);
     2081    }
    20492082   
    20502083    SectionReader& operator=(const SectionReader&);
    20512084
     
    22952328    /// file.
    22962329    LgfContents(const char* fn)
    22972330      : _is(new std::ifstream(fn)), local_is(true) {}
    2298 
    2299     /// \brief Copy constructor
    2300     ///
    2301     /// The copy constructor transfers all data from the other reader,
    2302     /// therefore the copied reader will not be usable more.
    2303     LgfContents(LgfContents& other)
    2304       : _is(other._is), local_is(other.local_is) {
    2305      
    2306       other._is = 0;
    2307       other.local_is = false;
    2308      
    2309       _node_sections.swap(other._node_sections);
    2310       _edge_sections.swap(other._edge_sections);
    2311       _attribute_sections.swap(other._attribute_sections);
    2312       _extra_sections.swap(other._extra_sections);
    2313 
    2314       _arc_sections.swap(other._arc_sections);
    2315 
    2316       _node_maps.swap(other._node_maps);
    2317       _edge_maps.swap(other._edge_maps);
    2318       _attributes.swap(other._attributes);
    2319     }
    23202331   
    23212332    /// \brief Destructor
    23222333    ~LgfContents() {
    23232334      if (local_is) delete _is;
    23242335    }
     2336
     2337  private:
     2338   
     2339    LgfContents(const LgfContents&);
     2340    LgfContents& operator=(const LgfContents&);
     2341
     2342  public:
    23252343
    23262344
    23272345    /// \name Node sections
  • lemon/lgf_writer.h

    diff -r a63ed81c57ba -r 1e6af6f0843c lemon/lgf_writer.h
    a b  
    304304    }
    305305
    306306  }
     307
     308  template <typename Digraph>
     309  class DigraphWriter;
     310
     311  template <typename Digraph>
     312  DigraphWriter<Digraph> digraphWriter(std::ostream& os,
     313                                       const Digraph& digraph);
     314
     315  template <typename Digraph>
     316  DigraphWriter<Digraph> digraphWriter(const std::string& fn,
     317                                       const Digraph& digraph);
     318
     319  template <typename Digraph>
     320  DigraphWriter<Digraph> digraphWriter(const char *fn,
     321                                       const Digraph& digraph);
    307322 
    308323  /// \ingroup lemon_io
    309324  /// 
     
    362377    std::ostream* _os;
    363378    bool local_os;
    364379
    365     Digraph& _digraph;
     380    const Digraph& _digraph;
    366381
    367382    std::string _nodes_caption;
    368383    std::string _arcs_caption;
     
    394409    ///
    395410    /// Construct a directed graph writer, which writes to the given
    396411    /// output stream.
    397     DigraphWriter(std::ostream& is, Digraph& digraph)
     412    DigraphWriter(std::ostream& is, const Digraph& digraph)
    398413      : _os(&is), local_os(false), _digraph(digraph),
    399414        _skip_nodes(false), _skip_arcs(false) {}
    400415
     
    402417    ///
    403418    /// Construct a directed graph writer, which writes to the given
    404419    /// output file.
    405     DigraphWriter(const std::string& fn, Digraph& digraph)
     420    DigraphWriter(const std::string& fn, const Digraph& digraph)
    406421      : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),
    407422        _skip_nodes(false), _skip_arcs(false) {}
    408423
     
    410425    ///
    411426    /// Construct a directed graph writer, which writes to the given
    412427    /// output file.
    413     DigraphWriter(const char* fn, Digraph& digraph)
     428    DigraphWriter(const char* fn, const Digraph& digraph)
    414429      : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),
    415430        _skip_nodes(false), _skip_arcs(false) {}
    416 
    417     /// \brief Copy constructor
    418     ///
    419     /// The copy constructor transfers all data from the other writer,
    420     /// therefore the copied writer will not be usable more.
    421     DigraphWriter(DigraphWriter& other)
    422       : _os(other._os), local_os(other.local_os), _digraph(other._digraph),
    423         _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
    424 
    425       other._os = 0;
    426       other.local_os = false;
    427 
    428       _node_index.swap(other._node_index);
    429       _arc_index.swap(other._arc_index);
    430 
    431       _node_maps.swap(other._node_maps);
    432       _arc_maps.swap(other._arc_maps);
    433       _attributes.swap(other._attributes);
    434 
    435       _nodes_caption = other._nodes_caption;
    436       _arcs_caption = other._arcs_caption;
    437       _attributes_caption = other._attributes_caption;
    438     }
    439431
    440432    /// \brief Destructor
    441433    ~DigraphWriter() {
     
    460452    }
    461453
    462454  private:
     455
     456    friend DigraphWriter<Digraph> digraphWriter<>(std::ostream& os,
     457                                                  const Digraph& digraph);
     458    friend DigraphWriter<Digraph> digraphWriter<>(const std::string& fn,
     459                                                  const Digraph& digraph);   
     460    friend DigraphWriter<Digraph> digraphWriter<>(const char *fn,
     461                                                  const Digraph& digraph);
     462
     463    DigraphWriter(DigraphWriter& other)
     464      : _os(other._os), local_os(other.local_os), _digraph(other._digraph),
     465        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
     466
     467      other._os = 0;
     468      other.local_os = false;
     469
     470      _node_index.swap(other._node_index);
     471      _arc_index.swap(other._arc_index);
     472
     473      _node_maps.swap(other._node_maps);
     474      _arc_maps.swap(other._arc_maps);
     475      _attributes.swap(other._attributes);
     476
     477      _nodes_caption = other._nodes_caption;
     478      _arcs_caption = other._arcs_caption;
     479      _attributes_caption = other._attributes_caption;
     480    }
    463481   
    464482    DigraphWriter& operator=(const DigraphWriter&);
    465483
     
    844862
    845863  /// \relates DigraphWriter
    846864  template <typename Digraph>
    847   DigraphWriter<Digraph> digraphWriter(std::ostream& os, Digraph& digraph) {
     865  DigraphWriter<Digraph> digraphWriter(std::ostream& os,
     866                                       const Digraph& digraph) {
    848867    DigraphWriter<Digraph> tmp(os, digraph);
    849868    return tmp;
    850869  }
     
    852871  /// \relates DigraphWriter
    853872  template <typename Digraph>
    854873  DigraphWriter<Digraph> digraphWriter(const std::string& fn,
    855                                        Digraph& digraph) {
     874                                       const Digraph& digraph) {
    856875    DigraphWriter<Digraph> tmp(fn, digraph);
    857876    return tmp;
    858877  }
    859878
    860879  /// \relates DigraphWriter
    861880  template <typename Digraph>
    862   DigraphWriter<Digraph> digraphWriter(const char* fn, Digraph& digraph) {
     881  DigraphWriter<Digraph> digraphWriter(const char* fn,
     882                                       const Digraph& digraph) {
    863883    DigraphWriter<Digraph> tmp(fn, digraph);
    864884    return tmp;
    865885  }
     886
     887  template <typename Graph>
     888  class GraphWriter;
     889
     890  template <typename Graph>
     891  GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph);   
     892
     893  template <typename Graph>
     894  GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph);   
     895
     896  template <typename Graph>
     897  GraphWriter<Graph> graphWriter(const char *fn, const Graph& graph);   
    866898
    867899  /// \ingroup lemon_io
    868900  /// 
     
    914946    ///
    915947    /// Construct a directed graph writer, which writes to the given
    916948    /// output stream.
    917     GraphWriter(std::ostream& is, Graph& graph)
     949    GraphWriter(std::ostream& is, const Graph& graph)
    918950      : _os(&is), local_os(false), _graph(graph),
    919951        _skip_nodes(false), _skip_edges(false) {}
    920952
     
    922954    ///
    923955    /// Construct a directed graph writer, which writes to the given
    924956    /// output file.
    925     GraphWriter(const std::string& fn, Graph& graph)
     957    GraphWriter(const std::string& fn, const Graph& graph)
    926958      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
    927959        _skip_nodes(false), _skip_edges(false) {}
    928960
     
    930962    ///
    931963    /// Construct a directed graph writer, which writes to the given
    932964    /// output file.
    933     GraphWriter(const char* fn, Graph& graph)
     965    GraphWriter(const char* fn, const Graph& graph)
    934966      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
    935967        _skip_nodes(false), _skip_edges(false) {}
    936 
    937     /// \brief Copy constructor
    938     ///
    939     /// The copy constructor transfers all data from the other writer,
    940     /// therefore the copied writer will not be usable more.
    941     GraphWriter(GraphWriter& other)
    942       : _os(other._os), local_os(other.local_os), _graph(other._graph),
    943         _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
    944 
    945       other._os = 0;
    946       other.local_os = false;
    947 
    948       _node_index.swap(other._node_index);
    949       _edge_index.swap(other._edge_index);
    950 
    951       _node_maps.swap(other._node_maps);
    952       _edge_maps.swap(other._edge_maps);
    953       _attributes.swap(other._attributes);
    954 
    955       _nodes_caption = other._nodes_caption;
    956       _edges_caption = other._edges_caption;
    957       _attributes_caption = other._attributes_caption;
    958     }
    959968
    960969    /// \brief Destructor
    961970    ~GraphWriter() {
     
    978987        delete _os;
    979988      }
    980989    }
     990   
     991  private:
    981992
    982   private:
    983    
     993    friend GraphWriter<Graph> graphWriter<>(std::ostream& os,
     994                                            const Graph& graph);   
     995    friend GraphWriter<Graph> graphWriter<>(const std::string& fn,
     996                                            const Graph& graph);   
     997    friend GraphWriter<Graph> graphWriter<>(const char *fn,
     998                                            const Graph& graph);   
     999
     1000    GraphWriter(GraphWriter& other)
     1001      : _os(other._os), local_os(other.local_os), _graph(other._graph),
     1002        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
     1003
     1004      other._os = 0;
     1005      other.local_os = false;
     1006
     1007      _node_index.swap(other._node_index);
     1008      _edge_index.swap(other._edge_index);
     1009
     1010      _node_maps.swap(other._node_maps);
     1011      _edge_maps.swap(other._edge_maps);
     1012      _attributes.swap(other._attributes);
     1013
     1014      _nodes_caption = other._nodes_caption;
     1015      _edges_caption = other._edges_caption;
     1016      _attributes_caption = other._attributes_caption;
     1017    }
     1018
    9841019    GraphWriter& operator=(const GraphWriter&);
    9851020
    9861021  public:
     
    14101445
    14111446  /// \relates GraphWriter
    14121447  template <typename Graph>
    1413   GraphWriter<Graph> graphWriter(std::ostream& os, Graph& graph) {
     1448  GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph) {
    14141449    GraphWriter<Graph> tmp(os, graph);
    14151450    return tmp;
    14161451  }
    14171452
    14181453  /// \relates GraphWriter
    14191454  template <typename Graph>
    1420   GraphWriter<Graph> graphWriter(const std::string& fn, Graph& graph) {
     1455  GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph) {
    14211456    GraphWriter<Graph> tmp(fn, graph);
    14221457    return tmp;
    14231458  }
    14241459
    14251460  /// \relates GraphWriter
    14261461  template <typename Graph>
    1427   GraphWriter<Graph> graphWriter(const char* fn, Graph& graph) {
     1462  GraphWriter<Graph> graphWriter(const char* fn, const Graph& graph) {
    14281463    GraphWriter<Graph> tmp(fn, graph);
    14291464    return tmp;
    14301465  }