Changeset 209:765619b7cbb2 in lemon-1.2 for lemon/lgf_writer.h

Timestamp:

07/13/08 20:51:02 (16 years ago)

Author:

Alpar Juttner <alpar@…>

Branch:

default

Phase:

public

Message:

Apply unify-sources.sh to the source tree

File:

• lemon/lgf_writer.h (modified) (76 diffs)

lemon/lgf_writer.h

@@ -1 @@
-/* -*- 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
@@ -44 +44 @@
     struct DefaultConverter {
       std::string operator()(const Value& value) {
-        std::ostringstream os;
-        os << value;
-        return os.str();
+        std::ostringstream os;
+        os << value;
+        return os.str();
       }
     };
@@ -63 +63 @@
     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];
       }
     };
@@ -82 +82 @@
       const Graph& _graph;
       const Map& _map;
-      
+
     public:
-      GraphArcMapLess(const Graph& graph, const Map& map) 
-        : _graph(graph), _map(map) {}
+      GraphArcMapLess(const Graph& graph, const Map& map)
+        : _graph(graph), _map(map) {}
 
       bool operator()(const Item& left, const Item& right) {
-        return _map[_graph.direct(left, _dir)] < 
-          _map[_graph.direct(right, _dir)];
+        return _map[_graph.direct(left, _dir)] <
+          _map[_graph.direct(right, _dir)];
       }
     };
 
-    template <typename _Item>    
+    template <typename _Item>
     class MapStorageBase {
     public:
@@ -106 +106 @@
     };
 
-    template <typename _Item, typename _Map, 
-              typename _Converter = DefaultConverter<typename _Map::Value> >
+    template <typename _Item, typename _Map,
+              typename _Converter = DefaultConverter<typename _Map::Value> >
     class MapStorage : public MapStorageBase<_Item> {
     public:
@@ -113 +113 @@
       typedef _Converter Converter;
       typedef _Item Item;
-      
+
     private:
       const Map& _map;
@@ -119 +119 @@
 
     public:
-      MapStorage(const Map& map, const Converter& converter = Converter()) 
-        : _map(map), _converter(converter) {}
+      MapStorage(const Map& map, const Converter& 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);
-        std::sort(items.begin(), items.end(), less);
+        MapLess<Map> less(_map);
+        std::sort(items.begin(), items.end(), less);
       }
     };
 
-    template <typename _Graph, bool _dir, typename _Map, 
-              typename _Converter = DefaultConverter<typename _Map::Value> >
+    template <typename _Graph, bool _dir, typename _Map,
+              typename _Converter = DefaultConverter<typename _Map::Value> >
     class GraphArcMapStorage : public MapStorageBase<typename _Graph::Edge> {
     public:
@@ -141 +141 @@
       typedef typename Graph::Edge Item;
       static const bool dir = _dir;
-      
+
     private:
       const Graph& _graph;
@@ -148 +148 @@
 
     public:
-      GraphArcMapStorage(const Graph& graph, const Map& map,  
-                         const Converter& converter = Converter()) 
-        : _graph(graph), _map(map), _converter(converter) {}
+      GraphArcMapStorage(const Graph& graph, const Map& map,
+                         const Converter& 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);
-        std::sort(items.begin(), items.end(), less);
+        GraphArcMapLess<Graph, dir, Map> less(_graph, _map);
+        std::sort(items.begin(), items.end(), less);
       }
     };
@@ -167 +167 @@
       virtual ~ValueStorageBase() {}
 
-      virtual std::string get() = 0;      
+      virtual std::string get() = 0;
     };
 
@@ -182 +182 @@
     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);
       }
     };
@@ -192 +192 @@
     struct MapLookUpConverter {
       const std::map<Value, std::string>& _map;
-      
-      MapLookUpConverter(const std::map<Value, std::string>& map) 
-        : _map(map) {}
-      
+
+      MapLookUpConverter(const std::map<Value, std::string>& map)
+        : _map(map) {}
+
       std::string operator()(const Value& str) {
-        typename std::map<Value, std::string>::const_iterator it = 
-          _map.find(str);
-        if (it == _map.end()) {
-          throw DataFormatError("Item not found");
-        }
-        return it->second;
+        typename std::map<Value, std::string>::const_iterator it =
+          _map.find(str);
+        if (it == _map.end()) {
+          throw DataFormatError("Item not found");
+        }
+        return it->second;
       }
     };
@@ -210 +210 @@
       const Graph& _graph;
       const std::map<typename Graph::Edge, std::string>& _map;
-      
-      GraphArcLookUpConverter(const Graph& graph, 
-                              const std::map<typename Graph::Edge, 
-                                             std::string>& map) 
-        : _graph(graph), _map(map) {}
-      
+
+      GraphArcLookUpConverter(const Graph& graph,
+                              const std::map<typename Graph::Edge,
+                                             std::string>& map)
+        : _graph(graph), _map(map) {}
+
       std::string operator()(const typename Graph::Arc& val) {
-        typename std::map<typename Graph::Edge, std::string>
-          ::const_iterator it = _map.find(val);
-        if (it == _map.end()) {
-          throw DataFormatError("Item not found");
-        }
-        return (_graph.direction(val) ? '+' : '-') + it->second;
+        typename std::map<typename Graph::Edge, std::string>
+          ::const_iterator it = _map.find(val);
+        if (it == _map.end()) {
+          throw DataFormatError("Item not found");
+        }
+        return (_graph.direction(val) ? '+' : '-') + it->second;
       }
     };
 
     inline bool isWhiteSpace(char c) {
-      return c == ' ' || c == '\t' || c == '\v' || 
-        c == '\n' || c == '\r' || c == '\f'; 
+      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';
+      return c == '\\' || c == '\"' || c == '\'' ||
+        c == '\a' || c == '\b';
     }
 
@@ -239 +239 @@
       switch (c) {
       case '\\':
-        os << "\\\\";
-        return;
+        os << "\\\\";
+        return;
       case '\"':
-        os << "\\\"";
-        return;
+        os << "\\\"";
+        return;
       case '\a':
-        os << "\\a";
-        return;
+        os << "\\a";
+        return;
       case '\b':
-        os << "\\b";
-        return;
+        os << "\\b";
+        return;
       case '\f':
-        os << "\\f";
-        return;
+        os << "\\f";
+        return;
       case '\r':
-        os << "\\r";
-        return;
+        os << "\\r";
+        return;
       case '\n':
-        os << "\\n";
-        return;
+        os << "\\n";
+        return;
       case '\t':
-        os << "\\t";
-        return;
+        os << "\\t";
+        return;
       case '\v':
-        os << "\\v";
-        return;
+        os << "\\v";
+        return;
       default:
-        if (c < 0x20) {
-          std::ios::fmtflags flags = os.flags();
-          os << '\\' << std::oct << static_cast<int>(c);
-          os.flags(flags);
-        } else {
-          os << c;
-        }
-        return;
-      }     
+        if (c < 0x20) {
+          std::ios::fmtflags flags = os.flags();
+          os << '\\' << std::oct << static_cast<int>(c);
+          os.flags(flags);
+        } else {
+          os << c;
+        }
+        return;
+      }
     }
 
@@ -282 +282 @@
       char c;
       while (is.get(c)) {
-        if (isWhiteSpace(c) || isEscaped(c)) {
-          return true;
-        }
+        if (isWhiteSpace(c) || isEscaped(c)) {
+          return true;
+        }
       }
       return false;
     }
-    
+
     inline std::ostream& writeToken(std::ostream& os, const std::string& str) {
 
       if (requireEscape(str)) {
-        os << '\"';
-        for (std::string::const_iterator it = str.begin(); 
-             it != str.end(); ++it) {
-          writeEscape(os, *it);
-        }       
-        os << '\"';
+        os << '\"';
+        for (std::string::const_iterator it = str.begin();
+             it != str.end(); ++it) {
+          writeEscape(os, *it);
+        }
+        os << '\"';
       } else {
-        os << str;
+        os << str;
       }
       return os;
@@ -310 +310 @@
 
   template <typename Digraph>
-  DigraphWriter<Digraph> digraphWriter(std::ostream& os, 
-                                       const Digraph& digraph);
+  DigraphWriter<Digraph> digraphWriter(std::ostream& os,
+                                       const Digraph& digraph);
 
   template <typename Digraph>
-  DigraphWriter<Digraph> digraphWriter(const std::string& fn, 
-                                       const Digraph& digraph);
+  DigraphWriter<Digraph> digraphWriter(const std::string& fn,
+                                       const Digraph& digraph);
 
   template <typename Digraph>
-  DigraphWriter<Digraph> digraphWriter(const char *fn, 
-                                       const Digraph& digraph);
-  
+  DigraphWriter<Digraph> digraphWriter(const char *fn,
+                                       const Digraph& digraph);
+
   /// \ingroup lemon_io
-  ///  
+  ///
   /// \brief \ref lgf-format "LGF" writer for directed graphs
   ///
@@ -371 +371 @@
     typedef _Digraph Digraph;
     TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-    
+
   private:
 
@@ -383 +383 @@
     std::string _arcs_caption;
     std::string _attributes_caption;
-    
+
     typedef std::map<Node, std::string> NodeIndex;
     NodeIndex _node_index;
@@ -389 +389 @@
     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, 
+    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, 
+    typedef std::vector<std::pair<std::string,
       _writer_bits::ValueStorageBase*> > Attributes;
     Attributes _attributes;
@@ -410 +410 @@
     /// Construct a directed graph writer, which writes to the given
     /// output stream.
-    DigraphWriter(std::ostream& is, const Digraph& digraph) 
+    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
@@ -418 +418 @@
     /// Construct a directed graph writer, which writes to the given
     /// output file.
-    DigraphWriter(const std::string& fn, const Digraph& digraph) 
+    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
@@ -426 +426 @@
     /// Construct a directed graph writer, which writes to the given
     /// output file.
-    DigraphWriter(const char* fn, const Digraph& digraph) 
+    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) {
-        delete it->second;
-      }
-
-      for (typename ArcMaps::iterator it = _arc_maps.begin(); 
-           it != _arc_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename Attributes::iterator it = _attributes.begin(); 
-           it != _attributes.end(); ++it) {
-        delete it->second;
+      for (typename NodeMaps::iterator it = _node_maps.begin();
+           it != _node_maps.end(); ++it) {
+        delete it->second;
+      }
+
+      for (typename ArcMaps::iterator it = _arc_maps.begin();
+           it != _arc_maps.end(); ++it) {
+        delete it->second;
+      }
+
+      for (typename Attributes::iterator it = _attributes.begin();
+           it != _attributes.end(); ++it) {
+        delete it->second;
       }
 
       if (local_os) {
-        delete _os;
+        delete _os;
       }
     }
@@ -454 +454 @@
   private:
 
-    friend DigraphWriter<Digraph> digraphWriter<>(std::ostream& os, 
-                                                  const Digraph& digraph);
-    friend DigraphWriter<Digraph> digraphWriter<>(const std::string& fn, 
-                                                  const Digraph& digraph);   
-    friend DigraphWriter<Digraph> digraphWriter<>(const char *fn, 
-                                                  const Digraph& digraph);
-
-    DigraphWriter(DigraphWriter& other) 
+    friend DigraphWriter<Digraph> digraphWriter<>(std::ostream& os,
+                                                  const Digraph& digraph);
+    friend DigraphWriter<Digraph> digraphWriter<>(const std::string& fn,
+                                                  const Digraph& digraph);
+    friend DigraphWriter<Digraph> digraphWriter<>(const char *fn,
+                                                  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;
@@ -479 +479 @@
       _attributes_caption = other._attributes_caption;
     }
-    
+
     DigraphWriter& operator=(const DigraphWriter&);
 
@@ -486 +486 @@
     /// \name Writing rules
     /// @{
-    
+
     /// \brief Node map writing rule
     ///
@@ -493 +493 @@
     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);
+      _writer_bits::MapStorageBase<Node>* storage =
+        new _writer_bits::MapStorage<Node, Map>(map);
       _node_maps.push_back(std::make_pair(caption, storage));
       return *this;
@@ -504 +504 @@
     /// writer.
     template <typename Map, typename Converter>
-    DigraphWriter& nodeMap(const std::string& caption, const Map& map, 
-                           const Converter& converter = Converter()) {
+    DigraphWriter& nodeMap(const std::string& caption, const Map& map,
+                           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);
+      _writer_bits::MapStorageBase<Node>* storage =
+        new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
       _node_maps.push_back(std::make_pair(caption, storage));
       return *this;
@@ -519 +519 @@
     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);
+      _writer_bits::MapStorageBase<Arc>* storage =
+        new _writer_bits::MapStorage<Arc, Map>(map);
       _arc_maps.push_back(std::make_pair(caption, storage));
       return *this;
@@ -530 +530 @@
     /// writer.
     template <typename Map, typename Converter>
-    DigraphWriter& arcMap(const std::string& caption, const Map& map, 
-                          const Converter& converter = Converter()) {
+    DigraphWriter& arcMap(const std::string& caption, const Map& map,
+                          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);
+      _writer_bits::MapStorageBase<Arc>* storage =
+        new _writer_bits::MapStorage<Arc, Map, Converter>(map, converter);
       _arc_maps.push_back(std::make_pair(caption, storage));
       return *this;
@@ -544 +544 @@
     template <typename Value>
     DigraphWriter& attribute(const std::string& caption, const Value& value) {
-      _writer_bits::ValueStorageBase* storage = 
-        new _writer_bits::ValueStorage<Value>(value);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Value>(value);
       _attributes.push_back(std::make_pair(caption, storage));
       return *this;
@@ -555 +555 @@
     /// writer.
     template <typename Value, typename Converter>
-    DigraphWriter& attribute(const std::string& caption, const Value& value, 
-                             const Converter& converter = Converter()) {
-      _writer_bits::ValueStorageBase* storage = 
-        new _writer_bits::ValueStorage<Value, Converter>(value, converter);
+    DigraphWriter& attribute(const std::string& caption, const Value& value,
+                             const Converter& converter = Converter()) {
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Value, Converter>(value, converter);
       _attributes.push_back(std::make_pair(caption, storage));
       return *this;
@@ -569 +569 @@
       typedef _writer_bits::MapLookUpConverter<Node> Converter;
       Converter converter(_node_index);
-      _writer_bits::ValueStorageBase* storage = 
-        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
       _attributes.push_back(std::make_pair(caption, storage));
       return *this;
@@ -581 +581 @@
       typedef _writer_bits::MapLookUpConverter<Arc> Converter;
       Converter converter(_arc_index);
-      _writer_bits::ValueStorageBase* storage = 
-        new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
       _attributes.push_back(std::make_pair(caption, storage));
       return *this;
@@ -642 +642 @@
       _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;
-          break;
-        }
+          label = it->second;
+          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) {
-        _writer_bits::writeToken(*_os, it->first) << '\t';
+           it != _node_maps.end(); ++it) {
+        _writer_bits::writeToken(*_os, it->first) << '\t';
       }
       *_os << std::endl;
@@ -666 +666 @@
       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);
-        _writer_bits::MapLess<IdMap<Digraph, Node> > id_less(id_map);
-        std::sort(nodes.begin(), nodes.end(), id_less);
+        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);
+        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;
+        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;
       }
     }
@@ -702 +702 @@
       _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;
-          break;
-        }
+          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()));        
-        }       
+        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));
-        }
+        for (NodeIt n(_digraph); n != INVALID; ++n) {
+          std::string value = label->get(n);
+          _node_index.insert(std::make_pair(n, value));
+        }
       }
     }
@@ -726 +726 @@
       _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;
-          break;
-        }
+          label = it->second;
+          break;
+        }
       }
 
       *_os << "@arcs";
       if (!_arcs_caption.empty()) {
-        _writer_bits::writeToken(*_os << ' ', _arcs_caption);
+        _writer_bits::writeToken(*_os << ' ', _arcs_caption);
       }
       *_os << std::endl;
@@ -741 +741 @@
       *_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) {
-        _writer_bits::writeToken(*_os, it->first) << '\t';
+           it != _arc_maps.end(); ++it) {
+        _writer_bits::writeToken(*_os, it->first) << '\t';
       }
       *_os << std::endl;
@@ -751 +751 @@
       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);
-        _writer_bits::MapLess<IdMap<Digraph, Arc> > id_less(id_map);
-        std::sort(arcs.begin(), arcs.end(), id_less);
+        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);
+        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;
+        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;
       }
     }
@@ -793 +793 @@
       _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;
-          break;
-        }
+          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()));         
-        }       
+        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));
-        }
+        for (ArcIt a(_digraph); a != INVALID; ++a) {
+          std::string value = label->get(a);
+          _arc_index.insert(std::make_pair(a, value));
+        }
       }
     }
@@ -818 +818 @@
       *_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) {
-        _writer_bits::writeToken(*_os, it->first) << ' ';
-        _writer_bits::writeToken(*_os, it->second->get());
-        *_os << std::endl;
-      }
-    }
-    
+           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    
+
+    /// \name Execution of the writer
     /// @{
 
@@ -839 +839 @@
     void run() {
       if (!_skip_nodes) {
-        writeNodes();
+        writeNodes();
       } else {
-        createNodeIndex();
-      }
-      if (!_skip_arcs) {      
-        writeArcs();
+        createNodeIndex();
+      }
+      if (!_skip_arcs) {
+        writeArcs();
       } else {
-        createArcIndex();
+        createArcIndex();
       }
       writeAttributes();
@@ -862 +862 @@
 
   /// \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) {
+  DigraphWriter<Digraph> digraphWriter(std::ostream& os,
+                                       const Digraph& digraph) {
     DigraphWriter<Digraph> tmp(os, digraph);
     return tmp;
@@ -873 +873 @@
 
   /// \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) {
+  DigraphWriter<Digraph> digraphWriter(const std::string& fn,
+                                       const Digraph& digraph) {
     DigraphWriter<Digraph> tmp(fn, digraph);
     return tmp;
@@ -884 +884 @@
 
   /// \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) {
+  DigraphWriter<Digraph> digraphWriter(const char* fn,
+                                       const Digraph& digraph) {
     DigraphWriter<Digraph> tmp(fn, digraph);
     return tmp;
@@ -898 +898 @@
 
   template <typename Graph>
-  GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph);    
+  GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph);
 
   template <typename Graph>
-  GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph);   
+  GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph);
 
   template <typename Graph>
-  GraphWriter<Graph> graphWriter(const char *fn, const Graph& graph);    
+  GraphWriter<Graph> graphWriter(const char *fn, const Graph& graph);
 
   /// \ingroup lemon_io
-  ///  
+  ///
   /// \brief \ref lgf-format "LGF" writer for directed graphs
   ///
@@ -927 +927 @@
     typedef _Graph Graph;
     TEMPLATE_GRAPH_TYPEDEFS(Graph);
-    
+
   private:
 
@@ -939 +939 @@
     std::string _edges_caption;
     std::string _attributes_caption;
-    
+
     typedef std::map<Node, std::string> NodeIndex;
     NodeIndex _node_index;
@@ -945 +945 @@
     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, 
+    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, 
+    typedef std::vector<std::pair<std::string,
       _writer_bits::ValueStorageBase*> > Attributes;
     Attributes _attributes;
@@ -966 +966 @@
     /// Construct a directed graph writer, which writes to the given
     /// output stream.
-    GraphWriter(std::ostream& is, const Graph& graph) 
+    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
@@ -974 +974 @@
     /// Construct a directed graph writer, which writes to the given
     /// output file.
-    GraphWriter(const std::string& fn, const Graph& graph) 
+    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
@@ -982 +982 @@
     /// Construct a directed graph writer, which writes to the given
     /// output file.
-    GraphWriter(const char* fn, const Graph& graph) 
+    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) {
-        delete it->second;
-      }
-
-      for (typename EdgeMaps::iterator it = _edge_maps.begin(); 
-           it != _edge_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename Attributes::iterator it = _attributes.begin(); 
-           it != _attributes.end(); ++it) {
-        delete it->second;
+      for (typename NodeMaps::iterator it = _node_maps.begin();
+           it != _node_maps.end(); ++it) {
+        delete it->second;
+      }
+
+      for (typename EdgeMaps::iterator it = _edge_maps.begin();
+           it != _edge_maps.end(); ++it) {
+        delete it->second;
+      }
+
+      for (typename Attributes::iterator it = _attributes.begin();
+           it != _attributes.end(); ++it) {
+        delete it->second;
       }
 
       if (local_os) {
-        delete _os;
-      }
-    }
-    
+        delete _os;
+      }
+    }
+
   private:
 
-    friend GraphWriter<Graph> graphWriter<>(std::ostream& os, 
-                                            const Graph& graph);    
-    friend GraphWriter<Graph> graphWriter<>(const std::string& fn, 
-                                            const Graph& graph);   
-    friend GraphWriter<Graph> graphWriter<>(const char *fn, 
-                                            const Graph& graph);    
-
-    GraphWriter(GraphWriter& other) 
+    friend GraphWriter<Graph> graphWriter<>(std::ostream& os,
+                                            const Graph& graph);
+    friend GraphWriter<Graph> graphWriter<>(const std::string& fn,
+                                            const Graph& graph);
+    friend GraphWriter<Graph> graphWriter<>(const char *fn,
+                                            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;
@@ -1042 +1042 @@
     /// \name Writing rules
     /// @{
-    
+
     /// \brief Node map writing rule
     ///
@@ -1049 +1049 @@
     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);
+      _writer_bits::MapStorageBase<Node>* storage =
+        new _writer_bits::MapStorage<Node, Map>(map);
       _node_maps.push_back(std::make_pair(caption, storage));
       return *this;
@@ -1060 +1060 @@
     /// writer.
     template <typename Map, typename Converter>
-    GraphWriter& nodeMap(const std::string& caption, const Map& map, 
-                           const Converter& converter = Converter()) {
+    GraphWriter& nodeMap(const std::string& caption, const Map& map,
+                           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);
+      _writer_bits::MapStorageBase<Node>* storage =
+        new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
       _node_maps.push_back(std::make_pair(caption, storage));
       return *this;
@@ -1075 +1075 @@
     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);
+      _writer_bits::MapStorageBase<Edge>* storage =
+        new _writer_bits::MapStorage<Edge, Map>(map);
       _edge_maps.push_back(std::make_pair(caption, storage));
       return *this;
@@ -1086 +1086 @@
     /// writer.
     template <typename Map, typename Converter>
-    GraphWriter& edgeMap(const std::string& caption, const Map& map, 
-                          const Converter& converter = Converter()) {
+    GraphWriter& edgeMap(const std::string& caption, const Map& map,
+                          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);
+      _writer_bits::MapStorageBase<Edge>* storage =
+        new _writer_bits::MapStorage<Edge, Map, Converter>(map, converter);
       _edge_maps.push_back(std::make_pair(caption, storage));
       return *this;
@@ -1101 +1101 @@
     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);
+      _writer_bits::MapStorageBase<Edge>* forward_storage =
+        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);
+      _writer_bits::MapStorageBase<Edge>* backward_storage =
+        new _writer_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
       _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
       return *this;
@@ -1115 +1115 @@
     /// writer.
     template <typename Map, typename Converter>
-    GraphWriter& arcMap(const std::string& caption, const Map& map, 
-                          const Converter& converter = Converter()) {
+    GraphWriter& arcMap(const std::string& caption, const Map& map,
+                          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>
-        (_graph, map, converter);
+      _writer_bits::MapStorageBase<Edge>* forward_storage =
+        new _writer_bits::GraphArcMapStorage<Graph, true, 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>
-        (_graph, map, converter);
+      _writer_bits::MapStorageBase<Edge>* backward_storage =
+        new _writer_bits::GraphArcMapStorage<Graph, false, Map, Converter>
+        (_graph, map, converter);
       _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
       return *this;
@@ -1134 +1134 @@
     template <typename Value>
     GraphWriter& attribute(const std::string& caption, const Value& value) {
-      _writer_bits::ValueStorageBase* storage = 
-        new _writer_bits::ValueStorage<Value>(value);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Value>(value);
       _attributes.push_back(std::make_pair(caption, storage));
       return *this;
@@ -1145 +1145 @@
     /// writer.
     template <typename Value, typename Converter>
-    GraphWriter& attribute(const std::string& caption, const Value& value, 
-                             const Converter& converter = Converter()) {
-      _writer_bits::ValueStorageBase* storage = 
-        new _writer_bits::ValueStorage<Value, Converter>(value, converter);
+    GraphWriter& attribute(const std::string& caption, const Value& value,
+                             const Converter& converter = Converter()) {
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Value, Converter>(value, converter);
       _attributes.push_back(std::make_pair(caption, storage));
       return *this;
@@ -1159 +1159 @@
       typedef _writer_bits::MapLookUpConverter<Node> Converter;
       Converter converter(_node_index);
-      _writer_bits::ValueStorageBase* storage = 
-        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
       _attributes.push_back(std::make_pair(caption, storage));
       return *this;
@@ -1171 +1171 @@
       typedef _writer_bits::MapLookUpConverter<Edge> Converter;
       Converter converter(_edge_index);
-      _writer_bits::ValueStorageBase* storage = 
-        new _writer_bits::ValueStorage<Edge, Converter>(edge, converter);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Edge, Converter>(edge, converter);
       _attributes.push_back(std::make_pair(caption, storage));
       return *this;
@@ -1183 +1183 @@
       typedef _writer_bits::GraphArcLookUpConverter<Graph> Converter;
       Converter converter(_graph, _edge_index);
-      _writer_bits::ValueStorageBase* storage = 
-        new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
+      _writer_bits::ValueStorageBase* storage =
+        new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
       _attributes.push_back(std::make_pair(caption, storage));
       return *this;
@@ -1244 +1244 @@
       _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;
-          break;
-        }
+          label = it->second;
+          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) {
-        _writer_bits::writeToken(*_os, it->first) << '\t';
+           it != _node_maps.end(); ++it) {
+        _writer_bits::writeToken(*_os, it->first) << '\t';
       }
       *_os << std::endl;
@@ -1268 +1268 @@
       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);
-        _writer_bits::MapLess<IdMap<Graph, Node> > id_less(id_map);
-        std::sort(nodes.begin(), nodes.end(), id_less);
+        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);
+        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;
+        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;
       }
     }
@@ -1304 +1304 @@
       _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;
-          break;
-        }
+          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()));        
-        }       
+        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));
-        }
+        for (NodeIt n(_graph); n != INVALID; ++n) {
+          std::string value = label->get(n);
+          _node_index.insert(std::make_pair(n, value));
+        }
       }
     }
@@ -1328 +1328 @@
       _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;
-          break;
-        }
+          label = it->second;
+          break;
+        }
       }
 
       *_os << "@edges";
       if (!_edges_caption.empty()) {
-        _writer_bits::writeToken(*_os << ' ', _edges_caption);
+        _writer_bits::writeToken(*_os << ' ', _edges_caption);
       }
       *_os << std::endl;
@@ -1343 +1343 @@
       *_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) {
-        _writer_bits::writeToken(*_os, it->first) << '\t';
+           it != _edge_maps.end(); ++it) {
+        _writer_bits::writeToken(*_os, it->first) << '\t';
       }
       *_os << std::endl;
@@ -1353 +1353 @@
       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);
-        _writer_bits::MapLess<IdMap<Graph, Edge> > id_less(id_map);
-        std::sort(edges.begin(), edges.end(), id_less);
+        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);
+        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;
+        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;
       }
     }
@@ -1395 +1395 @@
       _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;
-          break;
-        }
+          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()));        
-        }       
+        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));
-        }
+        for (EdgeIt e(_graph); e != INVALID; ++e) {
+          std::string value = label->get(e);
+          _edge_index.insert(std::make_pair(e, value));
+        }
       }
     }
@@ -1420 +1420 @@
       *_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) {
-        _writer_bits::writeToken(*_os, it->first) << ' ';
-        _writer_bits::writeToken(*_os, it->second->get());
-        *_os << std::endl;
-      }
-    }
-    
+           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    
+
+    /// \name Execution of the writer
     /// @{
 
@@ -1441 +1441 @@
     void run() {
       if (!_skip_nodes) {
-        writeNodes();
+        writeNodes();
       } else {
-        createNodeIndex();
-      }
-      if (!_skip_edges) {      
-        writeEdges();
+        createNodeIndex();
+      }
+      if (!_skip_edges) {
+        writeEdges();
       } else {
-        createEdgeIndex();
+        createEdgeIndex();
       }
       writeAttributes();
@@ -1464 +1464 @@
 
   /// \brief Return a \ref GraphWriter class
-  /// 
+  ///
   /// This function just returns a \ref GraphWriter class.
   /// \relates GraphWriter
@@ -1474 +1474 @@
 
   /// \brief Return a \ref GraphWriter class
-  /// 
+  ///
   /// This function just returns a \ref GraphWriter class.
   /// \relates GraphWriter
@@ -1484 +1484 @@
 
   /// \brief Return a \ref GraphWriter class
-  /// 
+  ///
   /// This function just returns a \ref GraphWriter class.
   /// \relates GraphWriter