COIN-OR::LEMON - Graph Library

Changeset 190:1e6af6f0843c in lemon-1.0 for lemon/lgf_reader.h


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

File:
1 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
Note: See TracChangeset for help on using the changeset viewer.