lemon-1.2: comparison lemon/lgf

equal deleted inserted replaced

-:dede6b043875
+:c60f07796eb9
 ///\endcode
 ///
 /// By default the reader uses the first section in the file of the
 /// proper type. If a section has an optional name, then it can be
 /// selected for reading by giving an optional name parameter to the
-/// \c nodes(), \c arcs() or \c attributes() functions. The readers
+/// \c nodes(), \c arcs() or \c attributes() functions.
-/// also can load extra sections with the \c sectionLines() and
-/// sectionStream() functions.
 ///
 /// The \c useNodes() and \c useArcs() functions are used to tell the reader
 /// that the nodes or arcs should not be constructed (added to the
 /// graph) during the reading, but instead the label map of the items
 /// are given as a parameter of these functions. An
 typedef std::multimap<std::string, _reader_bits::ValueStorageBase*>
 Attributes;
 Attributes _attributes;
-typedef std::map<std::string, _reader_bits::Section*> Sections;
-Sections _sections;
 bool _use_nodes;
 bool _use_arcs;
 bool _skip_nodes;
 bool _skip_arcs;
 _nodes_caption = other._nodes_caption;
 _arcs_caption = other._arcs_caption;
 _attributes_caption = other._attributes_caption;
-_sections.swap(other._sections);
 }
 /// \brief Destructor
 ~DigraphReader() {
 for (typename NodeMaps::iterator it = _node_maps.begin();
 	delete it->second;
 }
 for (typename Attributes::iterator it = _attributes.begin();
 	   it != _attributes.end(); ++it) {
-	delete it->second;
-}
-for (typename Sections::iterator it = _sections.begin();
-	   it != _sections.end(); ++it) {
 	delete it->second;
 }
 if (local_is) {
 	delete _is;
 DigraphReader& attributes(const std::string& caption) {
 _attributes_caption = caption;
 return *this;
 }
-/// @}
-/// \name Section readers
-/// @{
-/// \brief Add a section processor with line oriented reading
-///
-/// In the \e LGF file extra sections can be placed, which contain
-/// any data in arbitrary format. These sections can be read with
-/// this function line by line. The first parameter is the type
-/// descriptor of the section, the second is a functor, which
-/// takes just one \c std::string parameter. At the reading
-/// process, each line of the section will be given to the functor
-/// object. However, the empty lines and the comment lines are
-/// filtered out, and the leading whitespaces are stipped from
-/// each processed string.
-///
-/// For example let's see a section, which contain several
-/// integers, which should be inserted into a vector.
-///\code
-///  @numbers
-///  12 45 23
-///  4
-///  23 6
-///\endcode
-///
-/// The functor is implemented as an struct:
-///\code
-///  struct NumberSection {
-///    std::vector<int>& _data;
-///    NumberSection(std::vector<int>& data) : _data(data) {}
-///    void operator()(const std::string& line) {
-///      std::istringstream ls(line);
-///      int value;
-///      while (ls >> value) _data.push_back(value);
-///    }
-///  };
-///
-///  // ...
-///
-///  reader.sectionLines("numbers", NumberSection(vec));
-///\endcode
-template <typename Functor>
-DigraphReader& sectionLines(const std::string& type, Functor functor) {
-LEMON_ASSERT(!type.empty(), "Type is not empty.");
-LEMON_ASSERT(_sections.find(type) == _sections.end(),
-		   "Multiple reading of section.");
-LEMON_ASSERT(type != "nodes" && type != "arcs" && type != "edges" &&
-		   type != "attributes", "Multiple reading of section.");
-_sections.insert(std::make_pair(type,
-new _reader_bits::LineSection<Functor>(functor)));
-return *this;
-}
-/// \brief Add a section processor with stream oriented reading
-///
-/// In the \e LGF file extra sections can be placed, which contain
-/// any data in arbitrary format. These sections can be read
-/// directly with this function. The first parameter is the type
-/// of the section, the second is a functor, which takes an \c
-/// std::istream& and an int& parameter, the latter regard to the
-/// line number of stream. The functor can read the input while
-/// the section go on, and the line number should be modified
-/// accordingly.
-template <typename Functor>
-DigraphReader& sectionStream(const std::string& type, Functor functor) {
-LEMON_ASSERT(!type.empty(), "Type is not empty.");
-LEMON_ASSERT(_sections.find(type) == _sections.end(),
-		   "Multiple reading of section.");
-LEMON_ASSERT(type != "nodes" && type != "arcs" && type != "edges" &&
-		   type != "attributes", "Multiple reading of section.");
-_sections.insert(std::make_pair(type,
-	 new _reader_bits::StreamSection<Functor>(functor)));
-return *this;
-}
 /// @}
 /// \name Using previously constructed node or arc set
 /// @{
 }
 bool nodes_done = _skip_nodes;
 bool arcs_done = _skip_arcs;
 bool attributes_done = false;
-std::set<std::string> extra_sections;
 line_num = 0;
 readLine();
 skipSection();
 	    if (_attributes_caption.empty() || _attributes_caption == caption) {
 	      readAttributes();
 	      attributes_done = true;
 	    }
 	  } else {
-	    if (extra_sections.find(section) != extra_sections.end()) {
-	      std::ostringstream msg;
-	      msg << "Multiple occurence of section " << section;
-	      throw DataFormatError(msg.str().c_str());
-	    }
-	    Sections::iterator it = _sections.find(section);
-	    if (it != _sections.end()) {
-	      extra_sections.insert(section);
-	      it->second->process(*_is, line_num);
-	    }
 	    readLine();
 	    skipSection();
 	  }
 	} catch (DataFormatError& error) {
 	  error.line(line_num);
 typedef _Graph Graph;
 TEMPLATE_GRAPH_TYPEDEFS(Graph);
 private:
 std::istream* _is;
 bool local_is;
 Graph& _graph;
 EdgeMaps _edge_maps;
 typedef std::multimap<std::string, _reader_bits::ValueStorageBase*>
 Attributes;
 Attributes _attributes;
-typedef std::map<std::string, _reader_bits::Section*> Sections;
-Sections _sections;
 bool _use_nodes;
 bool _use_edges;
 bool _skip_nodes;
 _nodes_caption = other._nodes_caption;
 _edges_caption = other._edges_caption;
 _attributes_caption = other._attributes_caption;
-_sections.swap(other._sections);
 }
 /// \brief Destructor
 ~GraphReader() {
 for (typename NodeMaps::iterator it = _node_maps.begin();
 	delete it->second;
 }
 for (typename Attributes::iterator it = _attributes.begin();
 	   it != _attributes.end(); ++it) {
-	delete it->second;
-}
-for (typename Sections::iterator it = _sections.begin();
-	   it != _sections.end(); ++it) {
 	delete it->second;
 }
 if (local_is) {
 	delete _is;
 GraphReader& attributes(const std::string& caption) {
 _attributes_caption = caption;
 return *this;
 }
-/// @}
-/// \name Section readers
-/// @{
-/// \brief Add a section processor with line oriented reading
-///
-/// In the \e LGF file extra sections can be placed, which contain
-/// any data in arbitrary format. These sections can be read with
-/// this function line by line. The first parameter is the type
-/// descriptor of the section, the second is a functor, which
-/// takes just one \c std::string parameter. At the reading
-/// process, each line of the section will be given to the functor
-/// object. However, the empty lines and the comment lines are
-/// filtered out, and the leading whitespaces are stipped from
-/// each processed string.
-///
-/// For example let's see a section, which contain several
-/// integers, which should be inserted into a vector.
-///\code
-///  @numbers
-///  12 45 23
-///  4
-///  23 6
-///\endcode
-///
-/// The functor is implemented as an struct:
-///\code
-///  struct NumberSection {
-///    std::vector<int>& _data;
-///    NumberSection(std::vector<int>& data) : _data(data) {}
-///    void operator()(const std::string& line) {
-///      std::istringstream ls(line);
-///      int value;
-///      while (ls >> value) _data.push_back(value);
-///    }
-///  };
-///
-///  // ...
-///
-///  reader.sectionLines("numbers", NumberSection(vec));
-///\endcode
-template <typename Functor>
-GraphReader& sectionLines(const std::string& type, Functor functor) {
-LEMON_ASSERT(!type.empty(), "Type is not empty.");
-LEMON_ASSERT(_sections.find(type) == _sections.end(),
-		   "Multiple reading of section.");
-LEMON_ASSERT(type != "nodes" && type != "arcs" && type != "edges" &&
-		   type != "attributes", "Multiple reading of section.");
-_sections.insert(std::make_pair(type,
-new _reader_bits::LineSection<Functor>(functor)));
-return *this;
-}
-/// \brief Add a section processor with stream oriented reading
-///
-/// In the \e LGF file extra sections can be placed, which contain
-/// any data in arbitrary format. These sections can be read
-/// directly with this function. The first parameter is the type
-/// of the section, the second is a functor, which takes an \c
-/// std::istream& and an int& parameter, the latter regard to the
-/// line number of stream. The functor can read the input while
-/// the section go on, and the line number should be modified
-/// accordingly.
-template <typename Functor>
-GraphReader& sectionStream(const std::string& type, Functor functor) {
-LEMON_ASSERT(!type.empty(), "Type is not empty.");
-LEMON_ASSERT(_sections.find(type) == _sections.end(),
-		   "Multiple reading of section.");
-LEMON_ASSERT(type != "nodes" && type != "arcs" && type != "edges" &&
-		   type != "attributes", "Multiple reading of section.");
-_sections.insert(std::make_pair(type,
-	 new _reader_bits::StreamSection<Functor>(functor)));
-return *this;
-}
 /// @}
 /// \name Using previously constructed node or edge set
 /// @{
 LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
 bool nodes_done = _skip_nodes;
 bool edges_done = _skip_edges;
 bool attributes_done = false;
-std::set<std::string> extra_sections;
 line_num = 0;
 readLine();
 skipSection();
 	    if (_attributes_caption.empty() || _attributes_caption == caption) {
 	      readAttributes();
 	      attributes_done = true;
 	    }
 	  } else {
-	    if (extra_sections.find(section) != extra_sections.end()) {
-	      std::ostringstream msg;
-	      msg << "Multiple occurence of section " << section;
-	      throw DataFormatError(msg.str().c_str());
-	    }
-	    Sections::iterator it = _sections.find(section);
-	    if (it != _sections.end()) {
-	      extra_sections.insert(section);
-	      it->second->process(*_is, line_num);
-	    }
 	    readLine();
 	    skipSection();
 	  }
 	} catch (DataFormatError& error) {
 	  error.line(line_num);
 /// \relates GraphReader
 template <typename Graph>
 GraphReader<Graph> graphReader(const char* fn, Graph& graph) {
 GraphReader<Graph> tmp(fn, graph);
+return tmp;
+}
+/// \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
+/// process the section line-by-line. While with the \c
+/// sectionStream() member the section can be read from an input
+/// stream.
+class SectionReader {
+private:
+std::istream* _is;
+bool local_is;
+typedef std::map<std::string, _reader_bits::Section*> Sections;
+Sections _sections;
+int line_num;
+std::istringstream line;
+public:
+/// \brief Constructor
+///
+/// Construct a section reader, which reads from the given input
+/// stream.
+SectionReader(std::istream& is)
+: _is(&is), local_is(false) {}
+/// \brief Constructor
+///
+/// Construct a section reader, which reads from the given file.
+SectionReader(const std::string& fn)
+: _is(new std::ifstream(fn.c_str())), local_is(true) {}
+/// \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;
+}
+if (local_is) {
+	delete _is;
+}
+}
+private:
+SectionReader& operator=(const SectionReader&);
+public:
+/// \name Section readers
+/// @{
+/// \brief Add a section processor with line oriented reading
+///
+/// The first parameter is the type descriptor of the section, the
+/// second is a functor, which takes just one \c std::string
+/// parameter. At the reading process, each line of the section
+/// will be given to the functor object. However, the empty lines
+/// and the comment lines are filtered out, and the leading
+/// whitespaces are trimmed from each processed string.
+///
+/// For example let's see a section, which contain several
+/// integers, which should be inserted into a vector.
+///\code
+///  @numbers
+///  12 45 23
+///  4
+///  23 6
+///\endcode
+///
+/// The functor is implemented as an struct:
+///\code
+///  struct NumberSection {
+///    std::vector<int>& _data;
+///    NumberSection(std::vector<int>& data) : _data(data) {}
+///    void operator()(const std::string& line) {
+///      std::istringstream ls(line);
+///      int value;
+///      while (ls >> value) _data.push_back(value);
+///    }
+///  };
+///
+///  // ...
+///
+///  reader.sectionLines("numbers", NumberSection(vec));
+///\endcode
+template <typename Functor>
+SectionReader& sectionLines(const std::string& type, Functor functor) {
+LEMON_ASSERT(!type.empty(), "Type is not empty.");
+LEMON_ASSERT(_sections.find(type) == _sections.end(),
+		   "Multiple reading of section.");
+_sections.insert(std::make_pair(type,
+new _reader_bits::LineSection<Functor>(functor)));
+return *this;
+}
+/// \brief Add a section processor with stream oriented reading
+///
+/// The first parameter is the type of the section, the second is
+/// a functor, which takes an \c std::istream& and an int&
+/// parameter, the latter regard to the line number of stream. The
+/// functor can read the input while the section go on, and the
+/// line number should be modified accordingly.
+template <typename Functor>
+SectionReader& sectionStream(const std::string& type, Functor functor) {
+LEMON_ASSERT(!type.empty(), "Type is not empty.");
+LEMON_ASSERT(_sections.find(type) == _sections.end(),
+		   "Multiple reading of section.");
+_sections.insert(std::make_pair(type,
+	 new _reader_bits::StreamSection<Functor>(functor)));
+return *this;
+}
+/// @}
+private:
+bool readLine() {
+std::string str;
+while(++line_num, std::getline(*_is, str)) {
+	line.clear(); line.str(str);
+	char c;
+	if (line >> std::ws >> c && c != '#') {
+	  line.putback(c);
+	  return true;
+	}
+}
+return false;
+}
+bool readSuccess() {
+return static_cast<bool>(*_is);
+}
+void skipSection() {
+char c;
+while (readSuccess() && line >> c && c != '@') {
+	readLine();
+}
+line.putback(c);
+}
+public:
+/// \name Execution of the reader
+/// @{
+/// \brief Start the batch processing
+///
+/// This function starts the batch processing
+void run() {
+LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
+std::set<std::string> extra_sections;
+line_num = 0;
+readLine();
+skipSection();
+while (readSuccess()) {
+	try {
+	  char c;
+	  std::string section, caption;
+	  line >> c;
+	  _reader_bits::readToken(line, section);
+	  _reader_bits::readToken(line, caption);
+	  if (line >> c)
+	    throw DataFormatError("Extra character on the end of line");
+	  if (extra_sections.find(section) != extra_sections.end()) {
+	    std::ostringstream msg;
+	    msg << "Multiple occurence of section " << section;
+	    throw DataFormatError(msg.str().c_str());
+	  }
+	  Sections::iterator it = _sections.find(section);
+	  if (it != _sections.end()) {
+	    extra_sections.insert(section);
+	    it->second->process(*_is, line_num);
+	  }
+	  readLine();
+	  skipSection();
+	} catch (DataFormatError& error) {
+	  error.line(line_num);
+	  throw;
+	}
+}
+for (Sections::iterator it = _sections.begin();
+	   it != _sections.end(); ++it) {
+	if (extra_sections.find(it->first) == extra_sections.end()) {
+	  std::ostringstream os;
+	  os << "Cannot find section: " << it->first;
+	  throw DataFormatError(os.str().c_str());
+	}
+}
+}
+/// @}
+};
+/// \relates SectionReader
+inline SectionReader sectionReader(std::istream& is) {
+SectionReader tmp(is);
+return tmp;
+}
+/// \relates SectionReader
+inline SectionReader sectionReader(const std::string& fn) {
+SectionReader tmp(fn);
+return tmp;
+}
+/// \relates SectionReader
+inline SectionReader sectionReader(const char* fn) {
+SectionReader tmp(fn);
 return tmp;
 }
 /// \ingroup lemon_io
 ///

changeset 189	a63ed81c57ba
parent 188	70694e6bdcac
child 190	1e6af6f0843c