RhodeCode

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * 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).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

///\ingroup demos

///\file

///\brief Demonstrating graph input and output

///

/// This program gives an example of how to read and write a digraph

/// and additional maps from/to a stream or a file using the

/// \ref lgf-format "LGF" format.

///

/// The \c "digraph.lgf" file:

/// \include digraph.lgf

///

/// And the program which reads it and prints the digraph to the

/// standard output:

/// \include lgf_demo.cc

#include <iostream>

#include <lemon/smart_graph.h>

#include <lemon/lgf_reader.h>

#include <lemon/lgf_writer.h>

using namespace lemon;

int main() {

  SmartDigraph g;

  SmartDigraph::ArcMap<int> cap(g);

  SmartDigraph::Node s, t;

  try {

      arcMap("capacity", cap).       // read the 'capacity' arc map into cap

      node("source", s).             // read 'source' node to s

      node("target", t).             // read 'target' node to t

      run();

  } catch (DataFormatError& error) { // check if there was any error

    std::cerr << "Error: " << error.what() << std::endl;

    return -1;

  }

  std::cout << "A digraph is read from 'digraph.lgf'." << std::endl;

  std::cout << "Number of nodes: " << countNodes(g) << std::endl;

  std::cout << "Number of arcs: " << countArcs(g) << std::endl;

  std::cout << "We can write it to the standard output:" << std::endl;

    arcMap("capacity", cap).       // write cap into 'capacity'

    node("source", s).             // write s to 'source'

    node("target", t).             // write t to 'target'

    run();

  return 0;

}

            getline(is, line);

            ++line_num;

          } else if (!isWhiteSpace(c)) {

            is.putback(c);

            getline(is, line);

            _functor(line);

            ++line_num;

          }

        }

        if (is) is.putback(c);

        else if (is.eof()) is.clear();

      }

    };

    template <typename Functor>

    class StreamSection : public Section {

    private:

      Functor _functor;

    public:

      StreamSection(const Functor& functor) : _functor(functor) {}

      virtual ~StreamSection() {}

      virtual void process(std::istream& is, int& line_num) {

        _functor(is, line_num);

        char c;

        std::string line;

        while (is.get(c) && c != '@') {

          if (c == '\n') {

            ++line_num;

          } else if (!isWhiteSpace(c)) {

            getline(is, line);

            ++line_num;

          }

        }

        if (is) is.putback(c);

        else if (is.eof()) is.clear();

      }

    };

  }

  template <typename Digraph>

  class DigraphReader;

  template <typename Digraph>

  template <typename Digraph>

  template <typename Digraph>

  /// \ingroup lemon_io

  ///

  /// \brief \ref lgf-format "LGF" reader for directed graphs

  ///

  /// This utility reads an \ref lgf-format "LGF" file.

  ///

  /// The reading method does a batch processing. The user creates a

  /// reader object, then various reading rules can be added to the

  /// reader, and eventually the reading is executed with the \c run()

  /// member function. A map reading rule can be added to the reader

  /// with the \c nodeMap() or \c arcMap() members. An optional

  /// converter parameter can also be added as a standard functor

  /// converting from \c std::string to the value type of the map. If it

  /// is set, it will determine how the tokens in the file should be

  /// converted to the value type of the map. If the functor is not set,

  /// then a default conversion will be used. One map can be read into

  /// multiple map objects at the same time. The \c attribute(), \c

  /// node() and \c arc() functions are used to add attribute reading

  /// rules.

  ///

  ///\code

  ///   nodeMap("coordinates", coord_map).

  ///   arcMap("capacity", cap_map).

  ///   node("source", src).

  ///   node("target", trg).

  ///   attribute("caption", caption).

  ///   run();

  ///\endcode

  ///

  /// By default the reader uses the first section in the file of the

  /// proper type. If a section has an optional name, then it can be

  /// selected for reading by giving an optional name parameter to the

  /// \c nodes(), \c arcs() or \c attributes() functions.

  ///

  /// The \c useNodes() and \c useArcs() functions are used to tell the reader

  /// that the nodes or arcs should not be constructed (added to the

  /// graph) during the reading, but instead the label map of the items

  /// are given as a parameter of these functions. An

  /// application of these functions is multipass reading, which is

  /// important if two \c \@arcs sections must be read from the

  /// file. In this case the first phase would read the node set and one

  /// of the arc sets, while the second phase would read the second arc

  /// set into an \e ArcSet class (\c SmartArcSet or \c ListArcSet).

  /// The previously read label node map should be passed to the \c

  /// useNodes() functions. Another application of multipass reading when

  /// paths are given as a node map or an arc map.

  /// It is impossible to read this in

  /// a single pass, because the arcs are not constructed when the node

  /// maps are read.

  template <typename _Digraph>

  class DigraphReader {

  public:

    typedef _Digraph Digraph;

    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

  private:

    std::istream* _is;

    bool local_is;

    Digraph& _digraph;

    std::string _nodes_caption;

    std::string _arcs_caption;

    std::string _attributes_caption;

    typedef std::map<std::string, Node> NodeIndex;

    NodeIndex _node_index;

    typedef std::map<std::string, Arc> ArcIndex;

    ArcIndex _arc_index;

    typedef std::vector<std::pair<std::string,

      _reader_bits::MapStorageBase<Node>*> > NodeMaps;

    NodeMaps _node_maps;

    typedef std::vector<std::pair<std::string,

      _reader_bits::MapStorageBase<Arc>*> >ArcMaps;

    ArcMaps _arc_maps;

    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*>

      Attributes;

    Attributes _attributes;

    bool _use_nodes;

    bool _use_arcs;

    bool _skip_nodes;

    bool _skip_arcs;

    int line_num;

    std::istringstream line;

  public:

    /// \brief Constructor

    ///

    /// Construct a directed graph reader, which reads from the given

    /// input stream.

      : _is(&is), local_is(false), _digraph(digraph),

        _use_nodes(false), _use_arcs(false),

        _skip_nodes(false), _skip_arcs(false) {}

    /// \brief Constructor

    ///

    /// Construct a directed graph reader, which reads from the given

    /// file.

      : _is(new std::ifstream(fn.c_str())), local_is(true), _digraph(digraph),

        _use_nodes(false), _use_arcs(false),

        _skip_nodes(false), _skip_arcs(false) {}

    /// \brief Constructor

    ///

    /// Construct a directed graph reader, which reads from the given

    /// file.

      : _is(new std::ifstream(fn)), local_is(true), _digraph(digraph),

        _use_nodes(false), _use_arcs(false),

        _skip_nodes(false), _skip_arcs(false) {}

    /// \brief Destructor

    ~DigraphReader() {

      for (typename NodeMaps::iterator it = _node_maps.begin();

           it != _node_maps.end(); ++it) {

        delete it->second;

      }

      for (typename ArcMaps::iterator it = _arc_maps.begin();

           it != _arc_maps.end(); ++it) {

        delete it->second;

      }

      for (typename Attributes::iterator it = _attributes.begin();

           it != _attributes.end(); ++it) {

        delete it->second;

      }

      if (local_is) {

        delete _is;

      }

    }

  private:

    DigraphReader(DigraphReader& other)

      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),

        _use_nodes(other._use_nodes), _use_arcs(other._use_arcs),

        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {

      other._is = 0;

      other.local_is = false;

      _node_index.swap(other._node_index);

      _arc_index.swap(other._arc_index);

      _node_maps.swap(other._node_maps);

      _arc_maps.swap(other._arc_maps);

      _attributes.swap(other._attributes);

      _nodes_caption = other._nodes_caption;

      _arcs_caption = other._arcs_caption;

      _attributes_caption = other._attributes_caption;

    }

    DigraphReader& operator=(const DigraphReader&);

  public:

    /// \name Reading rules

    /// @{

    /// \brief Node map reading rule

    ///

    /// Add a node map reading rule to the reader.

    template <typename Map>

    DigraphReader& nodeMap(const std::string& caption, Map& map) {

      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();

      _reader_bits::MapStorageBase<Node>* storage =

        new _reader_bits::MapStorage<Node, Map>(map);

      _node_maps.push_back(std::make_pair(caption, storage));

      return *this;

    }

    /// \brief Node map reading rule

    ///

    /// Add a node map reading rule with specialized converter to the

    /// reader.

    template <typename Map, typename Converter>

    DigraphReader& nodeMap(const std::string& caption, Map& map,

                           const Converter& converter = Converter()) {

            if (_nodes_caption.empty() || _nodes_caption == caption) {

              readNodes();

              nodes_done = true;

            }

          } else if ((section == "arcs" || section == "edges") &&

                     !arcs_done) {

            if (_arcs_caption.empty() || _arcs_caption == caption) {

              readArcs();

              arcs_done = true;

            }

          } else if (section == "attributes" && !attributes_done) {

            if (_attributes_caption.empty() || _attributes_caption == caption) {

              readAttributes();

              attributes_done = true;

            }

          } else {

            readLine();

            skipSection();

          }

        } catch (DataFormatError& error) {

          error.line(line_num);

          throw;

        }

      }

      if (!nodes_done) {

        throw DataFormatError("Section @nodes not found");

      }

      if (!arcs_done) {

        throw DataFormatError("Section @arcs not found");

      }

      if (!attributes_done && !_attributes.empty()) {

        throw DataFormatError("Section @attributes not found");

      }

    }

    /// @}

  };

  /// \brief Return a \ref DigraphReader class

  ///

  /// This function just returns a \ref DigraphReader class.

  /// \relates DigraphReader

  template <typename Digraph>

    return tmp;

  }

  /// \brief Return a \ref DigraphReader class

  ///

  /// This function just returns a \ref DigraphReader class.

  /// \relates DigraphReader

  template <typename Digraph>

    return tmp;

  }

  /// \brief Return a \ref DigraphReader class

  ///

  /// This function just returns a \ref DigraphReader class.

  /// \relates DigraphReader

  template <typename Digraph>

    return tmp;

  }

  template <typename Graph>

  class GraphReader;

  template <typename Graph>

  template <typename Graph>

  template <typename Graph>

  /// \ingroup lemon_io

  ///

  /// \brief \ref lgf-format "LGF" reader for undirected graphs

  ///

  /// This utility reads an \ref lgf-format "LGF" file.

  ///

  /// It can be used almost the same way as \c DigraphReader.

  /// The only difference is that this class can handle edges and

  /// edge maps as well as arcs and arc maps.

  ///

  /// The columns in the \c \@edges (or \c \@arcs) section are the

  /// edge maps. However, if there are two maps with the same name

  /// prefixed with \c '+' and \c '-', then these can be read into an

  /// arc map.  Similarly, an attribute can be read into an arc, if

  /// it's value is an edge label prefixed with \c '+' or \c '-'.

  template <typename _Graph>

  class GraphReader {

  public:

    typedef _Graph Graph;

    TEMPLATE_GRAPH_TYPEDEFS(Graph);

  private:

    std::istream* _is;

    bool local_is;

    Graph& _graph;

    std::string _nodes_caption;

    std::string _edges_caption;

    std::string _attributes_caption;

    typedef std::map<std::string, Node> NodeIndex;

    NodeIndex _node_index;

    typedef std::map<std::string, Edge> EdgeIndex;

    EdgeIndex _edge_index;

    typedef std::vector<std::pair<std::string,

      _reader_bits::MapStorageBase<Node>*> > NodeMaps;

    NodeMaps _node_maps;

    typedef std::vector<std::pair<std::string,

      _reader_bits::MapStorageBase<Edge>*> > EdgeMaps;

    EdgeMaps _edge_maps;

    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*>

      Attributes;

    Attributes _attributes;

    bool _use_nodes;

    bool _use_edges;

    bool _skip_nodes;

    bool _skip_edges;

    int line_num;

    std::istringstream line;

  public:

    /// \brief Constructor

    ///

    /// Construct an undirected graph reader, which reads from the given

    /// input stream.

      : _is(&is), local_is(false), _graph(graph),

        _use_nodes(false), _use_edges(false),

        _skip_nodes(false), _skip_edges(false) {}

    /// \brief Constructor

    ///

    /// Construct an undirected graph reader, which reads from the given

    /// file.

      : _is(new std::ifstream(fn.c_str())), local_is(true), _graph(graph),

        _use_nodes(false), _use_edges(false),

        _skip_nodes(false), _skip_edges(false) {}

    /// \brief Constructor

    ///

    /// Construct an undirected graph reader, which reads from the given

    /// file.

      : _is(new std::ifstream(fn)), local_is(true), _graph(graph),

        _use_nodes(false), _use_edges(false),

        _skip_nodes(false), _skip_edges(false) {}

    /// \brief Destructor

    ~GraphReader() {

      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_is) {

        delete _is;

      }

    }

  private:

    GraphReader(GraphReader& other)

      : _is(other._is), local_is(other.local_is), _graph(other._graph),

        _use_nodes(other._use_nodes), _use_edges(other._use_edges),

        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {

      other._is = 0;

      other.local_is = false;

      _node_index.swap(other._node_index);

      _edge_index.swap(other._edge_index);

      _node_maps.swap(other._node_maps);

      _edge_maps.swap(other._edge_maps);

      _attributes.swap(other._attributes);

      _nodes_caption = other._nodes_caption;

      _edges_caption = other._edges_caption;

      _attributes_caption = other._attributes_caption;

    }

    GraphReader& operator=(const GraphReader&);

  public:

    /// \name Reading rules

    /// @{

    /// \brief Node map reading rule

    ///

    /// Add a node map reading rule to the reader.

    template <typename Map>

    GraphReader& nodeMap(const std::string& caption, Map& map) {

      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();

      _reader_bits::MapStorageBase<Node>* storage =

        new _reader_bits::MapStorage<Node, Map>(map);

      _node_maps.push_back(std::make_pair(caption, storage));

      return *this;

    }

    /// \brief Node map reading rule

    ///

    /// Add a node map reading rule with specialized converter to the

    /// reader.

    template <typename Map, typename Converter>

    GraphReader& nodeMap(const std::string& caption, Map& map,

                           const Converter& converter = Converter()) {

            if (_nodes_caption.empty() || _nodes_caption == caption) {

              readNodes();

              nodes_done = true;

            }

          } else if ((section == "edges" || section == "arcs") &&

                     !edges_done) {

            if (_edges_caption.empty() || _edges_caption == caption) {

              readEdges();

              edges_done = true;

            }

          } else if (section == "attributes" && !attributes_done) {

            if (_attributes_caption.empty() || _attributes_caption == caption) {

              readAttributes();

              attributes_done = true;

            }

          } else {

            readLine();

            skipSection();

          }

        } catch (DataFormatError& error) {

          error.line(line_num);

          throw;

        }

      }

      if (!nodes_done) {

        throw DataFormatError("Section @nodes not found");

      }

      if (!edges_done) {

        throw DataFormatError("Section @edges not found");

      }

      if (!attributes_done && !_attributes.empty()) {

        throw DataFormatError("Section @attributes not found");

      }

    }

    /// @}

  };

  /// \brief Return a \ref GraphReader class

  ///

  /// This function just returns a \ref GraphReader class.

  /// \relates GraphReader

  template <typename Graph>

    return tmp;

  }

  /// \brief Return a \ref GraphReader class

  ///

  /// This function just returns a \ref GraphReader class.

  /// \relates GraphReader

  template <typename Graph>

    return tmp;

  }

  /// \brief Return a \ref GraphReader class

  ///

  /// This function just returns a \ref GraphReader class.

  /// \relates GraphReader

  template <typename Graph>

    return tmp;

  }

  class SectionReader;

  SectionReader sectionReader(std::istream& is);

  SectionReader sectionReader(const std::string& fn);

  SectionReader sectionReader(const char* fn);

  /// \ingroup lemon_io

  ///

  /// \brief Section reader class

  ///

  /// In the \ref lgf-format "LGF" file extra sections can be placed,

  /// which contain any data in arbitrary format. Such sections can be

  /// read with this class. A reading rule can be added to the class

  /// with two different functions. With the \c sectionLines() function a

  /// functor can process the section line-by-line, while with the \c

  /// sectionStream() member the section can be read from an input

  /// stream.

  class SectionReader {

  private:

    std::istream* _is;

    bool local_is;

    typedef std::map<std::string, _reader_bits::Section*> Sections;

    Sections _sections;

    int line_num;

    std::istringstream line;

  public:

    /// \brief Constructor

    ///

    /// Construct a section reader, which reads from the given input

    /// stream.

    SectionReader(std::istream& is)

      : _is(&is), local_is(false) {}

    /// \brief Constructor

    ///

    /// Construct a section reader, which reads from the given file.

    SectionReader(const std::string& fn)

      : _is(new std::ifstream(fn.c_str())), local_is(true) {}

    /// \brief Constructor

      return os;

    }

    class Section {

    public:

      virtual ~Section() {}

      virtual void process(std::ostream& os) = 0;

    };

    template <typename Functor>

    class LineSection : public Section {

    private:

      Functor _functor;

    public:

      LineSection(const Functor& functor) : _functor(functor) {}

      virtual ~LineSection() {}

      virtual void process(std::ostream& os) {

        std::string line;

        while (!(line = _functor()).empty()) os << line << std::endl;

      }

    };

    template <typename Functor>

    class StreamSection : public Section {

    private:

      Functor _functor;

    public:

      StreamSection(const Functor& functor) : _functor(functor) {}

      virtual ~StreamSection() {}

      virtual void process(std::ostream& os) {

        _functor(os);

      }

    };

  }

  template <typename Digraph>

  class DigraphWriter;

  template <typename Digraph>

  template <typename Digraph>

  template <typename 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

  /// writer object, then various writing rules can be added to the

  /// writer, and eventually the writing is executed with the \c run()

  /// member function. A map writing rule can be added to the writer

  /// with the \c nodeMap() or \c arcMap() members. An optional

  /// converter parameter can also be added as a standard functor

  /// converting from the value type of the map to \c std::string. If it

  /// is set, it will determine how the value type of the map is written to

  /// the output stream. If the functor is not set, then a default

  /// conversion will be used. The \c attribute(), \c node() and \c

  /// arc() functions are used to add attribute writing rules.

  ///

  ///\code

  ///   nodeMap("coordinates", coord_map).

  ///   nodeMap("size", size).

  ///   nodeMap("title", title).

  ///   arcMap("capacity", cap_map).

  ///   node("source", src).

  ///   node("target", trg).

  ///   attribute("caption", caption).

  ///   run();

  ///\endcode

  ///

  ///

  /// By default, the writer does not write additional captions to the

  /// sections, but they can be give as an optional parameter of

  /// the \c nodes(), \c arcs() or \c

  /// attributes() functions.

  ///

  /// The \c skipNodes() and \c skipArcs() functions forbid the

  /// writing of the sections. If two arc sections should be written

  /// to the output, it can be done in two passes, the first pass

  /// writes the node section and the first arc section, then the

  /// second pass skips the node section and writes just the arc

  /// section to the stream. The output stream can be retrieved with

  /// the \c ostream() function, hence the second pass can append its

  /// output to the output of the first pass.

  template <typename _Digraph>

  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;

  public:

    /// \brief Constructor

    ///

    /// Construct a directed graph writer, which writes to the given

    /// output stream.

        _skip_nodes(false), _skip_arcs(false) {}

    /// \brief Constructor

    ///

    /// Construct a directed graph writer, which writes to the given

    /// output file.

      : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),

        _skip_nodes(false), _skip_arcs(false) {}

    /// \brief Constructor

    ///

    /// Construct a directed graph writer, which writes to the given

    /// output file.

      : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),

        _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;

      }

      if (local_os) {

        delete _os;

      }

    }

  private:

    DigraphWriter(DigraphWriter& other)

      : _os(other._os), local_os(other.local_os), _digraph(other._digraph),

        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {

      other._os = 0;

      other.local_os = false;

      _node_index.swap(other._node_index);

      _arc_index.swap(other._arc_index);

      _node_maps.swap(other._node_maps);

      _arc_maps.swap(other._arc_maps);

      _attributes.swap(other._attributes);

      _nodes_caption = other._nodes_caption;

      _arcs_caption = other._arcs_caption;

      _attributes_caption = other._attributes_caption;

    }

    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);

      _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()) {

      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();

      _writer_bits::MapStorageBase<Node>* storage =

        _writer_bits::writeToken(*_os << ' ', _attributes_caption);

      }

      *_os << std::endl;

      for (typename Attributes::iterator it = _attributes.begin();

           it != _attributes.end(); ++it) {

        _writer_bits::writeToken(*_os, it->first) << ' ';

        _writer_bits::writeToken(*_os, it->second->get());

        *_os << std::endl;

      }

    }

  public:

    /// \name Execution of the writer

    /// @{

    /// \brief Start the batch processing

    ///

    /// This function starts the batch processing.

    void run() {

      if (!_skip_nodes) {

        writeNodes();

      } else {

        createNodeIndex();

      }

      if (!_skip_arcs) {

        writeArcs();

      } else {

        createArcIndex();

      }

      writeAttributes();

    }

    /// \brief Give back the stream of the writer

    ///

    /// Give back the stream of the writer.

    std::ostream& ostream() {

      return *_os;

    }

    /// @}

  };

  /// \brief Return a \ref DigraphWriter class

  ///

  /// This function just returns a \ref DigraphWriter class.

  /// \relates DigraphWriter

  template <typename Digraph>

    return tmp;

  }

  /// \brief Return a \ref DigraphWriter class

  ///

  /// This function just returns a \ref DigraphWriter class.

  /// \relates DigraphWriter

  template <typename Digraph>

    return tmp;

  }

  /// \brief Return a \ref DigraphWriter class

  ///

  /// This function just returns a \ref DigraphWriter class.

  /// \relates DigraphWriter

  template <typename Digraph>

    return tmp;

  }