COIN-OR::LEMON - Graph Library

Changeset 190:1e6af6f0843c in lemon-1.2 for lemon


Ignore:
Timestamp:
07/04/08 16:12:31 (11 years ago)
Author:
Balazs Dezso <deba@…>
Branch:
default
Children:
191:abc5b9d0c67e, 192:7bf5f97d574f, 206:4e22275a2b52
Phase:
public
Message:

Move to private copy constrcutors

Location:
lemon
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • lemon/lgf_reader.h

    r189 r190  
    386386   
    387387  }
     388
     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);
    388400
    389401  /// \ingroup lemon_io
     
    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.
     524    /// \brief Destructor
     525    ~DigraphReader() {
     526      for (typename NodeMaps::iterator it = _node_maps.begin();
     527           it != _node_maps.end(); ++it) {
     528        delete it->second;
     529      }
     530
     531      for (typename ArcMaps::iterator it = _arc_maps.begin();
     532           it != _arc_maps.end(); ++it) {
     533        delete it->second;
     534      }
     535
     536      for (typename Attributes::iterator it = _attributes.begin();
     537           it != _attributes.end(); ++it) {
     538        delete it->second;
     539      }
     540
     541      if (local_is) {
     542        delete _is;
     543      }
     544
     545    }
     546
     547  private:
     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
    516556    DigraphReader(DigraphReader& other)
    517557      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),
     
    535575    }
    536576
    537     /// \brief Destructor
    538     ~DigraphReader() {
    539       for (typename NodeMaps::iterator it = _node_maps.begin();
    540            it != _node_maps.end(); ++it) {
    541         delete it->second;
    542       }
    543 
    544       for (typename ArcMaps::iterator it = _arc_maps.begin();
    545            it != _arc_maps.end(); ++it) {
    546         delete it->second;
    547       }
    548 
    549       for (typename Attributes::iterator it = _attributes.begin();
    550            it != _attributes.end(); ++it) {
    551         delete it->second;
    552       }
    553 
    554       if (local_is) {
    555         delete _is;
    556       }
    557 
    558     }
    559 
    560   private:
    561    
    562577    DigraphReader& operator=(const DigraphReader&);
    563578
     
    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  /// 
     
    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.
     1290    /// \brief Destructor
     1291    ~GraphReader() {
     1292      for (typename NodeMaps::iterator it = _node_maps.begin();
     1293           it != _node_maps.end(); ++it) {
     1294        delete it->second;
     1295      }
     1296
     1297      for (typename EdgeMaps::iterator it = _edge_maps.begin();
     1298           it != _edge_maps.end(); ++it) {
     1299        delete it->second;
     1300      }
     1301
     1302      for (typename Attributes::iterator it = _attributes.begin();
     1303           it != _attributes.end(); ++it) {
     1304        delete it->second;
     1305      }
     1306
     1307      if (local_is) {
     1308        delete _is;
     1309      }
     1310
     1311    }
     1312
     1313  private:
     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
    12671319    GraphReader(GraphReader& other)
    12681320      : _is(other._is), local_is(other.local_is), _graph(other._graph),
     
    12861338    }
    12871339
    1288     /// \brief Destructor
    1289     ~GraphReader() {
    1290       for (typename NodeMaps::iterator it = _node_maps.begin();
    1291            it != _node_maps.end(); ++it) {
    1292         delete it->second;
    1293       }
    1294 
    1295       for (typename EdgeMaps::iterator it = _edge_maps.begin();
    1296            it != _edge_maps.end(); ++it) {
    1297         delete it->second;
    1298       }
    1299 
    1300       for (typename Attributes::iterator it = _attributes.begin();
    1301            it != _attributes.end(); ++it) {
    1302         delete it->second;
    1303       }
    1304 
    1305       if (local_is) {
    1306         delete _is;
    1307       }
    1308 
    1309     }
    1310 
    1311   private:
    1312    
    13131340    GraphReader& operator=(const GraphReader&);
    13141341
     
    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  ///
     
    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() {
     
    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&);
     
    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
     
    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
  • lemon/lgf_writer.h

    r185 r190  
    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
     
    363378    bool local_os;
    364379
    365     Digraph& _digraph;
     380    const Digraph& _digraph;
    366381
    367382    std::string _nodes_caption;
     
    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) {}
     
    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) {}
     
    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
     
    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&);
     
    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;
     
    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;
     
    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
     
    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) {}
     
    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) {}
     
    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
     
    979988      }
    980989    }
    981 
     990   
    982991  private:
    983    
     992
     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
     
    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;
     
    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;
     
    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;
Note: See TracChangeset for help on using the changeset viewer.