LEMON/LEMON-main Changeset - r190:1e6af6f0843c

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r190:1e6af6f0843c

« 189:a63ed8

206:4e2227 »
192:7bf5f9 »
191:abc5b9 »

r190:1e6af6f0843c

Fri, 04 Jul 2008 16:12:31

[Not Reviewed]

0 comments (0 inline)

deba@inf.elte.hu
deba@inf.elte.hu

Move to private copy constrcutors

0 2 0

default

2 files changed with 201 insertions and 148 deletions:

lemon/lgf_reader.h

105

lemon/lgf_writer.h

↑ Collapse diff ↑

lemon/lgf_reader.h

Show inline comments

@@ -383,12 +383,24 @@
 			else if (is.eof()) is.clear();
+		      }
 		    };
+		  }
 		  template <typename Digraph>
 		  class DigraphReader;
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(std::istream& is, Digraph& digraph);
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(const std::string& fn, Digraph& digraph);
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(const char *fn, Digraph& digraph);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief LGF reader for directed graphs
 		  ///
 		  /// This utility reads an \ref lgf-format "LGF" file.
 		  ///
@@ -506,37 +518,12 @@
 		    /// file.
 		    DigraphReader(const char* fn, Digraph& digraph)
 		      : _is(new std::ifstream(fn)), local_is(true), _digraph(digraph),
 		    	_use_nodes(false), _use_arcs(false),
 			_skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Copy constructor
 		    ///
 		    /// The copy constructor transfers all data from the other reader,
 		    /// therefore the copied reader will not be usable more.
 		    DigraphReader(DigraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),
 			_use_nodes(other._use_nodes), _use_arcs(other._use_arcs),
 			_skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _node_index.swap(other._node_index);
 		      _arc_index.swap(other._arc_index);
 		      _node_maps.swap(other._node_maps);
 		      _arc_maps.swap(other._arc_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _arcs_caption = other._arcs_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    /// \brief Destructor
 		    ~DigraphReader() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 			delete it->second;
+		      }
@@ -555,13 +542,41 @@
 			delete _is;
+		      }
+		    }
 		  private:
 		    friend DigraphReader<Digraph> digraphReader<>(std::istream& is,
 								  Digraph& digraph);
 		    friend DigraphReader<Digraph> digraphReader<>(const std::string& fn,
 								  Digraph& digraph);
 		    friend DigraphReader<Digraph> digraphReader<>(const char *fn,
 								  Digraph& digraph);
 		    DigraphReader(DigraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),
 			_use_nodes(other._use_nodes), _use_arcs(other._use_arcs),
 			_skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _node_index.swap(other._node_index);
 		      _arc_index.swap(other._arc_index);
 		      _node_maps.swap(other._node_maps);
 		      _arc_maps.swap(other._arc_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _arcs_caption = other._arcs_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    DigraphReader& operator=(const DigraphReader&);
 		  public:
 		    /// \name Reading rules
 		    /// @{
@@ -1179,12 +1194,24 @@
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(const char* fn, Digraph& digraph) {
 		    DigraphReader<Digraph> tmp(fn, digraph);
 		    return tmp;
+		  }
 		  template <typename Graph>
 		  class GraphReader;
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(std::istream& is, Graph& graph);
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(const std::string& fn, Graph& graph);
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(const char *fn, Graph& graph);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief LGF reader for undirected graphs
 		  ///
 		  /// This utility reads an \ref lgf-format "LGF" file.
 		  template <typename _Graph>
@@ -1257,37 +1284,12 @@
 		    /// file.
 		    GraphReader(const char* fn, Graph& graph)
 		      : _is(new std::ifstream(fn)), local_is(true), _graph(graph),
 		    	_use_nodes(false), _use_edges(false),
 			_skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Copy constructor
 		    ///
 		    /// The copy constructor transfers all data from the other reader,
 		    /// therefore the copied reader will not be usable more.
 		    GraphReader(GraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _graph(other._graph),
 			_use_nodes(other._use_nodes), _use_edges(other._use_edges),
 			_skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _node_index.swap(other._node_index);
 		      _edge_index.swap(other._edge_index);
 		      _node_maps.swap(other._node_maps);
 		      _edge_maps.swap(other._edge_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _edges_caption = other._edges_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    /// \brief Destructor
 		    ~GraphReader() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 			delete it->second;
+		      }
@@ -1306,13 +1308,38 @@
 			delete _is;
+		      }
+		    }
 		  private:
+		    friend GraphReader<Graph> graphReader<>(std::istream& is, Graph& graph);
 		    friend GraphReader<Graph> graphReader<>(const std::string& fn,
 							    Graph& graph);
 		    friend GraphReader<Graph> graphReader<>(const char *fn, Graph& graph);
 		    GraphReader(GraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _graph(other._graph),
 			_use_nodes(other._use_nodes), _use_edges(other._use_edges),
 			_skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _node_index.swap(other._node_index);
 		      _edge_index.swap(other._edge_index);
 		      _node_maps.swap(other._node_maps);
 		      _edge_maps.swap(other._edge_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _edges_caption = other._edges_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    GraphReader& operator=(const GraphReader&);
 		  public:
 		    /// \name Reading rules
 		    /// @{
@@ -1974,12 +2001,18 @@
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(const char* fn, Graph& graph) {
 		    GraphReader<Graph> tmp(fn, graph);
 		    return tmp;
+		  }
 		  class SectionReader;
 		  SectionReader sectionReader(std::istream& is);
 		  SectionReader sectionReader(const std::string& fn);
 		  SectionReader sectionReader(const char* fn);
 		  /// \brief Section reader class
 		  ///
 		  /// In the \e LGF file extra sections can be placed, which contain
 		  /// any data in arbitrary format. Such sections can be read with
 		  /// this class. A reading rule can be added with two different
 		  /// functions, with the \c sectionLines() function a functor can
@@ -2016,25 +2049,12 @@
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section reader, which reads from the given file.
 		    SectionReader(const char* fn)
 		      : _is(new std::ifstream(fn)), local_is(true) {}
 		    /// \brief Copy constructor
 		    ///
 		    /// The copy constructor transfers all data from the other reader,
 		    /// therefore the copied reader will not be usable more.
 		    SectionReader(SectionReader& other)
 		      : _is(other._is), local_is(other.local_is) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _sections.swap(other._sections);
+		    }
 		    /// \brief Destructor
 		    ~SectionReader() {
 		      for (Sections::iterator it = _sections.begin();
 			   it != _sections.end(); ++it) {
 			delete it->second;
+		      }
@@ -2043,12 +2063,25 @@
 			delete _is;
+		      }
+		    }
 		  private:
 		    friend SectionReader sectionReader(std::istream& is);
 		    friend SectionReader sectionReader(const std::string& fn);
 		    friend SectionReader sectionReader(const char* fn);
 		    SectionReader(SectionReader& other)
 		      : _is(other._is), local_is(other.local_is) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _sections.swap(other._sections);
+		    }
 		    SectionReader& operator=(const SectionReader&);
 		  public:
 		    /// \name Section readers
@@ -2292,40 +2325,25 @@
 		    /// \brief Constructor
 		    ///
 		    /// Construct an \e LGF contents reader, which reads from the given
 		    /// file.
 		    LgfContents(const char* fn)
 		      : _is(new std::ifstream(fn)), local_is(true) {}
 		    /// \brief Copy constructor
 		    ///
 		    /// The copy constructor transfers all data from the other reader,
 		    /// therefore the copied reader will not be usable more.
 		    LgfContents(LgfContents& other)
 		      : _is(other._is), local_is(other.local_is) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _node_sections.swap(other._node_sections);
 		      _edge_sections.swap(other._edge_sections);
 		      _attribute_sections.swap(other._attribute_sections);
 		      _extra_sections.swap(other._extra_sections);
 		      _arc_sections.swap(other._arc_sections);
 		      _node_maps.swap(other._node_maps);
 		      _edge_maps.swap(other._edge_maps);
 		      _attributes.swap(other._attributes);
+		    }
 		    /// \brief Destructor
 		    ~LgfContents() {
 		      if (local_is) delete _is;
+		    }
 		  private:
 		    LgfContents(const LgfContents&);
 		    LgfContents& operator=(const LgfContents&);
 		  public:
 		    /// \name Node sections
 		    /// @{
 		    /// \brief Gives back the number of node sections in the file.
 		    ///

lemon/lgf_writer.h

Show inline comments

@@ -301,12 +301,27 @@
 			os << str;
+		      }
 		      return os;
+		    }
+		  }
 		  template <typename Digraph>
 		  class DigraphWriter;
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(std::ostream& os,
 						       const Digraph& digraph);
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const std::string& fn,
 						       const Digraph& digraph);
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const char *fn,
 						       const Digraph& digraph);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief LGF writer for directed graphs
 		  ///
 		  /// This utility writes an \ref lgf-format "LGF" file.
@@ -359,13 +374,13 @@
 		  private:
 		    std::ostream* _os;
 		    bool local_os;
 		    Digraph& _digraph;
+		    const Digraph& _digraph;
 		    std::string _nodes_caption;
 		    std::string _arcs_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<Node, std::string> NodeIndex;
@@ -391,55 +406,32 @@
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output stream.
 		    DigraphWriter(std::ostream& is, Digraph& digraph)
+		    DigraphWriter(std::ostream& is, const Digraph& digraph)
 		      : _os(&is), local_os(false), _digraph(digraph),
 			_skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    DigraphWriter(const std::string& fn, Digraph& digraph)
+		    DigraphWriter(const std::string& fn, const Digraph& digraph)
 		      : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),
 			_skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    DigraphWriter(const char* fn, Digraph& digraph)
+		    DigraphWriter(const char* fn, const Digraph& digraph)
 		      : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),
 			_skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Copy constructor
 		    ///
 		    /// The copy constructor transfers all data from the other writer,
 		    /// therefore the copied writer will not be usable more.
 		    DigraphWriter(DigraphWriter& other)
 		      : _os(other._os), local_os(other.local_os), _digraph(other._digraph),
 			_skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
 		      other._os = 0;
 		      other.local_os = false;
 		      _node_index.swap(other._node_index);
 		      _arc_index.swap(other._arc_index);
 		      _node_maps.swap(other._node_maps);
 		      _arc_maps.swap(other._arc_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _arcs_caption = other._arcs_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    /// \brief Destructor
 		    ~DigraphWriter() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 			delete it->second;
+		      }
@@ -457,12 +449,38 @@
 		      if (local_os) {
 			delete _os;
+		      }
+		    }
 		  private:
 		    friend DigraphWriter<Digraph> digraphWriter<>(std::ostream& os,
 								  const Digraph& digraph);
 		    friend DigraphWriter<Digraph> digraphWriter<>(const std::string& fn,
 								  const Digraph& digraph);
 		    friend DigraphWriter<Digraph> digraphWriter<>(const char *fn,
 								  const Digraph& digraph);
 		    DigraphWriter(DigraphWriter& other)
 		      : _os(other._os), local_os(other.local_os), _digraph(other._digraph),
 			_skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
 		      other._os = 0;
 		      other.local_os = false;
 		      _node_index.swap(other._node_index);
 		      _arc_index.swap(other._arc_index);
 		      _node_maps.swap(other._node_maps);
 		      _arc_maps.swap(other._arc_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _arcs_caption = other._arcs_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    DigraphWriter& operator=(const DigraphWriter&);
 		  public:
 		    /// \name Writing rules
@@ -841,32 +859,46 @@
 		    /// @}
 		  };
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
-		  DigraphWriter<Digraph> digraphWriter(std::ostream& os, Digraph& digraph) {
 		  DigraphWriter<Digraph> digraphWriter(std::ostream& os,
 						       const Digraph& digraph) {
 		    DigraphWriter<Digraph> tmp(os, digraph);
 		    return tmp;
+		  }
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const std::string& fn,
 						       Digraph& digraph) {
+						       const Digraph& digraph) {
 		    DigraphWriter<Digraph> tmp(fn, digraph);
 		    return tmp;
+		  }
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
-		  DigraphWriter<Digraph> digraphWriter(const char* fn, Digraph& digraph) {
 		  DigraphWriter<Digraph> digraphWriter(const char* fn,
 						       const Digraph& digraph) {
 		    DigraphWriter<Digraph> tmp(fn, digraph);
 		    return tmp;
+		  }
 		  template <typename Graph>
 		  class GraphWriter;
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph);
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph);
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const char *fn, const Graph& graph);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief LGF writer for directed graphs
 		  ///
 		  /// This utility writes an \ref lgf-format "LGF" file.
 		  template <typename _Graph>
@@ -911,55 +943,32 @@
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output stream.
 		    GraphWriter(std::ostream& is, Graph& graph)
+		    GraphWriter(std::ostream& is, const Graph& graph)
 		      : _os(&is), local_os(false), _graph(graph),
 			_skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    GraphWriter(const std::string& fn, Graph& graph)
+		    GraphWriter(const std::string& fn, const Graph& graph)
 		      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
 			_skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    GraphWriter(const char* fn, Graph& graph)
+		    GraphWriter(const char* fn, const Graph& graph)
 		      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
 			_skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Copy constructor
 		    ///
 		    /// The copy constructor transfers all data from the other writer,
 		    /// therefore the copied writer will not be usable more.
 		    GraphWriter(GraphWriter& other)
 		      : _os(other._os), local_os(other.local_os), _graph(other._graph),
 			_skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 		      other._os = 0;
 		      other.local_os = false;
 		      _node_index.swap(other._node_index);
 		      _edge_index.swap(other._edge_index);
 		      _node_maps.swap(other._node_maps);
 		      _edge_maps.swap(other._edge_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _edges_caption = other._edges_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    /// \brief Destructor
 		    ~GraphWriter() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 			delete it->second;
+		      }
@@ -975,15 +984,41 @@
+		      }
 		      if (local_os) {
 			delete _os;
+		      }
+		    }
 		  private:
 		  private:
 		    friend GraphWriter<Graph> graphWriter<>(std::ostream& os,
 							    const Graph& graph);
 		    friend GraphWriter<Graph> graphWriter<>(const std::string& fn,
 							    const Graph& graph);
 		    friend GraphWriter<Graph> graphWriter<>(const char *fn,
 							    const Graph& graph);
 		    GraphWriter(GraphWriter& other)
 		      : _os(other._os), local_os(other.local_os), _graph(other._graph),
 			_skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 		      other._os = 0;
 		      other.local_os = false;
 		      _node_index.swap(other._node_index);
 		      _edge_index.swap(other._edge_index);
 		      _node_maps.swap(other._node_maps);
 		      _edge_maps.swap(other._edge_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _edges_caption = other._edges_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    GraphWriter& operator=(const GraphWriter&);
 		  public:
 		    /// \name Writing rules
 		    /// @{
@@ -1407,27 +1442,27 @@
 		    /// @}
 		  };
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(std::ostream& os, Graph& graph) {
+		  GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph) {
 		    GraphWriter<Graph> tmp(os, graph);
 		    return tmp;
+		  }
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const std::string& fn, Graph& graph) {
+		  GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph) {
 		    GraphWriter<Graph> tmp(fn, graph);
 		    return tmp;
+		  }
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const char* fn, Graph& graph) {
+		  GraphWriter<Graph> graphWriter(const char* fn, const Graph& graph) {
 		    GraphWriter<Graph> tmp(fn, graph);
 		    return tmp;
+		  }
+		}
 		#endif

0 comments (0 inline)

RhodeCode

Login to your account