lemon-1.0: comparison lemon/lgf

equal deleted inserted replaced

-:bda14aa11159
+:e5c488f9c398
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
-* This file is a part of LEMON, a generic C++ optimization library
+* This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 namespace _writer_bits {
 template <typename Value>
 struct DefaultConverter {
 std::string operator()(const Value& value) {
-	std::ostringstream os;
+std::ostringstream os;
-	os << value;
+os << value;
-	return os.str();
+return os.str();
 }
 };
 template <typename T>
 bool operator<(const T&, const T&) {
 typedef _Map Map;
 typedef typename Map::Key Item;
 private:
 const Map& _map;
 public:
 MapLess(const Map& map) : _map(map) {}
 bool operator()(const Item& left, const Item& right) {
-	return _map[left] < _map[right];
+return _map[left] < _map[right];
 }
 };
 template <typename _Graph, bool _dir, typename _Map>
 class GraphArcMapLess {
 typedef typename Graph::Edge Item;
 private:
 const Graph& _graph;
 const Map& _map;
 public:
 GraphArcMapLess(const Graph& graph, const Map& map)
-	: _graph(graph), _map(map) {}
+: _graph(graph), _map(map) {}
 bool operator()(const Item& left, const Item& right) {
-	return _map[_graph.direct(left, _dir)] <
+return _map[_graph.direct(left, _dir)] <
-	  _map[_graph.direct(right, _dir)];
+_map[_graph.direct(right, _dir)];
 }
 };
 template <typename _Item>
 class MapStorageBase {
 public:
 typedef _Item Item;
 public:
 virtual std::string get(const Item& item) = 0;
 virtual void sort(std::vector<Item>&) = 0;
 };
 template <typename _Item, typename _Map,
-	      typename _Converter = DefaultConverter<typename _Map::Value> >
+typename _Converter = DefaultConverter<typename _Map::Value> >
 class MapStorage : public MapStorageBase<_Item> {
 public:
 typedef _Map Map;
 typedef _Converter Converter;
 typedef _Item Item;
 private:
 const Map& _map;
 Converter _converter;
 public:
 MapStorage(const Map& map, const Converter& converter = Converter())
-	: _map(map), _converter(converter) {}
+: _map(map), _converter(converter) {}
 virtual ~MapStorage() {}
 virtual std::string get(const Item& item) {
-	return _converter(_map[item]);
+return _converter(_map[item]);
 }
 virtual void sort(std::vector<Item>& items) {
-	MapLess<Map> less(_map);
+MapLess<Map> less(_map);
-	std::sort(items.begin(), items.end(), less);
+std::sort(items.begin(), items.end(), less);
 }
 };
 template <typename _Graph, bool _dir, typename _Map,
-	      typename _Converter = DefaultConverter<typename _Map::Value> >
+typename _Converter = DefaultConverter<typename _Map::Value> >
 class GraphArcMapStorage : public MapStorageBase<typename _Graph::Edge> {
 public:
 typedef _Map Map;
 typedef _Converter Converter;
 typedef _Graph Graph;
 typedef typename Graph::Edge Item;
 static const bool dir = _dir;
 private:
 const Graph& _graph;
 const Map& _map;
 Converter _converter;
 public:
 GraphArcMapStorage(const Graph& graph, const Map& map,
-			 const Converter& converter = Converter())
+const Converter& converter = Converter())
-	: _graph(graph), _map(map), _converter(converter) {}
+: _graph(graph), _map(map), _converter(converter) {}
 virtual ~GraphArcMapStorage() {}
 virtual std::string get(const Item& item) {
-	return _converter(_map[_graph.direct(item, dir)]);
+return _converter(_map[_graph.direct(item, dir)]);
 }
 virtual void sort(std::vector<Item>& items) {
-	GraphArcMapLess<Graph, dir, Map> less(_graph, _map);
+GraphArcMapLess<Graph, dir, Map> less(_graph, _map);
-	std::sort(items.begin(), items.end(), less);
+std::sort(items.begin(), items.end(), less);
 }
 };
 class ValueStorageBase {
 public:
 ValueStorageBase() {}
 virtual ~ValueStorageBase() {}
 virtual std::string get() = 0;
 };
 template <typename _Value, typename _Converter = DefaultConverter<_Value> >
 class ValueStorage : public ValueStorageBase {
 public:
 const Value& _value;
 Converter _converter;
 public:
 ValueStorage(const Value& value, const Converter& converter = Converter())
-	: _value(value), _converter(converter) {}
+: _value(value), _converter(converter) {}
 virtual std::string get() {
-	return _converter(_value);
+return _converter(_value);
 }
 };
 template <typename Value>
 struct MapLookUpConverter {
 const std::map<Value, std::string>& _map;
 MapLookUpConverter(const std::map<Value, std::string>& map)
-	: _map(map) {}
+: _map(map) {}
 std::string operator()(const Value& str) {
-	typename std::map<Value, std::string>::const_iterator it =
+typename std::map<Value, std::string>::const_iterator it =
-	  _map.find(str);
+_map.find(str);
-	if (it == _map.end()) {
+if (it == _map.end()) {
-	  throw DataFormatError("Item not found");
+throw DataFormatError("Item not found");
-	}
+}
-	return it->second;
+return it->second;
 }
 };
 template <typename Graph>
 struct GraphArcLookUpConverter {
 const Graph& _graph;
 const std::map<typename Graph::Edge, std::string>& _map;
 GraphArcLookUpConverter(const Graph& graph,
-			      const std::map<typename Graph::Edge,
+const std::map<typename Graph::Edge,
-			                     std::string>& map)
+std::string>& map)
-	: _graph(graph), _map(map) {}
+: _graph(graph), _map(map) {}
 std::string operator()(const typename Graph::Arc& val) {
-	typename std::map<typename Graph::Edge, std::string>
+typename std::map<typename Graph::Edge, std::string>
-	  ::const_iterator it = _map.find(val);
+::const_iterator it = _map.find(val);
-	if (it == _map.end()) {
+if (it == _map.end()) {
-	  throw DataFormatError("Item not found");
+throw DataFormatError("Item not found");
-	}
+}
-	return (_graph.direction(val) ? '+' : '-') + it->second;
+return (_graph.direction(val) ? '+' : '-') + it->second;
 }
 };
 inline bool isWhiteSpace(char c) {
 return c == ' ' || c == '\t' || c == '\v' ||
 c == '\n' || c == '\r' || c == '\f';
 }
 inline bool isEscaped(char c) {
 return c == '\\' || c == '\"' || c == '\'' ||
-	c == '\a' || c == '\b';
+c == '\a' || c == '\b';
 }
 inline static void writeEscape(std::ostream& os, char c) {
 switch (c) {
 case '\\':
-	os << "\\\\";
+os << "\\\\";
-	return;
+return;
 case '\"':
-	os << "\\\"";
+os << "\\\"";
-	return;
+return;
 case '\a':
-	os << "\\a";
+os << "\\a";
-	return;
+return;
 case '\b':
-	os << "\\b";
+os << "\\b";
-	return;
+return;
 case '\f':
-	os << "\\f";
+os << "\\f";
-	return;
+return;
 case '\r':
-	os << "\\r";
+os << "\\r";
-	return;
+return;
 case '\n':
-	os << "\\n";
+os << "\\n";
-	return;
+return;
 case '\t':
-	os << "\\t";
+os << "\\t";
-	return;
+return;
 case '\v':
-	os << "\\v";
+os << "\\v";
-	return;
+return;
 default:
-	if (c < 0x20) {
+if (c < 0x20) {
-	  std::ios::fmtflags flags = os.flags();
+std::ios::fmtflags flags = os.flags();
-	  os << '\\' << std::oct << static_cast<int>(c);
+os << '\\' << std::oct << static_cast<int>(c);
-	  os.flags(flags);
+os.flags(flags);
-	} else {
+} else {
-	  os << c;
+os << c;
-	}
+}
-	return;
+return;
 }
 }
 inline bool requireEscape(const std::string& str) {
 if (str.empty() || str[0] == '@') return true;
 std::istringstream is(str);
 char c;
 while (is.get(c)) {
-	if (isWhiteSpace(c) || isEscaped(c)) {
+if (isWhiteSpace(c) || isEscaped(c)) {
-	  return true;
+return true;
-	}
+}
 }
 return false;
 }
 inline std::ostream& writeToken(std::ostream& os, const std::string& str) {
 if (requireEscape(str)) {
-	os << '\"';
+os << '\"';
-	for (std::string::const_iterator it = str.begin();
+for (std::string::const_iterator it = str.begin();
-	     it != str.end(); ++it) {
+it != str.end(); ++it) {
-	  writeEscape(os, *it);
+writeEscape(os, *it);
-	}
+}
-	os << '\"';
+os << '\"';
 } else {
-	os << str;
+os << str;
 }
 return os;
 }
 }
 template <typename Digraph>
 class DigraphWriter;
 template <typename Digraph>
 DigraphWriter<Digraph> digraphWriter(std::ostream& os,
-				       const Digraph& digraph);
+const Digraph& digraph);
 template <typename Digraph>
 DigraphWriter<Digraph> digraphWriter(const std::string& fn,
-				       const Digraph& digraph);
+const Digraph& digraph);
 template <typename Digraph>
 DigraphWriter<Digraph> digraphWriter(const char *fn,
-				       const Digraph& digraph);
+const Digraph& digraph);
 /// \ingroup lemon_io
 ///
 /// \brief \ref lgf-format "LGF" writer for directed graphs
 ///
 /// This utility writes an \ref lgf-format "LGF" file.
 ///
 /// The writing method does a batch processing. The user creates a
 class DigraphWriter {
 public:
 typedef _Digraph Digraph;
 TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 private:
 std::ostream* _os;
 bool local_os;
 const Digraph& _digraph;
 std::string _nodes_caption;
 std::string _arcs_caption;
 std::string _attributes_caption;
 typedef std::map<Node, std::string> NodeIndex;
 NodeIndex _node_index;
 typedef std::map<Arc, std::string> ArcIndex;
 ArcIndex _arc_index;
 typedef std::vector<std::pair<std::string,
 _writer_bits::MapStorageBase<Node>* > > NodeMaps;
 NodeMaps _node_maps;
 typedef std::vector<std::pair<std::string,
 _writer_bits::MapStorageBase<Arc>* > >ArcMaps;
 ArcMaps _arc_maps;
 typedef std::vector<std::pair<std::string,
 _writer_bits::ValueStorageBase*> > Attributes;
 Attributes _attributes;
 bool _skip_nodes;
 bool _skip_arcs;
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output stream.
 DigraphWriter(std::ostream& is, const Digraph& digraph)
 : _os(&is), local_os(false), _digraph(digraph),
-	_skip_nodes(false), _skip_arcs(false) {}
+_skip_nodes(false), _skip_arcs(false) {}
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output file.
 DigraphWriter(const std::string& fn, const Digraph& digraph)
 : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),
-	_skip_nodes(false), _skip_arcs(false) {}
+_skip_nodes(false), _skip_arcs(false) {}
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output file.
 DigraphWriter(const char* fn, const Digraph& digraph)
 : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),
-	_skip_nodes(false), _skip_arcs(false) {}
+_skip_nodes(false), _skip_arcs(false) {}
 /// \brief Destructor
 ~DigraphWriter() {
 for (typename NodeMaps::iterator it = _node_maps.begin();
-	   it != _node_maps.end(); ++it) {
+it != _node_maps.end(); ++it) {
-	delete it->second;
+delete it->second;
 }
 for (typename ArcMaps::iterator it = _arc_maps.begin();
-	   it != _arc_maps.end(); ++it) {
+it != _arc_maps.end(); ++it) {
-	delete it->second;
+delete it->second;
 }
 for (typename Attributes::iterator it = _attributes.begin();
-	   it != _attributes.end(); ++it) {
+it != _attributes.end(); ++it) {
-	delete it->second;
+delete it->second;
 }
 if (local_os) {
-	delete _os;
+delete _os;
 }
 }
 private:
 friend DigraphWriter<Digraph> digraphWriter<>(std::ostream& os,
-						  const Digraph& digraph);
+const Digraph& digraph);
 friend DigraphWriter<Digraph> digraphWriter<>(const std::string& fn,
-						  const Digraph& digraph);
+const Digraph& digraph);
 friend DigraphWriter<Digraph> digraphWriter<>(const char *fn,
-						  const Digraph& digraph);
+const Digraph& digraph);
 DigraphWriter(DigraphWriter& other)
 : _os(other._os), local_os(other.local_os), _digraph(other._digraph),
-	_skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
+_skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
 other._os = 0;
 other.local_os = false;
 _node_index.swap(other._node_index);
 _nodes_caption = other._nodes_caption;
 _arcs_caption = other._arcs_caption;
 _attributes_caption = other._attributes_caption;
 }
 DigraphWriter& operator=(const DigraphWriter&);
 public:
 /// \name Writing rules
 /// @{
 /// \brief Node map writing rule
 ///
 /// Add a node map writing rule to the writer.
 template <typename Map>
 DigraphWriter& nodeMap(const std::string& caption, const Map& map) {
 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Node>* storage =
-	new _writer_bits::MapStorage<Node, Map>(map);
+new _writer_bits::MapStorage<Node, Map>(map);
 _node_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Node map writing rule
 ///
 /// Add a node map writing rule with specialized converter to the
 /// writer.
 template <typename Map, typename Converter>
 DigraphWriter& nodeMap(const std::string& caption, const Map& map,
-			   const Converter& converter = Converter()) {
+const Converter& converter = Converter()) {
 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Node>* storage =
-	new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
+new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
 _node_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Arc map writing rule
 ///
 /// Add an arc map writing rule to the writer.
 template <typename Map>
 DigraphWriter& arcMap(const std::string& caption, const Map& map) {
 checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Arc>* storage =
-	new _writer_bits::MapStorage<Arc, Map>(map);
+new _writer_bits::MapStorage<Arc, Map>(map);
 _arc_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Arc map writing rule
 ///
 /// Add an arc map writing rule with specialized converter to the
 /// writer.
 template <typename Map, typename Converter>
 DigraphWriter& arcMap(const std::string& caption, const Map& map,
-			  const Converter& converter = Converter()) {
+const Converter& converter = Converter()) {
 checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Arc>* storage =
-	new _writer_bits::MapStorage<Arc, Map, Converter>(map, converter);
+new _writer_bits::MapStorage<Arc, Map, Converter>(map, converter);
 _arc_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Attribute writing rule
 ///
 /// Add an attribute writing rule to the writer.
 template <typename Value>
 DigraphWriter& attribute(const std::string& caption, const Value& value) {
 _writer_bits::ValueStorageBase* storage =
-	new _writer_bits::ValueStorage<Value>(value);
+new _writer_bits::ValueStorage<Value>(value);
 _attributes.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Attribute writing rule
 ///
 /// Add an attribute writing rule with specialized converter to the
 /// writer.
 template <typename Value, typename Converter>
 DigraphWriter& attribute(const std::string& caption, const Value& value,
-			     const Converter& converter = Converter()) {
+const Converter& converter = Converter()) {
 _writer_bits::ValueStorageBase* storage =
-	new _writer_bits::ValueStorage<Value, Converter>(value, converter);
+new _writer_bits::ValueStorage<Value, Converter>(value, converter);
 _attributes.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Node writing rule
 ///
 /// Add a node writing rule to the writer.
 DigraphWriter& node(const std::string& caption, const Node& node) {
 typedef _writer_bits::MapLookUpConverter<Node> Converter;
 Converter converter(_node_index);
 _writer_bits::ValueStorageBase* storage =
-	new _writer_bits::ValueStorage<Node, Converter>(node, converter);
+new _writer_bits::ValueStorage<Node, Converter>(node, converter);
 _attributes.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \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);
+new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
 _attributes.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \name Section captions
 private:
 void writeNodes() {
 _writer_bits::MapStorageBase<Node>* label = 0;
 for (typename NodeMaps::iterator it = _node_maps.begin();
-	   it != _node_maps.end(); ++it) {
+it != _node_maps.end(); ++it) {
 if (it->first == "label") {
-	  label = it->second;
+label = it->second;
-	  break;
+break;
-	}
+}
 }
 *_os << "@nodes";
 if (!_nodes_caption.empty()) {
-	_writer_bits::writeToken(*_os << ' ', _nodes_caption);
+_writer_bits::writeToken(*_os << ' ', _nodes_caption);
 }
 *_os << std::endl;
 if (label == 0) {
-	*_os << "label" << '\t';
+*_os << "label" << '\t';
 }
 for (typename NodeMaps::iterator it = _node_maps.begin();
-	   it != _node_maps.end(); ++it) {
+it != _node_maps.end(); ++it) {
-	_writer_bits::writeToken(*_os, it->first) << '\t';
+_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);
+nodes.push_back(n);
 }
 if (label == 0) {
-	IdMap<Digraph, Node> id_map(_digraph);
+IdMap<Digraph, Node> id_map(_digraph);
-	_writer_bits::MapLess<IdMap<Digraph, Node> > id_less(id_map);
+_writer_bits::MapLess<IdMap<Digraph, Node> > id_less(id_map);
-	std::sort(nodes.begin(), nodes.end(), id_less);
+std::sort(nodes.begin(), nodes.end(), id_less);
 } else {
-	label->sort(nodes);
+label->sort(nodes);
 }
 for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
-	Node n = nodes[i];
+Node n = nodes[i];
-	if (label == 0) {
+if (label == 0) {
-	  std::ostringstream os;
+std::ostringstream os;
-	  os << _digraph.id(n);
+os << _digraph.id(n);
-	  _writer_bits::writeToken(*_os, os.str());
+_writer_bits::writeToken(*_os, os.str());
-	  *_os << '\t';
+*_os << '\t';
-	  _node_index.insert(std::make_pair(n, os.str()));
+_node_index.insert(std::make_pair(n, os.str()));
-	}
+}
-	for (typename NodeMaps::iterator it = _node_maps.begin();
+for (typename NodeMaps::iterator it = _node_maps.begin();
-	     it != _node_maps.end(); ++it) {
+it != _node_maps.end(); ++it) {
-	  std::string value = it->second->get(n);
+std::string value = it->second->get(n);
-	  _writer_bits::writeToken(*_os, value);
+_writer_bits::writeToken(*_os, value);
-	  if (it->first == "label") {
+if (it->first == "label") {
-	    _node_index.insert(std::make_pair(n, value));
+_node_index.insert(std::make_pair(n, value));
-	  }
+}
-	  *_os << '\t';
+*_os << '\t';
-	}
+}
-	*_os << std::endl;
+*_os << std::endl;
 }
 }
 void createNodeIndex() {
 _writer_bits::MapStorageBase<Node>* label = 0;
 for (typename NodeMaps::iterator it = _node_maps.begin();
-	   it != _node_maps.end(); ++it) {
+it != _node_maps.end(); ++it) {
 if (it->first == "label") {
-	  label = it->second;
+label = it->second;
-	  break;
+break;
-	}
+}
 }
 if (label == 0) {
-	for (NodeIt n(_digraph); n != INVALID; ++n) {
+for (NodeIt n(_digraph); n != INVALID; ++n) {
-	  std::ostringstream os;
+std::ostringstream os;
-	  os << _digraph.id(n);
+os << _digraph.id(n);
-	  _node_index.insert(std::make_pair(n, os.str()));
+_node_index.insert(std::make_pair(n, os.str()));
-	}
+}
 } else {
-	for (NodeIt n(_digraph); n != INVALID; ++n) {
+for (NodeIt n(_digraph); n != INVALID; ++n) {
-	  std::string value = label->get(n);
+std::string value = label->get(n);
-	  _node_index.insert(std::make_pair(n, value));
+_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) {
+it != _arc_maps.end(); ++it) {
 if (it->first == "label") {
-	  label = it->second;
+label = it->second;
-	  break;
+break;
-	}
+}
 }
 *_os << "@arcs";
 if (!_arcs_caption.empty()) {
-	_writer_bits::writeToken(*_os << ' ', _arcs_caption);
+_writer_bits::writeToken(*_os << ' ', _arcs_caption);
 }
 *_os << std::endl;
 *_os << '\t' << '\t';
 if (label == 0) {
-	*_os << "label" << '\t';
+*_os << "label" << '\t';
 }
 for (typename ArcMaps::iterator it = _arc_maps.begin();
-	   it != _arc_maps.end(); ++it) {
+it != _arc_maps.end(); ++it) {
-	_writer_bits::writeToken(*_os, it->first) << '\t';
+_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);
+arcs.push_back(n);
 }
 if (label == 0) {
-	IdMap<Digraph, Arc> id_map(_digraph);
+IdMap<Digraph, Arc> id_map(_digraph);
-	_writer_bits::MapLess<IdMap<Digraph, Arc> > id_less(id_map);
+_writer_bits::MapLess<IdMap<Digraph, Arc> > id_less(id_map);
-	std::sort(arcs.begin(), arcs.end(), id_less);
+std::sort(arcs.begin(), arcs.end(), id_less);
 } else {
-	label->sort(arcs);
+label->sort(arcs);
 }
 for (int i = 0; i < static_cast<int>(arcs.size()); ++i) {
-	Arc a = arcs[i];
+Arc a = arcs[i];
-	_writer_bits::writeToken(*_os, _node_index.
+_writer_bits::writeToken(*_os, _node_index.
-				 find(_digraph.source(a))->second);
+find(_digraph.source(a))->second);
-	*_os << '\t';
+*_os << '\t';
-	_writer_bits::writeToken(*_os, _node_index.
+_writer_bits::writeToken(*_os, _node_index.
-				 find(_digraph.target(a))->second);
+find(_digraph.target(a))->second);
-	*_os << '\t';
+*_os << '\t';
-	if (label == 0) {
+if (label == 0) {
-	  std::ostringstream os;
+std::ostringstream os;
-	  os << _digraph.id(a);
+os << _digraph.id(a);
-	  _writer_bits::writeToken(*_os, os.str());
+_writer_bits::writeToken(*_os, os.str());
-	  *_os << '\t';
+*_os << '\t';
-	  _arc_index.insert(std::make_pair(a, os.str()));
+_arc_index.insert(std::make_pair(a, os.str()));
-	}
+}
-	for (typename ArcMaps::iterator it = _arc_maps.begin();
+for (typename ArcMaps::iterator it = _arc_maps.begin();
-	     it != _arc_maps.end(); ++it) {
+it != _arc_maps.end(); ++it) {
-	  std::string value = it->second->get(a);
+std::string value = it->second->get(a);
-	  _writer_bits::writeToken(*_os, value);
+_writer_bits::writeToken(*_os, value);
-	  if (it->first == "label") {
+if (it->first == "label") {
-	    _arc_index.insert(std::make_pair(a, value));
+_arc_index.insert(std::make_pair(a, value));
-	  }
+}
-	  *_os << '\t';
+*_os << '\t';
-	}
+}
-	*_os << std::endl;
+*_os << std::endl;
 }
 }
 void createArcIndex() {
 _writer_bits::MapStorageBase<Arc>* label = 0;
 for (typename ArcMaps::iterator it = _arc_maps.begin();
-	   it != _arc_maps.end(); ++it) {
+it != _arc_maps.end(); ++it) {
 if (it->first == "label") {
-	  label = it->second;
+label = it->second;
-	  break;
+break;
-	}
+}
 }
 if (label == 0) {
-	for (ArcIt a(_digraph); a != INVALID; ++a) {
+for (ArcIt a(_digraph); a != INVALID; ++a) {
-	  std::ostringstream os;
+std::ostringstream os;
-	  os << _digraph.id(a);
+os << _digraph.id(a);
-	  _arc_index.insert(std::make_pair(a, os.str()));
+_arc_index.insert(std::make_pair(a, os.str()));
-	}
+}
 } else {
-	for (ArcIt a(_digraph); a != INVALID; ++a) {
+for (ArcIt a(_digraph); a != INVALID; ++a) {
-	  std::string value = label->get(a);
+std::string value = label->get(a);
-	  _arc_index.insert(std::make_pair(a, value));
+_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);
+_writer_bits::writeToken(*_os << ' ', _attributes_caption);
 }
 *_os << std::endl;
 for (typename Attributes::iterator it = _attributes.begin();
-	   it != _attributes.end(); ++it) {
+it != _attributes.end(); ++it) {
-	_writer_bits::writeToken(*_os, it->first) << ' ';
+_writer_bits::writeToken(*_os, it->first) << ' ';
-	_writer_bits::writeToken(*_os, it->second->get());
+_writer_bits::writeToken(*_os, it->second->get());
-	*_os << std::endl;
+*_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();
+writeNodes();
 } else {
-	createNodeIndex();
+createNodeIndex();
 }
 if (!_skip_arcs) {
-	writeArcs();
+writeArcs();
 } else {
-	createArcIndex();
+createArcIndex();
 }
 writeAttributes();
 }
 /// \brief Give back the stream of the writer
 /// @}
 };
 /// \brief Return a \ref DigraphWriter class
 ///
 /// This function just returns a \ref DigraphWriter class.
 /// \relates DigraphWriter
 template <typename Digraph>
 DigraphWriter<Digraph> digraphWriter(std::ostream& os,
-				       const Digraph& digraph) {
+const Digraph& digraph) {
 DigraphWriter<Digraph> tmp(os, digraph);
 return tmp;
 }
 /// \brief Return a \ref DigraphWriter class
 ///
 /// This function just returns a \ref DigraphWriter class.
 /// \relates DigraphWriter
 template <typename Digraph>
 DigraphWriter<Digraph> digraphWriter(const std::string& fn,
-				       const Digraph& digraph) {
+const Digraph& digraph) {
 DigraphWriter<Digraph> tmp(fn, digraph);
 return tmp;
 }
 /// \brief Return a \ref DigraphWriter class
 ///
 /// This function just returns a \ref DigraphWriter class.
 /// \relates DigraphWriter
 template <typename Digraph>
 DigraphWriter<Digraph> digraphWriter(const char* fn,
-				       const Digraph& digraph) {
+const Digraph& digraph) {
 DigraphWriter<Digraph> tmp(fn, digraph);
 return tmp;
 }
 template <typename Graph>
 class GraphWriter;
 template <typename Graph>
 GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph);
 template <typename Graph>
 GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph);
 template <typename Graph>
 GraphWriter<Graph> graphWriter(const char *fn, const Graph& graph);
 /// \ingroup lemon_io
 ///
 /// \brief \ref lgf-format "LGF" writer for directed graphs
 ///
 /// This utility writes an \ref lgf-format "LGF" file.
 ///
 /// It can be used almost the same way as \c DigraphWriter.
 class GraphWriter {
 public:
 typedef _Graph Graph;
 TEMPLATE_GRAPH_TYPEDEFS(Graph);
 private:
 std::ostream* _os;
 bool local_os;
 Graph& _graph;
 std::string _nodes_caption;
 std::string _edges_caption;
 std::string _attributes_caption;
 typedef std::map<Node, std::string> NodeIndex;
 NodeIndex _node_index;
 typedef std::map<Edge, std::string> EdgeIndex;
 EdgeIndex _edge_index;
 typedef std::vector<std::pair<std::string,
 _writer_bits::MapStorageBase<Node>* > > NodeMaps;
 NodeMaps _node_maps;
 typedef std::vector<std::pair<std::string,
 _writer_bits::MapStorageBase<Edge>* > >EdgeMaps;
 EdgeMaps _edge_maps;
 typedef std::vector<std::pair<std::string,
 _writer_bits::ValueStorageBase*> > Attributes;
 Attributes _attributes;
 bool _skip_nodes;
 bool _skip_edges;
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output stream.
 GraphWriter(std::ostream& is, const Graph& graph)
 : _os(&is), local_os(false), _graph(graph),
-	_skip_nodes(false), _skip_edges(false) {}
+_skip_nodes(false), _skip_edges(false) {}
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output file.
 GraphWriter(const std::string& fn, const Graph& graph)
 : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
-	_skip_nodes(false), _skip_edges(false) {}
+_skip_nodes(false), _skip_edges(false) {}
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output file.
 GraphWriter(const char* fn, const Graph& graph)
 : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
-	_skip_nodes(false), _skip_edges(false) {}
+_skip_nodes(false), _skip_edges(false) {}
 /// \brief Destructor
 ~GraphWriter() {
 for (typename NodeMaps::iterator it = _node_maps.begin();
-	   it != _node_maps.end(); ++it) {
+it != _node_maps.end(); ++it) {
-	delete it->second;
+delete it->second;
 }
 for (typename EdgeMaps::iterator it = _edge_maps.begin();
-	   it != _edge_maps.end(); ++it) {
+it != _edge_maps.end(); ++it) {
-	delete it->second;
+delete it->second;
 }
 for (typename Attributes::iterator it = _attributes.begin();
-	   it != _attributes.end(); ++it) {
+it != _attributes.end(); ++it) {
-	delete it->second;
+delete it->second;
 }
 if (local_os) {
-	delete _os;
+delete _os;
 }
 }
 private:
 friend GraphWriter<Graph> graphWriter<>(std::ostream& os,
-					    const Graph& graph);
+const Graph& graph);
 friend GraphWriter<Graph> graphWriter<>(const std::string& fn,
-					    const Graph& graph);
+const Graph& graph);
 friend GraphWriter<Graph> graphWriter<>(const char *fn,
-					    const Graph& graph);
+const Graph& graph);
 GraphWriter(GraphWriter& other)
 : _os(other._os), local_os(other.local_os), _graph(other._graph),
-	_skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
+_skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 other._os = 0;
 other.local_os = false;
 _node_index.swap(other._node_index);
 public:
 /// \name Writing rules
 /// @{
 /// \brief Node map writing rule
 ///
 /// Add a node map writing rule to the writer.
 template <typename Map>
 GraphWriter& nodeMap(const std::string& caption, const Map& map) {
 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Node>* storage =
-	new _writer_bits::MapStorage<Node, Map>(map);
+new _writer_bits::MapStorage<Node, Map>(map);
 _node_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Node map writing rule
 ///
 /// Add a node map writing rule with specialized converter to the
 /// writer.
 template <typename Map, typename Converter>
 GraphWriter& nodeMap(const std::string& caption, const Map& map,
-			   const Converter& converter = Converter()) {
+const Converter& converter = Converter()) {
 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Node>* storage =
-	new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
+new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
 _node_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Edge map writing rule
 ///
 /// Add an edge map writing rule to the writer.
 template <typename Map>
 GraphWriter& edgeMap(const std::string& caption, const Map& map) {
 checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Edge>* storage =
-	new _writer_bits::MapStorage<Edge, Map>(map);
+new _writer_bits::MapStorage<Edge, Map>(map);
 _edge_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Edge map writing rule
 ///
 /// Add an edge map writing rule with specialized converter to the
 /// writer.
 template <typename Map, typename Converter>
 GraphWriter& edgeMap(const std::string& caption, const Map& map,
-			  const Converter& converter = Converter()) {
+const Converter& converter = Converter()) {
 checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Edge>* storage =
-	new _writer_bits::MapStorage<Edge, Map, Converter>(map, converter);
+new _writer_bits::MapStorage<Edge, Map, Converter>(map, converter);
 _edge_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Arc map writing rule
 ///
 /// Add an arc map writing rule to the writer.
 template <typename Map>
 GraphWriter& arcMap(const std::string& caption, const Map& map) {
 checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Edge>* forward_storage =
-	new _writer_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
+new _writer_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
 _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
 _writer_bits::MapStorageBase<Edge>* backward_storage =
-	new _writer_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
+new _writer_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
 _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
 return *this;
 }
 /// \brief Arc map writing rule
 ///
 /// Add an arc map writing rule with specialized converter to the
 /// writer.
 template <typename Map, typename Converter>
 GraphWriter& arcMap(const std::string& caption, const Map& map,
-			  const Converter& converter = Converter()) {
+const Converter& converter = Converter()) {
 checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Edge>* forward_storage =
-	new _writer_bits::GraphArcMapStorage<Graph, true, Map, Converter>
+new _writer_bits::GraphArcMapStorage<Graph, true, Map, Converter>
-	(_graph, map, converter);
+(_graph, map, converter);
 _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
 _writer_bits::MapStorageBase<Edge>* backward_storage =
-	new _writer_bits::GraphArcMapStorage<Graph, false, Map, Converter>
+new _writer_bits::GraphArcMapStorage<Graph, false, Map, Converter>
-	(_graph, map, converter);
+(_graph, map, converter);
 _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
 return *this;
 }
 /// \brief Attribute writing rule
 ///
 /// Add an attribute writing rule to the writer.
 template <typename Value>
 GraphWriter& attribute(const std::string& caption, const Value& value) {
 _writer_bits::ValueStorageBase* storage =
-	new _writer_bits::ValueStorage<Value>(value);
+new _writer_bits::ValueStorage<Value>(value);
 _attributes.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Attribute writing rule
 ///
 /// Add an attribute writing rule with specialized converter to the
 /// writer.
 template <typename Value, typename Converter>
 GraphWriter& attribute(const std::string& caption, const Value& value,
-			     const Converter& converter = Converter()) {
+const Converter& converter = Converter()) {
 _writer_bits::ValueStorageBase* storage =
-	new _writer_bits::ValueStorage<Value, Converter>(value, converter);
+new _writer_bits::ValueStorage<Value, Converter>(value, converter);
 _attributes.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Node writing rule
 ///
 /// Add a node writing rule to the writer.
 GraphWriter& node(const std::string& caption, const Node& node) {
 typedef _writer_bits::MapLookUpConverter<Node> Converter;
 Converter converter(_node_index);
 _writer_bits::ValueStorageBase* storage =
-	new _writer_bits::ValueStorage<Node, Converter>(node, converter);
+new _writer_bits::ValueStorage<Node, Converter>(node, converter);
 _attributes.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Edge writing rule
 ///
 /// Add an edge writing rule to writer.
 GraphWriter& edge(const std::string& caption, const Edge& edge) {
 typedef _writer_bits::MapLookUpConverter<Edge> Converter;
 Converter converter(_edge_index);
 _writer_bits::ValueStorageBase* storage =
-	new _writer_bits::ValueStorage<Edge, Converter>(edge, converter);
+new _writer_bits::ValueStorage<Edge, Converter>(edge, converter);
 _attributes.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \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);
+new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
 _attributes.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \name Section captions
 private:
 void writeNodes() {
 _writer_bits::MapStorageBase<Node>* label = 0;
 for (typename NodeMaps::iterator it = _node_maps.begin();
-	   it != _node_maps.end(); ++it) {
+it != _node_maps.end(); ++it) {
 if (it->first == "label") {
-	  label = it->second;
+label = it->second;
-	  break;
+break;
-	}
+}
 }
 *_os << "@nodes";
 if (!_nodes_caption.empty()) {
-	_writer_bits::writeToken(*_os << ' ', _nodes_caption);
+_writer_bits::writeToken(*_os << ' ', _nodes_caption);
 }
 *_os << std::endl;
 if (label == 0) {
-	*_os << "label" << '\t';
+*_os << "label" << '\t';
 }
 for (typename NodeMaps::iterator it = _node_maps.begin();
-	   it != _node_maps.end(); ++it) {
+it != _node_maps.end(); ++it) {
-	_writer_bits::writeToken(*_os, it->first) << '\t';
+_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);
+nodes.push_back(n);
 }
 if (label == 0) {
-	IdMap<Graph, Node> id_map(_graph);
+IdMap<Graph, Node> id_map(_graph);
-	_writer_bits::MapLess<IdMap<Graph, Node> > id_less(id_map);
+_writer_bits::MapLess<IdMap<Graph, Node> > id_less(id_map);
-	std::sort(nodes.begin(), nodes.end(), id_less);
+std::sort(nodes.begin(), nodes.end(), id_less);
 } else {
-	label->sort(nodes);
+label->sort(nodes);
 }
 for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
-	Node n = nodes[i];
+Node n = nodes[i];
-	if (label == 0) {
+if (label == 0) {
-	  std::ostringstream os;
+std::ostringstream os;
-	  os << _graph.id(n);
+os << _graph.id(n);
-	  _writer_bits::writeToken(*_os, os.str());
+_writer_bits::writeToken(*_os, os.str());
-	  *_os << '\t';
+*_os << '\t';
-	  _node_index.insert(std::make_pair(n, os.str()));
+_node_index.insert(std::make_pair(n, os.str()));
-	}
+}
-	for (typename NodeMaps::iterator it = _node_maps.begin();
+for (typename NodeMaps::iterator it = _node_maps.begin();
-	     it != _node_maps.end(); ++it) {
+it != _node_maps.end(); ++it) {
-	  std::string value = it->second->get(n);
+std::string value = it->second->get(n);
-	  _writer_bits::writeToken(*_os, value);
+_writer_bits::writeToken(*_os, value);
-	  if (it->first == "label") {
+if (it->first == "label") {
-	    _node_index.insert(std::make_pair(n, value));
+_node_index.insert(std::make_pair(n, value));
-	  }
+}
-	  *_os << '\t';
+*_os << '\t';
-	}
+}
-	*_os << std::endl;
+*_os << std::endl;
 }
 }
 void createNodeIndex() {
 _writer_bits::MapStorageBase<Node>* label = 0;
 for (typename NodeMaps::iterator it = _node_maps.begin();
-	   it != _node_maps.end(); ++it) {
+it != _node_maps.end(); ++it) {
 if (it->first == "label") {
-	  label = it->second;
+label = it->second;
-	  break;
+break;
-	}
+}
 }
 if (label == 0) {
-	for (NodeIt n(_graph); n != INVALID; ++n) {
+for (NodeIt n(_graph); n != INVALID; ++n) {
-	  std::ostringstream os;
+std::ostringstream os;
-	  os << _graph.id(n);
+os << _graph.id(n);
-	  _node_index.insert(std::make_pair(n, os.str()));
+_node_index.insert(std::make_pair(n, os.str()));
-	}
+}
 } else {
-	for (NodeIt n(_graph); n != INVALID; ++n) {
+for (NodeIt n(_graph); n != INVALID; ++n) {
-	  std::string value = label->get(n);
+std::string value = label->get(n);
-	  _node_index.insert(std::make_pair(n, value));
+_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) {
+it != _edge_maps.end(); ++it) {
 if (it->first == "label") {
-	  label = it->second;
+label = it->second;
-	  break;
+break;
-	}
+}
 }
 *_os << "@edges";
 if (!_edges_caption.empty()) {
-	_writer_bits::writeToken(*_os << ' ', _edges_caption);
+_writer_bits::writeToken(*_os << ' ', _edges_caption);
 }
 *_os << std::endl;
 *_os << '\t' << '\t';
 if (label == 0) {
-	*_os << "label" << '\t';
+*_os << "label" << '\t';
 }
 for (typename EdgeMaps::iterator it = _edge_maps.begin();
-	   it != _edge_maps.end(); ++it) {
+it != _edge_maps.end(); ++it) {
-	_writer_bits::writeToken(*_os, it->first) << '\t';
+_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);
+edges.push_back(n);
 }
 if (label == 0) {
-	IdMap<Graph, Edge> id_map(_graph);
+IdMap<Graph, Edge> id_map(_graph);
-	_writer_bits::MapLess<IdMap<Graph, Edge> > id_less(id_map);
+_writer_bits::MapLess<IdMap<Graph, Edge> > id_less(id_map);
-	std::sort(edges.begin(), edges.end(), id_less);
+std::sort(edges.begin(), edges.end(), id_less);
 } else {
-	label->sort(edges);
+label->sort(edges);
 }
 for (int i = 0; i < static_cast<int>(edges.size()); ++i) {
-	Edge e = edges[i];
+Edge e = edges[i];
-	_writer_bits::writeToken(*_os, _node_index.
+_writer_bits::writeToken(*_os, _node_index.
-				 find(_graph.u(e))->second);
+find(_graph.u(e))->second);
-	*_os << '\t';
+*_os << '\t';
-	_writer_bits::writeToken(*_os, _node_index.
+_writer_bits::writeToken(*_os, _node_index.
-				 find(_graph.v(e))->second);
+find(_graph.v(e))->second);
-	*_os << '\t';
+*_os << '\t';
-	if (label == 0) {
+if (label == 0) {
-	  std::ostringstream os;
+std::ostringstream os;
-	  os << _graph.id(e);
+os << _graph.id(e);
-	  _writer_bits::writeToken(*_os, os.str());
+_writer_bits::writeToken(*_os, os.str());
-	  *_os << '\t';
+*_os << '\t';
-	  _edge_index.insert(std::make_pair(e, os.str()));
+_edge_index.insert(std::make_pair(e, os.str()));
-	}
+}
-	for (typename EdgeMaps::iterator it = _edge_maps.begin();
+for (typename EdgeMaps::iterator it = _edge_maps.begin();
-	     it != _edge_maps.end(); ++it) {
+it != _edge_maps.end(); ++it) {
-	  std::string value = it->second->get(e);
+std::string value = it->second->get(e);
-	  _writer_bits::writeToken(*_os, value);
+_writer_bits::writeToken(*_os, value);
-	  if (it->first == "label") {
+if (it->first == "label") {
-	    _edge_index.insert(std::make_pair(e, value));
+_edge_index.insert(std::make_pair(e, value));
-	  }
+}
-	  *_os << '\t';
+*_os << '\t';
-	}
+}
-	*_os << std::endl;
+*_os << std::endl;
 }
 }
 void createEdgeIndex() {
 _writer_bits::MapStorageBase<Edge>* label = 0;
 for (typename EdgeMaps::iterator it = _edge_maps.begin();
-	   it != _edge_maps.end(); ++it) {
+it != _edge_maps.end(); ++it) {
 if (it->first == "label") {
-	  label = it->second;
+label = it->second;
-	  break;
+break;
-	}
+}
 }
 if (label == 0) {
-	for (EdgeIt e(_graph); e != INVALID; ++e) {
+for (EdgeIt e(_graph); e != INVALID; ++e) {
-	  std::ostringstream os;
+std::ostringstream os;
-	  os << _graph.id(e);
+os << _graph.id(e);
-	  _edge_index.insert(std::make_pair(e, os.str()));
+_edge_index.insert(std::make_pair(e, os.str()));
-	}
+}
 } else {
-	for (EdgeIt e(_graph); e != INVALID; ++e) {
+for (EdgeIt e(_graph); e != INVALID; ++e) {
-	  std::string value = label->get(e);
+std::string value = label->get(e);
-	  _edge_index.insert(std::make_pair(e, value));
+_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);
+_writer_bits::writeToken(*_os << ' ', _attributes_caption);
 }
 *_os << std::endl;
 for (typename Attributes::iterator it = _attributes.begin();
-	   it != _attributes.end(); ++it) {
+it != _attributes.end(); ++it) {
-	_writer_bits::writeToken(*_os, it->first) << ' ';
+_writer_bits::writeToken(*_os, it->first) << ' ';
-	_writer_bits::writeToken(*_os, it->second->get());
+_writer_bits::writeToken(*_os, it->second->get());
-	*_os << std::endl;
+*_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();
+writeNodes();
 } else {
-	createNodeIndex();
+createNodeIndex();
 }
 if (!_skip_edges) {
-	writeEdges();
+writeEdges();
 } else {
-	createEdgeIndex();
+createEdgeIndex();
 }
 writeAttributes();
 }
 /// \brief Give back the stream of the writer
 /// @}
 };
 /// \brief Return a \ref GraphWriter class
 ///
 /// This function just returns a \ref GraphWriter class.
 /// \relates GraphWriter
 template <typename Graph>
 GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph) {
 GraphWriter<Graph> tmp(os, graph);
 return tmp;
 }
 /// \brief Return a \ref GraphWriter class
 ///
 /// This function just returns a \ref GraphWriter class.
 /// \relates GraphWriter
 template <typename Graph>
 GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph) {
 GraphWriter<Graph> tmp(fn, graph);
 return tmp;
 }
 /// \brief Return a \ref GraphWriter class
 ///
 /// This function just returns a \ref GraphWriter class.
 /// \relates GraphWriter
 template <typename Graph>
 GraphWriter<Graph> graphWriter(const char* fn, const Graph& graph) {
 GraphWriter<Graph> tmp(fn, graph);

changeset 209	765619b7cbb2
parent 201	9757e3d9bfeb
child 212	1ae84dea7d09