LEMON/LEMON-main Changeset - r185:33e45a9b868c

Repositories » LEMON » LEMON-main

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

Changeset - r185:33e45a9b868c

« 184:716b22

186:9159de »

r185:33e45a9b868c

Tue, 01 Jul 2008 21:21:49

[Not Reviewed]

0 comments (0 inline)

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

Fix skip*() functions is GraphWriters (Ticket #107)

0 1 0

default

1 file changed with 108 insertions and 0 deletions:

lemon/lgf_writer.h

108

↑ Collapse diff ↑

lemon/lgf_writer.h

Show inline comments

@@ -558,267 +558,321 @@
 		    /// \brief Arc writing rule
 		    ///
 		    /// Add an arc writing rule to writer.
 		    DigraphWriter& arc(const std::string& caption, const Arc& arc) {
 		      typedef _writer_bits::MapLookUpConverter<Arc> Converter;
 		      Converter converter(_arc_index);
 		      _writer_bits::ValueStorageBase* storage =
 			new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \name Select section by name
 		    /// @{
 		    /// \brief Set \c \@nodes section to be read
 		    ///
 		    /// Set \c \@nodes section to be read
 		    DigraphWriter& 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
 		    DigraphWriter& 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
 		    DigraphWriter& attributes(const std::string& caption) {
 		      _attributes_caption = caption;
 		      return *this;
+		    }
 		    /// \name Skipping section
 		    /// @{
 		    /// \brief Skip writing the node set
 		    ///
 		    /// The \c \@nodes section will be not written to the stream.
 		    DigraphWriter& skipNodes() {
 		      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
 		      _skip_nodes = true;
 		      return *this;
+		    }
 		    /// \brief Skip writing arc set
 		    ///
 		    /// The \c \@arcs section will be not written to the stream.
 		    DigraphWriter& skipArcs() {
 		      LEMON_ASSERT(!_skip_arcs, "Multiple usage of skipArcs() member");
 		      _skip_arcs = true;
 		      return *this;
+		    }
 		    /// @}
 		  private:
 		    void writeNodes() {
 		      _writer_bits::MapStorageBase<Node>* label = 0;
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 		        if (it->first == "label") {
 			  label = it->second;
 			  break;
+			}
+		      }
 		      *_os << "@nodes";
 		      if (!_nodes_caption.empty()) {
 			_writer_bits::writeToken(*_os << ' ', _nodes_caption);
+		      }
 		      *_os << std::endl;
 		      if (label == 0) {
 			*_os << "label" << '\t';
+		      }
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 			_writer_bits::writeToken(*_os, it->first) << '\t';
+		      }
 		      *_os << std::endl;
 		      std::vector<Node> nodes;
 		      for (NodeIt n(_digraph); n != INVALID; ++n) {
 			nodes.push_back(n);
+		      }
 		      if (label == 0) {
 			IdMap<Digraph, Node> id_map(_digraph);
 			_writer_bits::MapLess<IdMap<Digraph, Node> > id_less(id_map);
 			std::sort(nodes.begin(), nodes.end(), id_less);
 		      } else {
 			label->sort(nodes);
+		      }
 		      for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
 			Node n = nodes[i];
 			if (label == 0) {
 			  std::ostringstream os;
 			  os << _digraph.id(n);
 			  _writer_bits::writeToken(*_os, os.str());
 			  *_os << '\t';
 			  _node_index.insert(std::make_pair(n, os.str()));
+			}
 			for (typename NodeMaps::iterator it = _node_maps.begin();
 			     it != _node_maps.end(); ++it) {
 			  std::string value = it->second->get(n);
 			  _writer_bits::writeToken(*_os, value);
 			  if (it->first == "label") {
 			    _node_index.insert(std::make_pair(n, value));
+			  }
 			  *_os << '\t';
+			}
 			*_os << std::endl;
+		      }
+		    }
 		    void createNodeIndex() {
 		      _writer_bits::MapStorageBase<Node>* label = 0;
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 		        if (it->first == "label") {
 			  label = it->second;
 			  break;
+			}
+		      }
 		      if (label == 0) {
 			for (NodeIt n(_digraph); n != INVALID; ++n) {
 			  std::ostringstream os;
 			  os << _digraph.id(n);
 			  _node_index.insert(std::make_pair(n, os.str()));
+			}
 		      } else {
 			for (NodeIt n(_digraph); n != INVALID; ++n) {
 			  std::string value = label->get(n);
 			  _node_index.insert(std::make_pair(n, value));
+			}
+		      }
+		    }
 		    void writeArcs() {
 		      _writer_bits::MapStorageBase<Arc>* label = 0;
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 			   it != _arc_maps.end(); ++it) {
 		        if (it->first == "label") {
 			  label = it->second;
 			  break;
+			}
+		      }
 		      *_os << "@arcs";
 		      if (!_arcs_caption.empty()) {
 			_writer_bits::writeToken(*_os << ' ', _arcs_caption);
+		      }
 		      *_os << std::endl;
 		      *_os << '\t' << '\t';
 		      if (label == 0) {
 			*_os << "label" << '\t';
+		      }
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 			   it != _arc_maps.end(); ++it) {
 			_writer_bits::writeToken(*_os, it->first) << '\t';
+		      }
 		      *_os << std::endl;
 		      std::vector<Arc> arcs;
 		      for (ArcIt n(_digraph); n != INVALID; ++n) {
 			arcs.push_back(n);
+		      }
 		      if (label == 0) {
 			IdMap<Digraph, Arc> id_map(_digraph);
 			_writer_bits::MapLess<IdMap<Digraph, Arc> > id_less(id_map);
 			std::sort(arcs.begin(), arcs.end(), id_less);
 		      } else {
 			label->sort(arcs);
+		      }
 		      for (int i = 0; i < static_cast<int>(arcs.size()); ++i) {
 			Arc a = arcs[i];
 			_writer_bits::writeToken(*_os, _node_index.
 						 find(_digraph.source(a))->second);
 			*_os << '\t';
 			_writer_bits::writeToken(*_os, _node_index.
 						 find(_digraph.target(a))->second);
 			*_os << '\t';
 			if (label == 0) {
 			  std::ostringstream os;
 			  os << _digraph.id(a);
 			  _writer_bits::writeToken(*_os, os.str());
 			  *_os << '\t';
 			  _arc_index.insert(std::make_pair(a, os.str()));
+			}
 			for (typename ArcMaps::iterator it = _arc_maps.begin();
 			     it != _arc_maps.end(); ++it) {
 			  std::string value = it->second->get(a);
 			  _writer_bits::writeToken(*_os, value);
 			  if (it->first == "label") {
 			    _arc_index.insert(std::make_pair(a, value));
+			  }
 			  *_os << '\t';
+			}
 			*_os << std::endl;
+		      }
+		    }
 		    void createArcIndex() {
 		      _writer_bits::MapStorageBase<Arc>* label = 0;
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 			   it != _arc_maps.end(); ++it) {
 		        if (it->first == "label") {
 			  label = it->second;
 			  break;
+			}
+		      }
 		      if (label == 0) {
 			for (ArcIt a(_digraph); a != INVALID; ++a) {
 			  std::ostringstream os;
 			  os << _digraph.id(a);
 			  _arc_index.insert(std::make_pair(a, os.str()));
+			}
 		      } else {
 			for (ArcIt a(_digraph); a != INVALID; ++a) {
 			  std::string value = label->get(a);
 			  _arc_index.insert(std::make_pair(a, value));
+			}
+		      }
+		    }
 		    void writeAttributes() {
 		      if (_attributes.empty()) return;
 		      *_os << "@attributes";
 		      if (!_attributes_caption.empty()) {
 			_writer_bits::writeToken(*_os << ' ', _attributes_caption);
+		      }
 		      *_os << std::endl;
 		      for (typename Attributes::iterator it = _attributes.begin();
 			   it != _attributes.end(); ++it) {
 			_writer_bits::writeToken(*_os, it->first) << ' ';
 			_writer_bits::writeToken(*_os, it->second->get());
 			*_os << std::endl;
+		      }
+		    }
 		  public:
 		    /// \name Execution of the writer
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing
 		    void run() {
 		      if (!_skip_nodes) {
 			writeNodes();
 		      } else {
 			createNodeIndex();
+		      }
 		      if (!_skip_arcs) {
 			writeArcs();
 		      } else {
 			createArcIndex();
+		      }
 		      writeAttributes();
+		    }
 		    /// \brief Gives back the stream of the writer
 		    ///
 		    /// Gives back the stream of the writer
 		    std::ostream& ostream() {
 		      return *_os;
+		    }
 		    /// @}
 		  };
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(std::ostream& os, Digraph& digraph) {
 		    DigraphWriter<Digraph> tmp(os, digraph);
 		    return tmp;
+		  }
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const std::string& fn,
 						       Digraph& digraph) {
 		    DigraphWriter<Digraph> tmp(fn, digraph);
 		    return tmp;
+		  }
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const char* fn, Digraph& digraph) {
 		    DigraphWriter<Digraph> tmp(fn, digraph);
 		    return tmp;
+		  }
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief LGF writer for directed graphs
 		  ///
 		  /// This utility writes an \ref lgf-format "LGF" file.
 		  template <typename _Graph>
 		  class GraphWriter {
 		  public:
 		    typedef _Graph Graph;
 		    TEMPLATE_GRAPH_TYPEDEFS(Graph);
@@ -1070,256 +1124,310 @@
 		    /// \brief Arc writing rule
 		    ///
 		    /// Add an arc writing rule to writer.
 		    GraphWriter& arc(const std::string& caption, const Arc& arc) {
 		      typedef _writer_bits::GraphArcLookUpConverter<Graph> Converter;
 		      Converter converter(_graph, _edge_index);
 		      _writer_bits::ValueStorageBase* storage =
 			new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \name Select section by name
 		    /// @{
 		    /// \brief Set \c \@nodes section to be read
 		    ///
 		    /// Set \c \@nodes section to be read
 		    GraphWriter& nodes(const std::string& caption) {
 		      _nodes_caption = caption;
 		      return *this;
+		    }
 		    /// \brief Set \c \@edges section to be read
 		    ///
 		    /// Set \c \@edges section to be read
 		    GraphWriter& edges(const std::string& caption) {
 		      _edges_caption = caption;
 		      return *this;
+		    }
 		    /// \brief Set \c \@attributes section to be read
 		    ///
 		    /// Set \c \@attributes section to be read
 		    GraphWriter& attributes(const std::string& caption) {
 		      _attributes_caption = caption;
 		      return *this;
+		    }
 		    /// \name Skipping section
 		    /// @{
 		    /// \brief Skip writing the node set
 		    ///
 		    /// The \c \@nodes section will be not written to the stream.
 		    GraphWriter& skipNodes() {
 		      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
 		      _skip_nodes = true;
 		      return *this;
+		    }
 		    /// \brief Skip writing edge set
 		    ///
 		    /// The \c \@edges section will be not written to the stream.
 		    GraphWriter& skipEdges() {
 		      LEMON_ASSERT(!_skip_edges, "Multiple usage of skipEdges() member");
 		      _skip_edges = true;
 		      return *this;
+		    }
 		    /// @}
 		  private:
 		    void writeNodes() {
 		      _writer_bits::MapStorageBase<Node>* label = 0;
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 		        if (it->first == "label") {
 			  label = it->second;
 			  break;
+			}
+		      }
 		      *_os << "@nodes";
 		      if (!_nodes_caption.empty()) {
 			_writer_bits::writeToken(*_os << ' ', _nodes_caption);
+		      }
 		      *_os << std::endl;
 		      if (label == 0) {
 			*_os << "label" << '\t';
+		      }
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 			_writer_bits::writeToken(*_os, it->first) << '\t';
+		      }
 		      *_os << std::endl;
 		      std::vector<Node> nodes;
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 			nodes.push_back(n);
+		      }
 		      if (label == 0) {
 			IdMap<Graph, Node> id_map(_graph);
 			_writer_bits::MapLess<IdMap<Graph, Node> > id_less(id_map);
 			std::sort(nodes.begin(), nodes.end(), id_less);
 		      } else {
 			label->sort(nodes);
+		      }
 		      for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
 			Node n = nodes[i];
 			if (label == 0) {
 			  std::ostringstream os;
 			  os << _graph.id(n);
 			  _writer_bits::writeToken(*_os, os.str());
 			  *_os << '\t';
 			  _node_index.insert(std::make_pair(n, os.str()));
+			}
 			for (typename NodeMaps::iterator it = _node_maps.begin();
 			     it != _node_maps.end(); ++it) {
 			  std::string value = it->second->get(n);
 			  _writer_bits::writeToken(*_os, value);
 			  if (it->first == "label") {
 			    _node_index.insert(std::make_pair(n, value));
+			  }
 			  *_os << '\t';
+			}
 			*_os << std::endl;
+		      }
+		    }
 		    void createNodeIndex() {
 		      _writer_bits::MapStorageBase<Node>* label = 0;
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 		        if (it->first == "label") {
 			  label = it->second;
 			  break;
+			}
+		      }
 		      if (label == 0) {
 			for (NodeIt n(_graph); n != INVALID; ++n) {
 			  std::ostringstream os;
 			  os << _graph.id(n);
 			  _node_index.insert(std::make_pair(n, os.str()));
+			}
 		      } else {
 			for (NodeIt n(_graph); n != INVALID; ++n) {
 			  std::string value = label->get(n);
 			  _node_index.insert(std::make_pair(n, value));
+			}
+		      }
+		    }
 		    void writeEdges() {
 		      _writer_bits::MapStorageBase<Edge>* label = 0;
 		      for (typename EdgeMaps::iterator it = _edge_maps.begin();
 			   it != _edge_maps.end(); ++it) {
 		        if (it->first == "label") {
 			  label = it->second;
 			  break;
+			}
+		      }
 		      *_os << "@edges";
 		      if (!_edges_caption.empty()) {
 			_writer_bits::writeToken(*_os << ' ', _edges_caption);
+		      }
 		      *_os << std::endl;
 		      *_os << '\t' << '\t';
 		      if (label == 0) {
 			*_os << "label" << '\t';
+		      }
 		      for (typename EdgeMaps::iterator it = _edge_maps.begin();
 			   it != _edge_maps.end(); ++it) {
 			_writer_bits::writeToken(*_os, it->first) << '\t';
+		      }
 		      *_os << std::endl;
 		      std::vector<Edge> edges;
 		      for (EdgeIt n(_graph); n != INVALID; ++n) {
 			edges.push_back(n);
+		      }
 		      if (label == 0) {
 			IdMap<Graph, Edge> id_map(_graph);
 			_writer_bits::MapLess<IdMap<Graph, Edge> > id_less(id_map);
 			std::sort(edges.begin(), edges.end(), id_less);
 		      } else {
 			label->sort(edges);
+		      }
 		      for (int i = 0; i < static_cast<int>(edges.size()); ++i) {
 			Edge e = edges[i];
 			_writer_bits::writeToken(*_os, _node_index.
 						 find(_graph.u(e))->second);
 			*_os << '\t';
 			_writer_bits::writeToken(*_os, _node_index.
 						 find(_graph.v(e))->second);
 			*_os << '\t';
 			if (label == 0) {
 			  std::ostringstream os;
 			  os << _graph.id(e);
 			  _writer_bits::writeToken(*_os, os.str());
 			  *_os << '\t';
 			  _edge_index.insert(std::make_pair(e, os.str()));
+			}
 			for (typename EdgeMaps::iterator it = _edge_maps.begin();
 			     it != _edge_maps.end(); ++it) {
 			  std::string value = it->second->get(e);
 			  _writer_bits::writeToken(*_os, value);
 			  if (it->first == "label") {
 			    _edge_index.insert(std::make_pair(e, value));
+			  }
 			  *_os << '\t';
+			}
 			*_os << std::endl;
+		      }
+		    }
 		    void createEdgeIndex() {
 		      _writer_bits::MapStorageBase<Edge>* label = 0;
 		      for (typename EdgeMaps::iterator it = _edge_maps.begin();
 			   it != _edge_maps.end(); ++it) {
 		        if (it->first == "label") {
 			  label = it->second;
 			  break;
+			}
+		      }
 		      if (label == 0) {
 			for (EdgeIt e(_graph); e != INVALID; ++e) {
 			  std::ostringstream os;
 			  os << _graph.id(e);
 			  _edge_index.insert(std::make_pair(e, os.str()));
+			}
 		      } else {
 			for (EdgeIt e(_graph); e != INVALID; ++e) {
 			  std::string value = label->get(e);
 			  _edge_index.insert(std::make_pair(e, value));
+			}
+		      }
+		    }
 		    void writeAttributes() {
 		      if (_attributes.empty()) return;
 		      *_os << "@attributes";
 		      if (!_attributes_caption.empty()) {
 			_writer_bits::writeToken(*_os << ' ', _attributes_caption);
+		      }
 		      *_os << std::endl;
 		      for (typename Attributes::iterator it = _attributes.begin();
 			   it != _attributes.end(); ++it) {
 			_writer_bits::writeToken(*_os, it->first) << ' ';
 			_writer_bits::writeToken(*_os, it->second->get());
 			*_os << std::endl;
+		      }
+		    }
 		  public:
 		    /// \name Execution of the writer
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing
 		    void run() {
 		      if (!_skip_nodes) {
 			writeNodes();
 		      } else {
 			createNodeIndex();
+		      }
 		      if (!_skip_edges) {
 			writeEdges();
 		      } else {
 			createEdgeIndex();
+		      }
 		      writeAttributes();
+		    }
 		    /// \brief Gives back the stream of the writer
 		    ///
 		    /// Gives back the stream of the writer
 		    std::ostream& ostream() {
 		      return *_os;
+		    }
 		    /// @}
 		  };
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(std::ostream& os, 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> tmp(fn, graph);
 		    return tmp;
+		  }
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const char* fn, Graph& graph) {
 		    GraphWriter<Graph> tmp(fn, graph);
 		    return tmp;
+		  }
+		}
 		#endif

0 comments (0 inline)

RhodeCode

Login to your account