LEMON/LEMON-official Changeset - r162:33247f6fff16

Repositories » LEMON » LEMON-official

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

Changeset - r162:33247f6fff16

« 161:2c9999

163:c82fd9 »

r162:33247f6fff16

Tue, 27 May 2008 16:01:20

[Not Reviewed]

0 comments (0 inline)

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

Section reader for DigraphReader

0 2 0

default

2 files changed with 183 insertions and 12 deletions:

doc/lgf.dox

lemon/lgf_reader.h

180

↑ Collapse diff ↑

doc/lgf.dox

Show inline comments

@@ -81,16 +81,19 @@
 		The \c \@edges is just a synonym of \c \@arcs.
 		The \c \@attributes section contains key-value pairs, each line
 		consists of two tokens, an attribute name, and then an attribute value.
 		\code
 		 @attributes
 		 source 1
 		 target 3
 		 caption "LEMON test digraph"
 		\endcode
 		The \e LGF can contain extra sections, but there is no restriction on
 		the format of such sections.
 		*/
+		}
 		//  LocalWords:  whitespace whitespaces

lemon/lgf_reader.h

Show inline comments

@@ -259,61 +259,129 @@
 			    c = readEscape(is);
 			  os << c;
+			}
 			if (!is) {
 			  is.clear();
 			} else {
 			  is.putback(c);
+			}
+		      }
 		      str = os.str();
 		      return is;
+		    }
 		    class Section {
 		    public:
 		      virtual ~Section() {}
 		      virtual void process(std::istream& is, int& line_num) = 0;
 		    };
 		    template <typename Functor>
 		    class LineSection : public Section {
 		    private:
 		      Functor _functor;
 		    public:
 		      LineSection(const Functor& functor) : _functor(functor) {}
 		      virtual ~LineSection() {}
 		      virtual void process(std::istream& is, int& line_num) {
 			char c;
 			std::string line;
 			while (is.get(c) && c != '@') {
 			  if (c == '\n') {
 			    ++line_num;
 			  } else if (c == '#') {
 			    getline(is, line);
 			    ++line_num;
 			  } else if (!isWhiteSpace(c)) {
 			    is.putback(c);
 			    getline(is, line);
 			    _functor(line);
 			    ++line_num;
+			  }
+			}
 			if (is) is.putback(c);
 			else if (is.eof()) is.clear();
+		      }
 		    };
 		    template <typename Functor>
 		    class StreamSection : public Section {
 		    private:
 		      Functor _functor;
 		    public:
 		      StreamSection(const Functor& functor) : _functor(functor) {}
 		      virtual ~StreamSection() {}
 		      virtual void process(std::istream& is, int& line_num) {
 			_functor(is, line_num);
 			char c;
 			std::string line;
 			while (is.get(c) && c != '@') {
 			  if (c == '\n') {
 			    ++line_num;
 			  } else if (!isWhiteSpace(c)) {
 			    getline(is, line);
 			    ++line_num;
+			  }
+			}
 			if (is) is.putback(c);
 			else if (is.eof()) is.clear();
+		      }
 		    };
+		  }
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief LGF reader for directed graphs
 		  ///
 		  /// This utility reads an \ref lgf-format "LGF" file.
 		  ///
 		  /// The reading method does a batch processing. The user creates a
 		  /// reader object, then various reading rules can be added to the
 		  /// reader, and eventually the reading is executed with the \c run()
 		  /// member function. A map reading rule can be added to the reader
 		  /// with the \c nodeMap() or \c arcMap() members. An optional
 		  /// converter parameter can also be added as a standard functor converting from
 		  /// std::string to the value type of the map. If it is set, it will
 		  /// determine how the tokens in the file should be is converted to the map's
 		  /// value type. If the functor is not set, then a default conversion
 		  /// will be used. One map can be read into multiple map objects at the
 		  /// same time. The \c attribute(), \c node() and \c arc() functions
-		  /// are used to add attribute reading rules.
+		  /// converter parameter can also be added as a standard functor
 		  /// converting from std::string to the value type of the map. If it
 		  /// is set, it will determine how the tokens in the file should be
 		  /// is converted to the map's value type. If the functor is not set,
 		  /// then a default conversion will be used. One map can be read into
 		  /// multiple map objects at the same time. The \c attribute(), \c
 		  /// node() and \c arc() functions are used to add attribute reading
 		  /// rules.
 		  ///
 		  ///\code
 		  ///     DigraphReader<Digraph>(std::cin, digraph).
 		  ///       nodeMap("coordinates", coord_map).
 		  ///       arcMap("capacity", cap_map).
 		  ///       node("source", src).
 		  ///       node("target", trg).
 		  ///       attribute("caption", caption).
 		  ///       run();
 		  ///\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.
+		  /// selected for reading by giving an optional name parameter to the
 		  /// \c nodes(), \c arcs() or \c attributes() functions. The readers
 		  /// 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
 		  /// application of these function is multipass reading, which is
 		  /// important if two \e \@arcs sections must be read from the
 		  /// file. In this example the first phase would read the node set and one
 		  /// of the arc sets, while the second phase would read the second arc
 		  /// set into an \e ArcSet class (\c SmartArcSet or \c ListArcSet).
 		  /// The previously read label node map should be passed to the \c
 		  /// useNodes() functions. Another application of multipass reading when
@@ -347,24 +415,27 @@
 		    typedef std::vector<std::pair<std::string,
 		      _reader_bits::MapStorageBase<Node>*> > NodeMaps;
 		    NodeMaps _node_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _reader_bits::MapStorageBase<Arc>*> >ArcMaps;
 		    ArcMaps _arc_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_arcs;
 		    int line_num;
 		    std::istringstream line;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// input stream.
@@ -400,43 +471,50 @@
 		      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;
 		      _sections.swap(other._sections);
+		    }
 		    /// \brief Destructor
 		    ~DigraphReader() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 			delete it->second;
+		      }
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 			   it != _arc_maps.end(); ++it) {
 			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;
+		      }
+		    }
 		  private:
 		    DigraphReader& operator=(const DigraphReader&);
 		  public:
@@ -565,24 +643,101 @@
+		    }
 		    /// \brief Set \c \@attributes section to be read
 		    ///
 		    /// Set \c \@attributes section to be read
 		    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
 		    /// @{
 		    /// \brief Use previously constructed node set
 		    ///
 		    /// Use previously constructed node set, and specify the node
 		    /// label map.
 		    template <typename Map>
 		    DigraphReader& useNodes(const Map& map) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
 		      _use_nodes = true;
@@ -920,24 +1075,25 @@
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing
 		    void run() {
 		      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
 		      bool nodes_done = false;
 		      bool arcs_done = false;
 		      bool attributes_done = false;
 		      std::set<std::string> extra_sections;
 		      line_num = 0;
 		      readLine();
 		      while (readSuccess()) {
 			skipSection();
 			try {
 			  char c;
 			  std::string section, caption;
 			  line >> c;
 			  _reader_bits::readToken(line, section);
 			  _reader_bits::readToken(line, caption);
@@ -953,26 +1109,38 @@
 			  } else if ((section == "arcs" || section == "edges") &&
 				     !arcs_done) {
 			    if (_arcs_caption.empty() || _arcs_caption == caption) {
 			      readArcs();
 			      arcs_done = true;
+			    }
 			  } else if (section == "attributes" && !attributes_done) {
 			    if (_attributes_caption.empty() || _attributes_caption == caption) {
 			      readAttributes();
 			      attributes_done = true;
+			    }
 			  } else {
 			    readLine();
 			    skipSection();
 			    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();
 			    } else {
 			      readLine();
 			      skipSection();
+			    }
+			  }
 			} catch (DataFormatError& error) {
 			  error.line(line_num);
 			  throw;
+			}
+		      }
 		      if (!nodes_done) {
 			throw DataFormatError("Section @nodes not found");
+		      }
 		      if (!arcs_done) {

0 comments (0 inline)

RhodeCode

Login to your account