LEMON/LEMON-main Changeset - r162:33247f6fff16

Repositories » LEMON » LEMON-main

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

@@ -69,28 +69,31 @@
 		describe the arcs. The first two tokens of each line are
 		the source and the target node of the arc, respectively, then come the map
 		values. The source and target tokens must be node labels.
 		\code
 		 @arcs
 		 	      capacity
 2   16
 3   12
 3   18
 		\endcode
 		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

@@ -247,85 +247,153 @@
 		      if (c == '\"') {
 			while (is.get(c) && c != '\"') {
 			  if (c == '\\')
 			    c = readEscape(is);
 			  os << c;
+			}
 			if (!is)
 			  throw DataFormatError("Quoted format error");
 		      } else {
 			is.putback(c);
 			while (is.get(c) && !isWhiteSpace(c)) {
 			  if (c == '\\')
 			    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
 		  /// paths are given as a node map or an arc map. It is impossible read this in
 		  /// a single pass, because the arcs are not constructed when the node
 		  /// maps are read.
 		  template <typename _Digraph>
 		  class DigraphReader {
 		  public:
 		    typedef _Digraph Digraph;
 		    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		  private:
@@ -335,48 +403,51 @@
 		    Digraph& _digraph;
 		    std::string _nodes_caption;
 		    std::string _arcs_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<std::string, Node> NodeIndex;
 		    NodeIndex _node_index;
 		    typedef std::map<std::string, Arc> ArcIndex;
 		    ArcIndex _arc_index;
 		    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.
 		    DigraphReader(std::istream& is, Digraph& digraph)
 		      : _is(&is), local_is(false), _digraph(digraph),
 			_use_nodes(false), _use_arcs(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// file.
 		    DigraphReader(const std::string& fn, Digraph& digraph)
 		      : _is(new std::ifstream(fn.c_str())), local_is(true), _digraph(digraph),
 		    	_use_nodes(false), _use_arcs(false) {}
@@ -388,67 +459,74 @@
 		      : _is(new std::ifstream(fn)), local_is(true), _digraph(digraph),
 		    	_use_nodes(false), _use_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) {
 		      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;
 		      _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:
 		    /// \name Reading rules
 		    /// @{
 		    /// \brief Node map reading rule
 		    ///
 		    /// Add a node map reading rule to the reader.
 		    template <typename Map>
 		    DigraphReader& nodeMap(const std::string& caption, Map& map) {
 		      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Node>* storage =
 			new _reader_bits::MapStorage<Node, Map>(map);
 		      _node_maps.push_back(std::make_pair(caption, storage));
@@ -553,48 +631,125 @@
 		    /// Set \c \@nodes section to be read
 		    DigraphReader& nodes(const std::string& caption) {
 		      _nodes_caption = caption;
 		      return *this;
+		    }
 		    /// \brief Set \c \@arcs section to be read
 		    ///
 		    /// Set \c \@arcs section to be read
 		    DigraphReader& arcs(const std::string& caption) {
 		      _arcs_caption = caption;
 		      return *this;
+		    }
 		    /// \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;
 		      _writer_bits::DefaultConverter<typename Map::Value> converter;
 		      for (NodeIt n(_digraph); n != INVALID; ++n) {
 			_node_index.insert(std::make_pair(converter(map[n]), n));
+		      }
 		      return *this;
+		    }
 		    /// \brief Use previously constructed node set
 		    ///
 		    /// Use previously constructed node set, and specify the node
 		    /// label map and a functor which converts the label map values to
 		    /// std::string.
@@ -908,83 +1063,96 @@
 			   it != _attributes.end(); ++it) {
 			if (read_attr.find(it->first) == read_attr.end()) {
 			  std::ostringstream msg;
 			  msg << "Attribute not found in file: " << it->first;
 			  throw DataFormatError(msg.str().c_str());
+			}
+		      }
+		    }
 		  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");
 		      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);
 			  if (line >> c)
 			    throw DataFormatError("Extra character on the end of line");
 			  if (section == "nodes" && !nodes_done) {
 			    if (_nodes_caption.empty() || _nodes_caption == caption) {
 			      readNodes();
 			      nodes_done = true;
+			    }
 			  } 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) {
 			throw DataFormatError("Section @arcs not found");
+		      }
 		      if (!attributes_done && !_attributes.empty()) {
 			throw DataFormatError("Section @attributes not found");
+		      }
+		    }
 		    /// @}
 		  };

0 comments (0 inline)

RhodeCode

Login to your account