RhodeCode

    int line_num;

    std::istringstream line;

  public:

    /// \brief Constructor

    ///

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

    /// input stream.

    DigraphReader(Digraph& digraph, std::istream& is = std::cin)

      : _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.

    DigraphReader(Digraph& digraph, const std::string& fn)

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

        _filename(fn), _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.

    DigraphReader(Digraph& digraph, const char* fn)

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

        _filename(fn), _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;

      }

    }

    int line_num;

    std::istringstream line;

  public:

    /// \brief Constructor

    ///

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

    /// input stream.

    GraphReader(Graph& graph, std::istream& is = std::cin)

      : _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.

    GraphReader(Graph& graph, const std::string& fn)

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

        _filename(fn), _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.

    GraphReader(Graph& graph, const char* fn)

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

        _filename(fn), _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;

      }

    }

    bool local_is;

    std::string _filename;

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

        _filename(fn) {

    }

    /// \brief Constructor

    ///

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

    SectionReader(const char* fn)

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

        _filename(fn) {

    }

    /// \brief Destructor

    ~SectionReader() {

      for (Sections::iterator it = _sections.begin();

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

        delete it->second;

      }

      if (local_is) {

        delete _is;

      }

    }

  private:

    friend SectionReader sectionReader(std::istream& is);

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

    friend SectionReader sectionReader(const char* fn);

    SectionReader(SectionReader& other)

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

    std::vector<std::vector<std::string> > _node_maps;

    std::vector<std::vector<std::string> > _edge_maps;

    std::vector<std::vector<std::string> > _attributes;

    int line_num;

    std::istringstream line;

  public:

    /// \brief Constructor

    ///

    /// Construct an \e LGF contents reader, which reads from the given

    /// input stream.

    LgfContents(std::istream& is)

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

    /// \brief Constructor

    ///

    /// Construct an \e LGF contents reader, which reads from the given

    /// file.

    LgfContents(const std::string& fn)

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

    }

    /// \brief Constructor

    ///

    /// Construct an \e LGF contents reader, which reads from the given

    /// file.

    LgfContents(const char* fn)

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

    }

    /// \brief Destructor

    ~LgfContents() {

      if (local_is) delete _is;

    }

  private:

    LgfContents(const LgfContents&);

    LgfContents& operator=(const LgfContents&);

  public:

    /// \name Node sections

    /// @{

    /// \brief Gives back the number of node sections in the file.

    ///

    /// Gives back the number of node sections in the file.

    int nodeSectionNum() const {

      return _node_sections.size();

    }

    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.

    DigraphWriter(const Digraph& digraph, std::ostream& os = std::cout)

      : _os(&os), local_os(false), _digraph(digraph),

        _skip_nodes(false), _skip_arcs(false) {}

    /// \brief Constructor

    ///

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

    /// output file.

    DigraphWriter(const Digraph& digraph, const std::string& fn)

      : _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.

    DigraphWriter(const Digraph& digraph, const char* fn)

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

      }

    }

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

      _writer_bits::ValueStorageBase*> > Attributes;

    Attributes _attributes;

    bool _skip_nodes;

    bool _skip_edges;

  public:

    /// \brief Constructor

    ///

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

    /// output stream.

    GraphWriter(const Graph& graph, std::ostream& os = std::cout)

      : _os(&os), local_os(false), _graph(graph),

        _skip_nodes(false), _skip_edges(false) {}

    /// \brief Constructor

    ///

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

    /// output file.

    GraphWriter(const Graph& graph, const std::string& fn)

      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),

        _skip_nodes(false), _skip_edges(false) {

    }

    /// \brief Constructor

    ///

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

    /// output file.

    GraphWriter(const Graph& graph, const char* fn)

      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),

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

      }

      if (local_os) {

        delete _os;

      }

    }

  private:

    std::ostream* _os;

    bool local_os;

    typedef std::vector<std::pair<std::string, _writer_bits::Section*> >

    Sections;

    Sections _sections;

  public:

    /// \brief Constructor

    ///

    /// Construct a section writer, which writes to the given output

    /// stream.

    SectionWriter(std::ostream& os)

      : _os(&os), local_os(false) {}

    /// \brief Constructor

    ///

    /// Construct a section writer, which writes into the given file.

    SectionWriter(const std::string& fn)

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

    }

    /// \brief Constructor

    ///

    /// Construct a section writer, which writes into the given file.

    SectionWriter(const char* fn)

      : _os(new std::ofstream(fn)), local_os(true) {

    }

    /// \brief Destructor

    ~SectionWriter() {

      for (Sections::iterator it = _sections.begin();

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

        delete it->second;

      }

      if (local_os) {

        delete _os;

      }

    }

  private:

    friend SectionWriter sectionWriter(std::ostream& os);

    friend SectionWriter sectionWriter(const std::string& fn);

    friend SectionWriter sectionWriter(const char* fn);

    SectionWriter(SectionWriter& other)

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