1 /* -*- mode: C++; indent-tabs-mode: nil; -*-
3 * This file is a part of LEMON, a generic C++ optimization library.
5 * Copyright (C) 2003-2008
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all copies. For
11 * precise terms see the accompanying LICENSE file.
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
21 ///\brief \ref lgf-format "LEMON Graph Format" writer.
24 #ifndef LEMON_LGF_WRITER_H
25 #define LEMON_LGF_WRITER_H
36 #include <lemon/assert.h>
37 #include <lemon/core.h>
38 #include <lemon/maps.h>
40 #include <lemon/concept_check.h>
41 #include <lemon/concepts/maps.h>
45 namespace _writer_bits {
47 template <typename Value>
48 struct DefaultConverter {
49 std::string operator()(const Value& value) {
50 std::ostringstream os;
57 bool operator<(const T&, const T&) {
58 throw DataFormatError("Label map is not comparable");
61 template <typename _Map>
65 typedef typename Map::Key Item;
71 MapLess(const Map& map) : _map(map) {}
73 bool operator()(const Item& left, const Item& right) {
74 return _map[left] < _map[right];
78 template <typename _Graph, bool _dir, typename _Map>
79 class GraphArcMapLess {
83 typedef typename Graph::Edge Item;
90 GraphArcMapLess(const Graph& graph, const Map& map)
91 : _graph(graph), _map(map) {}
93 bool operator()(const Item& left, const Item& right) {
94 return _map[_graph.direct(left, _dir)] <
95 _map[_graph.direct(right, _dir)];
99 template <typename _Item>
100 class MapStorageBase {
106 virtual ~MapStorageBase() {}
108 virtual std::string get(const Item& item) = 0;
109 virtual void sort(std::vector<Item>&) = 0;
112 template <typename _Item, typename _Map,
113 typename _Converter = DefaultConverter<typename _Map::Value> >
114 class MapStorage : public MapStorageBase<_Item> {
117 typedef _Converter Converter;
122 Converter _converter;
125 MapStorage(const Map& map, const Converter& converter = Converter())
126 : _map(map), _converter(converter) {}
127 virtual ~MapStorage() {}
129 virtual std::string get(const Item& item) {
130 return _converter(_map[item]);
132 virtual void sort(std::vector<Item>& items) {
133 MapLess<Map> less(_map);
134 std::sort(items.begin(), items.end(), less);
138 template <typename _Graph, bool _dir, typename _Map,
139 typename _Converter = DefaultConverter<typename _Map::Value> >
140 class GraphArcMapStorage : public MapStorageBase<typename _Graph::Edge> {
143 typedef _Converter Converter;
144 typedef _Graph Graph;
145 typedef typename Graph::Edge Item;
146 static const bool dir = _dir;
151 Converter _converter;
154 GraphArcMapStorage(const Graph& graph, const Map& map,
155 const Converter& converter = Converter())
156 : _graph(graph), _map(map), _converter(converter) {}
157 virtual ~GraphArcMapStorage() {}
159 virtual std::string get(const Item& item) {
160 return _converter(_map[_graph.direct(item, dir)]);
162 virtual void sort(std::vector<Item>& items) {
163 GraphArcMapLess<Graph, dir, Map> less(_graph, _map);
164 std::sort(items.begin(), items.end(), less);
168 class ValueStorageBase {
170 ValueStorageBase() {}
171 virtual ~ValueStorageBase() {}
173 virtual std::string get() = 0;
176 template <typename _Value, typename _Converter = DefaultConverter<_Value> >
177 class ValueStorage : public ValueStorageBase {
179 typedef _Value Value;
180 typedef _Converter Converter;
184 Converter _converter;
187 ValueStorage(const Value& value, const Converter& converter = Converter())
188 : _value(value), _converter(converter) {}
190 virtual std::string get() {
191 return _converter(_value);
195 template <typename Value>
196 struct MapLookUpConverter {
197 const std::map<Value, std::string>& _map;
199 MapLookUpConverter(const std::map<Value, std::string>& map)
202 std::string operator()(const Value& str) {
203 typename std::map<Value, std::string>::const_iterator it =
205 if (it == _map.end()) {
206 throw DataFormatError("Item not found");
212 template <typename Graph>
213 struct GraphArcLookUpConverter {
215 const std::map<typename Graph::Edge, std::string>& _map;
217 GraphArcLookUpConverter(const Graph& graph,
218 const std::map<typename Graph::Edge,
220 : _graph(graph), _map(map) {}
222 std::string operator()(const typename Graph::Arc& val) {
223 typename std::map<typename Graph::Edge, std::string>
224 ::const_iterator it = _map.find(val);
225 if (it == _map.end()) {
226 throw DataFormatError("Item not found");
228 return (_graph.direction(val) ? '+' : '-') + it->second;
232 inline bool isWhiteSpace(char c) {
233 return c == ' ' || c == '\t' || c == '\v' ||
234 c == '\n' || c == '\r' || c == '\f';
237 inline bool isEscaped(char c) {
238 return c == '\\' || c == '\"' || c == '\'' ||
239 c == '\a' || c == '\b';
242 inline static void writeEscape(std::ostream& os, char c) {
273 std::ios::fmtflags flags = os.flags();
274 os << '\\' << std::oct << static_cast<int>(c);
283 inline bool requireEscape(const std::string& str) {
284 if (str.empty() || str[0] == '@') return true;
285 std::istringstream is(str);
288 if (isWhiteSpace(c) || isEscaped(c)) {
295 inline std::ostream& writeToken(std::ostream& os, const std::string& str) {
297 if (requireEscape(str)) {
299 for (std::string::const_iterator it = str.begin();
300 it != str.end(); ++it) {
301 writeEscape(os, *it);
312 virtual ~Section() {}
313 virtual void process(std::ostream& os) = 0;
316 template <typename Functor>
317 class LineSection : public Section {
324 LineSection(const Functor& functor) : _functor(functor) {}
325 virtual ~LineSection() {}
327 virtual void process(std::ostream& os) {
329 while (!(line = _functor()).empty()) os << line << std::endl;
333 template <typename Functor>
334 class StreamSection : public Section {
341 StreamSection(const Functor& functor) : _functor(functor) {}
342 virtual ~StreamSection() {}
344 virtual void process(std::ostream& os) {
351 template <typename Digraph>
354 template <typename Digraph>
355 DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
356 std::ostream& os = std::cout);
358 template <typename Digraph>
359 DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
360 const std::string& fn);
362 template <typename Digraph>
363 DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
366 /// \ingroup lemon_io
368 /// \brief \ref lgf-format "LGF" writer for directed graphs
370 /// This utility writes an \ref lgf-format "LGF" file.
372 /// The writing method does a batch processing. The user creates a
373 /// writer object, then various writing rules can be added to the
374 /// writer, and eventually the writing is executed with the \c run()
375 /// member function. A map writing rule can be added to the writer
376 /// with the \c nodeMap() or \c arcMap() members. An optional
377 /// converter parameter can also be added as a standard functor
378 /// converting from the value type of the map to \c std::string. If it
379 /// is set, it will determine how the value type of the map is written to
380 /// the output stream. If the functor is not set, then a default
381 /// conversion will be used. The \c attribute(), \c node() and \c
382 /// arc() functions are used to add attribute writing rules.
385 /// DigraphWriter<Digraph>(digraph, std::cout).
386 /// nodeMap("coordinates", coord_map).
387 /// nodeMap("size", size).
388 /// nodeMap("title", title).
389 /// arcMap("capacity", cap_map).
390 /// node("source", src).
391 /// node("target", trg).
392 /// attribute("caption", caption).
397 /// By default, the writer does not write additional captions to the
398 /// sections, but they can be give as an optional parameter of
399 /// the \c nodes(), \c arcs() or \c
400 /// attributes() functions.
402 /// The \c skipNodes() and \c skipArcs() functions forbid the
403 /// writing of the sections. If two arc sections should be written
404 /// to the output, it can be done in two passes, the first pass
405 /// writes the node section and the first arc section, then the
406 /// second pass skips the node section and writes just the arc
407 /// section to the stream. The output stream can be retrieved with
408 /// the \c ostream() function, hence the second pass can append its
409 /// output to the output of the first pass.
410 template <typename _Digraph>
411 class DigraphWriter {
414 typedef _Digraph Digraph;
415 TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
423 const Digraph& _digraph;
425 std::string _nodes_caption;
426 std::string _arcs_caption;
427 std::string _attributes_caption;
429 typedef std::map<Node, std::string> NodeIndex;
430 NodeIndex _node_index;
431 typedef std::map<Arc, std::string> ArcIndex;
434 typedef std::vector<std::pair<std::string,
435 _writer_bits::MapStorageBase<Node>* > > NodeMaps;
438 typedef std::vector<std::pair<std::string,
439 _writer_bits::MapStorageBase<Arc>* > >ArcMaps;
442 typedef std::vector<std::pair<std::string,
443 _writer_bits::ValueStorageBase*> > Attributes;
444 Attributes _attributes;
451 /// \brief Constructor
453 /// Construct a directed graph writer, which writes to the given
455 DigraphWriter(const Digraph& digraph, std::ostream& os = std::cout)
456 : _os(&os), local_os(false), _digraph(digraph),
457 _skip_nodes(false), _skip_arcs(false) {}
459 /// \brief Constructor
461 /// Construct a directed graph writer, which writes to the given
463 DigraphWriter(const Digraph& digraph, const std::string& fn)
464 : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),
465 _skip_nodes(false), _skip_arcs(false) {}
467 /// \brief Constructor
469 /// Construct a directed graph writer, which writes to the given
471 DigraphWriter(const Digraph& digraph, const char* fn)
472 : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),
473 _skip_nodes(false), _skip_arcs(false) {}
475 /// \brief Destructor
477 for (typename NodeMaps::iterator it = _node_maps.begin();
478 it != _node_maps.end(); ++it) {
482 for (typename ArcMaps::iterator it = _arc_maps.begin();
483 it != _arc_maps.end(); ++it) {
487 for (typename Attributes::iterator it = _attributes.begin();
488 it != _attributes.end(); ++it) {
499 friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,
501 friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,
502 const std::string& fn);
503 friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,
506 DigraphWriter(DigraphWriter& other)
507 : _os(other._os), local_os(other.local_os), _digraph(other._digraph),
508 _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
511 other.local_os = false;
513 _node_index.swap(other._node_index);
514 _arc_index.swap(other._arc_index);
516 _node_maps.swap(other._node_maps);
517 _arc_maps.swap(other._arc_maps);
518 _attributes.swap(other._attributes);
520 _nodes_caption = other._nodes_caption;
521 _arcs_caption = other._arcs_caption;
522 _attributes_caption = other._attributes_caption;
525 DigraphWriter& operator=(const DigraphWriter&);
529 /// \name Writing rules
532 /// \brief Node map writing rule
534 /// Add a node map writing rule to the writer.
535 template <typename Map>
536 DigraphWriter& nodeMap(const std::string& caption, const Map& map) {
537 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
538 _writer_bits::MapStorageBase<Node>* storage =
539 new _writer_bits::MapStorage<Node, Map>(map);
540 _node_maps.push_back(std::make_pair(caption, storage));
544 /// \brief Node map writing rule
546 /// Add a node map writing rule with specialized converter to the
548 template <typename Map, typename Converter>
549 DigraphWriter& nodeMap(const std::string& caption, const Map& map,
550 const Converter& converter = Converter()) {
551 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
552 _writer_bits::MapStorageBase<Node>* storage =
553 new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
554 _node_maps.push_back(std::make_pair(caption, storage));
558 /// \brief Arc map writing rule
560 /// Add an arc map writing rule to the writer.
561 template <typename Map>
562 DigraphWriter& arcMap(const std::string& caption, const Map& map) {
563 checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
564 _writer_bits::MapStorageBase<Arc>* storage =
565 new _writer_bits::MapStorage<Arc, Map>(map);
566 _arc_maps.push_back(std::make_pair(caption, storage));
570 /// \brief Arc map writing rule
572 /// Add an arc map writing rule with specialized converter to the
574 template <typename Map, typename Converter>
575 DigraphWriter& arcMap(const std::string& caption, const Map& map,
576 const Converter& converter = Converter()) {
577 checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
578 _writer_bits::MapStorageBase<Arc>* storage =
579 new _writer_bits::MapStorage<Arc, Map, Converter>(map, converter);
580 _arc_maps.push_back(std::make_pair(caption, storage));
584 /// \brief Attribute writing rule
586 /// Add an attribute writing rule to the writer.
587 template <typename Value>
588 DigraphWriter& attribute(const std::string& caption, const Value& value) {
589 _writer_bits::ValueStorageBase* storage =
590 new _writer_bits::ValueStorage<Value>(value);
591 _attributes.push_back(std::make_pair(caption, storage));
595 /// \brief Attribute writing rule
597 /// Add an attribute writing rule with specialized converter to the
599 template <typename Value, typename Converter>
600 DigraphWriter& attribute(const std::string& caption, const Value& value,
601 const Converter& converter = Converter()) {
602 _writer_bits::ValueStorageBase* storage =
603 new _writer_bits::ValueStorage<Value, Converter>(value, converter);
604 _attributes.push_back(std::make_pair(caption, storage));
608 /// \brief Node writing rule
610 /// Add a node writing rule to the writer.
611 DigraphWriter& node(const std::string& caption, const Node& node) {
612 typedef _writer_bits::MapLookUpConverter<Node> Converter;
613 Converter converter(_node_index);
614 _writer_bits::ValueStorageBase* storage =
615 new _writer_bits::ValueStorage<Node, Converter>(node, converter);
616 _attributes.push_back(std::make_pair(caption, storage));
620 /// \brief Arc writing rule
622 /// Add an arc writing rule to writer.
623 DigraphWriter& arc(const std::string& caption, const Arc& arc) {
624 typedef _writer_bits::MapLookUpConverter<Arc> Converter;
625 Converter converter(_arc_index);
626 _writer_bits::ValueStorageBase* storage =
627 new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
628 _attributes.push_back(std::make_pair(caption, storage));
632 /// \name Section captions
635 /// \brief Add an additional caption to the \c \@nodes section
637 /// Add an additional caption to the \c \@nodes section.
638 DigraphWriter& nodes(const std::string& caption) {
639 _nodes_caption = caption;
643 /// \brief Add an additional caption to the \c \@arcs section
645 /// Add an additional caption to the \c \@arcs section.
646 DigraphWriter& arcs(const std::string& caption) {
647 _arcs_caption = caption;
651 /// \brief Add an additional caption to the \c \@attributes section
653 /// Add an additional caption to the \c \@attributes section.
654 DigraphWriter& attributes(const std::string& caption) {
655 _attributes_caption = caption;
659 /// \name Skipping section
662 /// \brief Skip writing the node set
664 /// The \c \@nodes section will not be written to the stream.
665 DigraphWriter& skipNodes() {
666 LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
671 /// \brief Skip writing arc set
673 /// The \c \@arcs section will not be written to the stream.
674 DigraphWriter& skipArcs() {
675 LEMON_ASSERT(!_skip_arcs, "Multiple usage of skipArcs() member");
685 _writer_bits::MapStorageBase<Node>* label = 0;
686 for (typename NodeMaps::iterator it = _node_maps.begin();
687 it != _node_maps.end(); ++it) {
688 if (it->first == "label") {
695 if (!_nodes_caption.empty()) {
696 _writer_bits::writeToken(*_os << ' ', _nodes_caption);
701 *_os << "label" << '\t';
703 for (typename NodeMaps::iterator it = _node_maps.begin();
704 it != _node_maps.end(); ++it) {
705 _writer_bits::writeToken(*_os, it->first) << '\t';
709 std::vector<Node> nodes;
710 for (NodeIt n(_digraph); n != INVALID; ++n) {
715 IdMap<Digraph, Node> id_map(_digraph);
716 _writer_bits::MapLess<IdMap<Digraph, Node> > id_less(id_map);
717 std::sort(nodes.begin(), nodes.end(), id_less);
722 for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
725 std::ostringstream os;
726 os << _digraph.id(n);
727 _writer_bits::writeToken(*_os, os.str());
729 _node_index.insert(std::make_pair(n, os.str()));
731 for (typename NodeMaps::iterator it = _node_maps.begin();
732 it != _node_maps.end(); ++it) {
733 std::string value = it->second->get(n);
734 _writer_bits::writeToken(*_os, value);
735 if (it->first == "label") {
736 _node_index.insert(std::make_pair(n, value));
744 void createNodeIndex() {
745 _writer_bits::MapStorageBase<Node>* label = 0;
746 for (typename NodeMaps::iterator it = _node_maps.begin();
747 it != _node_maps.end(); ++it) {
748 if (it->first == "label") {
755 for (NodeIt n(_digraph); n != INVALID; ++n) {
756 std::ostringstream os;
757 os << _digraph.id(n);
758 _node_index.insert(std::make_pair(n, os.str()));
761 for (NodeIt n(_digraph); n != INVALID; ++n) {
762 std::string value = label->get(n);
763 _node_index.insert(std::make_pair(n, value));
769 _writer_bits::MapStorageBase<Arc>* label = 0;
770 for (typename ArcMaps::iterator it = _arc_maps.begin();
771 it != _arc_maps.end(); ++it) {
772 if (it->first == "label") {
779 if (!_arcs_caption.empty()) {
780 _writer_bits::writeToken(*_os << ' ', _arcs_caption);
784 *_os << '\t' << '\t';
786 *_os << "label" << '\t';
788 for (typename ArcMaps::iterator it = _arc_maps.begin();
789 it != _arc_maps.end(); ++it) {
790 _writer_bits::writeToken(*_os, it->first) << '\t';
794 std::vector<Arc> arcs;
795 for (ArcIt n(_digraph); n != INVALID; ++n) {
800 IdMap<Digraph, Arc> id_map(_digraph);
801 _writer_bits::MapLess<IdMap<Digraph, Arc> > id_less(id_map);
802 std::sort(arcs.begin(), arcs.end(), id_less);
807 for (int i = 0; i < static_cast<int>(arcs.size()); ++i) {
809 _writer_bits::writeToken(*_os, _node_index.
810 find(_digraph.source(a))->second);
812 _writer_bits::writeToken(*_os, _node_index.
813 find(_digraph.target(a))->second);
816 std::ostringstream os;
817 os << _digraph.id(a);
818 _writer_bits::writeToken(*_os, os.str());
820 _arc_index.insert(std::make_pair(a, os.str()));
822 for (typename ArcMaps::iterator it = _arc_maps.begin();
823 it != _arc_maps.end(); ++it) {
824 std::string value = it->second->get(a);
825 _writer_bits::writeToken(*_os, value);
826 if (it->first == "label") {
827 _arc_index.insert(std::make_pair(a, value));
835 void createArcIndex() {
836 _writer_bits::MapStorageBase<Arc>* label = 0;
837 for (typename ArcMaps::iterator it = _arc_maps.begin();
838 it != _arc_maps.end(); ++it) {
839 if (it->first == "label") {
846 for (ArcIt a(_digraph); a != INVALID; ++a) {
847 std::ostringstream os;
848 os << _digraph.id(a);
849 _arc_index.insert(std::make_pair(a, os.str()));
852 for (ArcIt a(_digraph); a != INVALID; ++a) {
853 std::string value = label->get(a);
854 _arc_index.insert(std::make_pair(a, value));
859 void writeAttributes() {
860 if (_attributes.empty()) return;
861 *_os << "@attributes";
862 if (!_attributes_caption.empty()) {
863 _writer_bits::writeToken(*_os << ' ', _attributes_caption);
866 for (typename Attributes::iterator it = _attributes.begin();
867 it != _attributes.end(); ++it) {
868 _writer_bits::writeToken(*_os, it->first) << ' ';
869 _writer_bits::writeToken(*_os, it->second->get());
876 /// \name Execution of the writer
879 /// \brief Start the batch processing
881 /// This function starts the batch processing.
896 /// \brief Give back the stream of the writer
898 /// Give back the stream of the writer.
899 std::ostream& ostream() {
906 /// \brief Return a \ref DigraphWriter class
908 /// This function just returns a \ref DigraphWriter class.
909 /// \relates DigraphWriter
910 template <typename Digraph>
911 DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
912 std::ostream& os = std::cout) {
913 DigraphWriter<Digraph> tmp(digraph, os);
917 /// \brief Return a \ref DigraphWriter class
919 /// This function just returns a \ref DigraphWriter class.
920 /// \relates DigraphWriter
921 template <typename Digraph>
922 DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
923 const std::string& fn) {
924 DigraphWriter<Digraph> tmp(digraph, fn);
928 /// \brief Return a \ref DigraphWriter class
930 /// This function just returns a \ref DigraphWriter class.
931 /// \relates DigraphWriter
932 template <typename Digraph>
933 DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
935 DigraphWriter<Digraph> tmp(digraph, fn);
939 template <typename Graph>
942 template <typename Graph>
943 GraphWriter<Graph> graphWriter(const Graph& graph,
944 std::ostream& os = std::cout);
946 template <typename Graph>
947 GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn);
949 template <typename Graph>
950 GraphWriter<Graph> graphWriter(const Graph& graph, const char *fn);
952 /// \ingroup lemon_io
954 /// \brief \ref lgf-format "LGF" writer for directed graphs
956 /// This utility writes an \ref lgf-format "LGF" file.
958 /// It can be used almost the same way as \c DigraphWriter.
959 /// The only difference is that this class can handle edges and
960 /// edge maps as well as arcs and arc maps.
962 /// The arc maps are written into the file as two columns, the
963 /// caption of the columns are the name of the map prefixed with \c
964 /// '+' and \c '-'. The arcs are written into the \c \@attributes
965 /// section as a \c '+' or a \c '-' prefix (depends on the direction
966 /// of the arc) and the label of corresponding edge.
967 template <typename _Graph>
971 typedef _Graph Graph;
972 TEMPLATE_GRAPH_TYPEDEFS(Graph);
982 std::string _nodes_caption;
983 std::string _edges_caption;
984 std::string _attributes_caption;
986 typedef std::map<Node, std::string> NodeIndex;
987 NodeIndex _node_index;
988 typedef std::map<Edge, std::string> EdgeIndex;
989 EdgeIndex _edge_index;
991 typedef std::vector<std::pair<std::string,
992 _writer_bits::MapStorageBase<Node>* > > NodeMaps;
995 typedef std::vector<std::pair<std::string,
996 _writer_bits::MapStorageBase<Edge>* > >EdgeMaps;
999 typedef std::vector<std::pair<std::string,
1000 _writer_bits::ValueStorageBase*> > Attributes;
1001 Attributes _attributes;
1008 /// \brief Constructor
1010 /// Construct a directed graph writer, which writes to the given
1012 GraphWriter(const Graph& graph, std::ostream& os = std::cout)
1013 : _os(&os), local_os(false), _graph(graph),
1014 _skip_nodes(false), _skip_edges(false) {}
1016 /// \brief Constructor
1018 /// Construct a directed graph writer, which writes to the given
1020 GraphWriter(const Graph& graph, const std::string& fn)
1021 : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
1022 _skip_nodes(false), _skip_edges(false) {}
1024 /// \brief Constructor
1026 /// Construct a directed graph writer, which writes to the given
1028 GraphWriter(const Graph& graph, const char* fn)
1029 : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
1030 _skip_nodes(false), _skip_edges(false) {}
1032 /// \brief Destructor
1034 for (typename NodeMaps::iterator it = _node_maps.begin();
1035 it != _node_maps.end(); ++it) {
1039 for (typename EdgeMaps::iterator it = _edge_maps.begin();
1040 it != _edge_maps.end(); ++it) {
1044 for (typename Attributes::iterator it = _attributes.begin();
1045 it != _attributes.end(); ++it) {
1056 friend GraphWriter<Graph> graphWriter<>(const Graph& graph,
1058 friend GraphWriter<Graph> graphWriter<>(const Graph& graph,
1059 const std::string& fn);
1060 friend GraphWriter<Graph> graphWriter<>(const Graph& graph,
1063 GraphWriter(GraphWriter& other)
1064 : _os(other._os), local_os(other.local_os), _graph(other._graph),
1065 _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
1068 other.local_os = false;
1070 _node_index.swap(other._node_index);
1071 _edge_index.swap(other._edge_index);
1073 _node_maps.swap(other._node_maps);
1074 _edge_maps.swap(other._edge_maps);
1075 _attributes.swap(other._attributes);
1077 _nodes_caption = other._nodes_caption;
1078 _edges_caption = other._edges_caption;
1079 _attributes_caption = other._attributes_caption;
1082 GraphWriter& operator=(const GraphWriter&);
1086 /// \name Writing rules
1089 /// \brief Node map writing rule
1091 /// Add a node map writing rule to the writer.
1092 template <typename Map>
1093 GraphWriter& nodeMap(const std::string& caption, const Map& map) {
1094 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
1095 _writer_bits::MapStorageBase<Node>* storage =
1096 new _writer_bits::MapStorage<Node, Map>(map);
1097 _node_maps.push_back(std::make_pair(caption, storage));
1101 /// \brief Node map writing rule
1103 /// Add a node map writing rule with specialized converter to the
1105 template <typename Map, typename Converter>
1106 GraphWriter& nodeMap(const std::string& caption, const Map& map,
1107 const Converter& converter = Converter()) {
1108 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
1109 _writer_bits::MapStorageBase<Node>* storage =
1110 new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
1111 _node_maps.push_back(std::make_pair(caption, storage));
1115 /// \brief Edge map writing rule
1117 /// Add an edge map writing rule to the writer.
1118 template <typename Map>
1119 GraphWriter& edgeMap(const std::string& caption, const Map& map) {
1120 checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
1121 _writer_bits::MapStorageBase<Edge>* storage =
1122 new _writer_bits::MapStorage<Edge, Map>(map);
1123 _edge_maps.push_back(std::make_pair(caption, storage));
1127 /// \brief Edge map writing rule
1129 /// Add an edge map writing rule with specialized converter to the
1131 template <typename Map, typename Converter>
1132 GraphWriter& edgeMap(const std::string& caption, const Map& map,
1133 const Converter& converter = Converter()) {
1134 checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
1135 _writer_bits::MapStorageBase<Edge>* storage =
1136 new _writer_bits::MapStorage<Edge, Map, Converter>(map, converter);
1137 _edge_maps.push_back(std::make_pair(caption, storage));
1141 /// \brief Arc map writing rule
1143 /// Add an arc map writing rule to the writer.
1144 template <typename Map>
1145 GraphWriter& arcMap(const std::string& caption, const Map& map) {
1146 checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
1147 _writer_bits::MapStorageBase<Edge>* forward_storage =
1148 new _writer_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
1149 _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
1150 _writer_bits::MapStorageBase<Edge>* backward_storage =
1151 new _writer_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
1152 _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
1156 /// \brief Arc map writing rule
1158 /// Add an arc map writing rule with specialized converter to the
1160 template <typename Map, typename Converter>
1161 GraphWriter& arcMap(const std::string& caption, const Map& map,
1162 const Converter& converter = Converter()) {
1163 checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
1164 _writer_bits::MapStorageBase<Edge>* forward_storage =
1165 new _writer_bits::GraphArcMapStorage<Graph, true, Map, Converter>
1166 (_graph, map, converter);
1167 _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
1168 _writer_bits::MapStorageBase<Edge>* backward_storage =
1169 new _writer_bits::GraphArcMapStorage<Graph, false, Map, Converter>
1170 (_graph, map, converter);
1171 _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
1175 /// \brief Attribute writing rule
1177 /// Add an attribute writing rule to the writer.
1178 template <typename Value>
1179 GraphWriter& attribute(const std::string& caption, const Value& value) {
1180 _writer_bits::ValueStorageBase* storage =
1181 new _writer_bits::ValueStorage<Value>(value);
1182 _attributes.push_back(std::make_pair(caption, storage));
1186 /// \brief Attribute writing rule
1188 /// Add an attribute writing rule with specialized converter to the
1190 template <typename Value, typename Converter>
1191 GraphWriter& attribute(const std::string& caption, const Value& value,
1192 const Converter& converter = Converter()) {
1193 _writer_bits::ValueStorageBase* storage =
1194 new _writer_bits::ValueStorage<Value, Converter>(value, converter);
1195 _attributes.push_back(std::make_pair(caption, storage));
1199 /// \brief Node writing rule
1201 /// Add a node writing rule to the writer.
1202 GraphWriter& node(const std::string& caption, const Node& node) {
1203 typedef _writer_bits::MapLookUpConverter<Node> Converter;
1204 Converter converter(_node_index);
1205 _writer_bits::ValueStorageBase* storage =
1206 new _writer_bits::ValueStorage<Node, Converter>(node, converter);
1207 _attributes.push_back(std::make_pair(caption, storage));
1211 /// \brief Edge writing rule
1213 /// Add an edge writing rule to writer.
1214 GraphWriter& edge(const std::string& caption, const Edge& edge) {
1215 typedef _writer_bits::MapLookUpConverter<Edge> Converter;
1216 Converter converter(_edge_index);
1217 _writer_bits::ValueStorageBase* storage =
1218 new _writer_bits::ValueStorage<Edge, Converter>(edge, converter);
1219 _attributes.push_back(std::make_pair(caption, storage));
1223 /// \brief Arc writing rule
1225 /// Add an arc writing rule to writer.
1226 GraphWriter& arc(const std::string& caption, const Arc& arc) {
1227 typedef _writer_bits::GraphArcLookUpConverter<Graph> Converter;
1228 Converter converter(_graph, _edge_index);
1229 _writer_bits::ValueStorageBase* storage =
1230 new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
1231 _attributes.push_back(std::make_pair(caption, storage));
1235 /// \name Section captions
1238 /// \brief Add an additional caption to the \c \@nodes section
1240 /// Add an additional caption to the \c \@nodes section.
1241 GraphWriter& nodes(const std::string& caption) {
1242 _nodes_caption = caption;
1246 /// \brief Add an additional caption to the \c \@arcs section
1248 /// Add an additional caption to the \c \@arcs section.
1249 GraphWriter& edges(const std::string& caption) {
1250 _edges_caption = caption;
1254 /// \brief Add an additional caption to the \c \@attributes section
1256 /// Add an additional caption to the \c \@attributes section.
1257 GraphWriter& attributes(const std::string& caption) {
1258 _attributes_caption = caption;
1262 /// \name Skipping section
1265 /// \brief Skip writing the node set
1267 /// The \c \@nodes section will not be written to the stream.
1268 GraphWriter& skipNodes() {
1269 LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
1274 /// \brief Skip writing edge set
1276 /// The \c \@edges section will not be written to the stream.
1277 GraphWriter& skipEdges() {
1278 LEMON_ASSERT(!_skip_edges, "Multiple usage of skipEdges() member");
1288 _writer_bits::MapStorageBase<Node>* label = 0;
1289 for (typename NodeMaps::iterator it = _node_maps.begin();
1290 it != _node_maps.end(); ++it) {
1291 if (it->first == "label") {
1298 if (!_nodes_caption.empty()) {
1299 _writer_bits::writeToken(*_os << ' ', _nodes_caption);
1304 *_os << "label" << '\t';
1306 for (typename NodeMaps::iterator it = _node_maps.begin();
1307 it != _node_maps.end(); ++it) {
1308 _writer_bits::writeToken(*_os, it->first) << '\t';
1312 std::vector<Node> nodes;
1313 for (NodeIt n(_graph); n != INVALID; ++n) {
1318 IdMap<Graph, Node> id_map(_graph);
1319 _writer_bits::MapLess<IdMap<Graph, Node> > id_less(id_map);
1320 std::sort(nodes.begin(), nodes.end(), id_less);
1325 for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
1328 std::ostringstream os;
1330 _writer_bits::writeToken(*_os, os.str());
1332 _node_index.insert(std::make_pair(n, os.str()));
1334 for (typename NodeMaps::iterator it = _node_maps.begin();
1335 it != _node_maps.end(); ++it) {
1336 std::string value = it->second->get(n);
1337 _writer_bits::writeToken(*_os, value);
1338 if (it->first == "label") {
1339 _node_index.insert(std::make_pair(n, value));
1347 void createNodeIndex() {
1348 _writer_bits::MapStorageBase<Node>* label = 0;
1349 for (typename NodeMaps::iterator it = _node_maps.begin();
1350 it != _node_maps.end(); ++it) {
1351 if (it->first == "label") {
1358 for (NodeIt n(_graph); n != INVALID; ++n) {
1359 std::ostringstream os;
1361 _node_index.insert(std::make_pair(n, os.str()));
1364 for (NodeIt n(_graph); n != INVALID; ++n) {
1365 std::string value = label->get(n);
1366 _node_index.insert(std::make_pair(n, value));
1372 _writer_bits::MapStorageBase<Edge>* label = 0;
1373 for (typename EdgeMaps::iterator it = _edge_maps.begin();
1374 it != _edge_maps.end(); ++it) {
1375 if (it->first == "label") {
1382 if (!_edges_caption.empty()) {
1383 _writer_bits::writeToken(*_os << ' ', _edges_caption);
1387 *_os << '\t' << '\t';
1389 *_os << "label" << '\t';
1391 for (typename EdgeMaps::iterator it = _edge_maps.begin();
1392 it != _edge_maps.end(); ++it) {
1393 _writer_bits::writeToken(*_os, it->first) << '\t';
1397 std::vector<Edge> edges;
1398 for (EdgeIt n(_graph); n != INVALID; ++n) {
1403 IdMap<Graph, Edge> id_map(_graph);
1404 _writer_bits::MapLess<IdMap<Graph, Edge> > id_less(id_map);
1405 std::sort(edges.begin(), edges.end(), id_less);
1410 for (int i = 0; i < static_cast<int>(edges.size()); ++i) {
1412 _writer_bits::writeToken(*_os, _node_index.
1413 find(_graph.u(e))->second);
1415 _writer_bits::writeToken(*_os, _node_index.
1416 find(_graph.v(e))->second);
1419 std::ostringstream os;
1421 _writer_bits::writeToken(*_os, os.str());
1423 _edge_index.insert(std::make_pair(e, os.str()));
1425 for (typename EdgeMaps::iterator it = _edge_maps.begin();
1426 it != _edge_maps.end(); ++it) {
1427 std::string value = it->second->get(e);
1428 _writer_bits::writeToken(*_os, value);
1429 if (it->first == "label") {
1430 _edge_index.insert(std::make_pair(e, value));
1438 void createEdgeIndex() {
1439 _writer_bits::MapStorageBase<Edge>* label = 0;
1440 for (typename EdgeMaps::iterator it = _edge_maps.begin();
1441 it != _edge_maps.end(); ++it) {
1442 if (it->first == "label") {
1449 for (EdgeIt e(_graph); e != INVALID; ++e) {
1450 std::ostringstream os;
1452 _edge_index.insert(std::make_pair(e, os.str()));
1455 for (EdgeIt e(_graph); e != INVALID; ++e) {
1456 std::string value = label->get(e);
1457 _edge_index.insert(std::make_pair(e, value));
1462 void writeAttributes() {
1463 if (_attributes.empty()) return;
1464 *_os << "@attributes";
1465 if (!_attributes_caption.empty()) {
1466 _writer_bits::writeToken(*_os << ' ', _attributes_caption);
1469 for (typename Attributes::iterator it = _attributes.begin();
1470 it != _attributes.end(); ++it) {
1471 _writer_bits::writeToken(*_os, it->first) << ' ';
1472 _writer_bits::writeToken(*_os, it->second->get());
1479 /// \name Execution of the writer
1482 /// \brief Start the batch processing
1484 /// This function starts the batch processing.
1499 /// \brief Give back the stream of the writer
1501 /// Give back the stream of the writer
1502 std::ostream& ostream() {
1509 /// \brief Return a \ref GraphWriter class
1511 /// This function just returns a \ref GraphWriter class.
1512 /// \relates GraphWriter
1513 template <typename Graph>
1514 GraphWriter<Graph> graphWriter(const Graph& graph,
1515 std::ostream& os = std::cout) {
1516 GraphWriter<Graph> tmp(graph, os);
1520 /// \brief Return a \ref GraphWriter class
1522 /// This function just returns a \ref GraphWriter class.
1523 /// \relates GraphWriter
1524 template <typename Graph>
1525 GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
1526 GraphWriter<Graph> tmp(graph, fn);
1530 /// \brief Return a \ref GraphWriter class
1532 /// This function just returns a \ref GraphWriter class.
1533 /// \relates GraphWriter
1534 template <typename Graph>
1535 GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
1536 GraphWriter<Graph> tmp(graph, fn);
1540 class SectionWriter;
1542 SectionWriter sectionWriter(std::istream& is);
1543 SectionWriter sectionWriter(const std::string& fn);
1544 SectionWriter sectionWriter(const char* fn);
1546 /// \ingroup lemon_io
1548 /// \brief Section writer class
1550 /// In the \ref lgf-format "LGF" file extra sections can be placed,
1551 /// which contain any data in arbitrary format. Such sections can be
1552 /// written with this class. A writing rule can be added to the
1553 /// class with two different functions. With the \c sectionLines()
1554 /// function a generator can write the section line-by-line, while
1555 /// with the \c sectionStream() member the section can be written to
1556 /// an output stream.
1557 class SectionWriter {
1563 typedef std::vector<std::pair<std::string, _writer_bits::Section*> >
1570 /// \brief Constructor
1572 /// Construct a section writer, which writes to the given output
1574 SectionWriter(std::ostream& os)
1575 : _os(&os), local_os(false) {}
1577 /// \brief Constructor
1579 /// Construct a section writer, which writes into the given file.
1580 SectionWriter(const std::string& fn)
1581 : _os(new std::ofstream(fn.c_str())), local_os(true) {}
1583 /// \brief Constructor
1585 /// Construct a section writer, which writes into the given file.
1586 SectionWriter(const char* fn)
1587 : _os(new std::ofstream(fn)), local_os(true) {}
1589 /// \brief Destructor
1591 for (Sections::iterator it = _sections.begin();
1592 it != _sections.end(); ++it) {
1604 friend SectionWriter sectionWriter(std::ostream& os);
1605 friend SectionWriter sectionWriter(const std::string& fn);
1606 friend SectionWriter sectionWriter(const char* fn);
1608 SectionWriter(SectionWriter& other)
1609 : _os(other._os), local_os(other.local_os) {
1612 other.local_os = false;
1614 _sections.swap(other._sections);
1617 SectionWriter& operator=(const SectionWriter&);
1621 /// \name Section writers
1624 /// \brief Add a section writer with line oriented writing
1626 /// The first parameter is the type descriptor of the section, the
1627 /// second is a generator with std::string values. At the writing
1628 /// process, the returned \c std::string will be written into the
1629 /// output file until it is an empty string.
1631 /// For example, an integer vector is written into a section.
1639 /// The generator is implemented as a struct.
1641 /// struct NumberSection {
1642 /// std::vector<int>::const_iterator _it, _end;
1643 /// NumberSection(const std::vector<int>& data)
1644 /// : _it(data.begin()), _end(data.end()) {}
1645 /// std::string operator()() {
1646 /// int rem_in_line = 4;
1647 /// std::ostringstream ls;
1648 /// while (rem_in_line > 0 && _it != _end) {
1649 /// ls << *(_it++) << ' ';
1652 /// return ls.str();
1658 /// writer.sectionLines("numbers", NumberSection(vec));
1660 template <typename Functor>
1661 SectionWriter& sectionLines(const std::string& type, Functor functor) {
1662 LEMON_ASSERT(!type.empty(), "Type is empty.");
1663 _sections.push_back(std::make_pair(type,
1664 new _writer_bits::LineSection<Functor>(functor)));
1669 /// \brief Add a section writer with stream oriented writing
1671 /// The first parameter is the type of the section, the second is
1672 /// a functor, which takes a \c std::ostream& parameter. The
1673 /// functor writes the section to the output stream.
1674 /// \warning The last line must be closed with end-line character.
1675 template <typename Functor>
1676 SectionWriter& sectionStream(const std::string& type, Functor functor) {
1677 LEMON_ASSERT(!type.empty(), "Type is empty.");
1678 _sections.push_back(std::make_pair(type,
1679 new _writer_bits::StreamSection<Functor>(functor)));
1688 /// \name Execution of the writer
1691 /// \brief Start the batch processing
1693 /// This function starts the batch processing.
1696 LEMON_ASSERT(_os != 0, "This writer is assigned to an other writer");
1698 for (Sections::iterator it = _sections.begin();
1699 it != _sections.end(); ++it) {
1700 (*_os) << '@' << it->first << std::endl;
1701 it->second->process(*_os);
1705 /// \brief Give back the stream of the writer
1707 /// Returns the stream of the writer
1708 std::ostream& ostream() {
1716 /// \brief Return a \ref SectionWriter class
1718 /// This function just returns a \ref SectionWriter class.
1719 /// \relates SectionWriter
1720 inline SectionWriter sectionWriter(std::ostream& os) {
1721 SectionWriter tmp(os);
1725 /// \brief Return a \ref SectionWriter class
1727 /// This function just returns a \ref SectionWriter class.
1728 /// \relates SectionWriter
1729 inline SectionWriter sectionWriter(const std::string& fn) {
1730 SectionWriter tmp(fn);
1734 /// \brief Return a \ref SectionWriter class
1736 /// This function just returns a \ref SectionWriter class.
1737 /// \relates SectionWriter
1738 inline SectionWriter sectionWriter(const char* fn) {
1739 SectionWriter tmp(fn);