RhodeCode

	}

	if (is) is.putback(c);

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

      }

    };

  }

  /// \ingroup lemon_io

  ///  

  /// \brief 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

    ///

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

    /// file.

    DigraphReader(const char* fn, Digraph& digraph) 

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

      if (local_is) {

	delete _is;

      }

    }

  private:

    DigraphReader& operator=(const DigraphReader&);

  public:

    /// \name Reading rules

    /// @{

    /// \brief Node map reading rule

  /// \relates DigraphReader

  template <typename Digraph>

  DigraphReader<Digraph> digraphReader(const char* fn, Digraph& digraph) {

    DigraphReader<Digraph> tmp(fn, digraph);

    return tmp;

  }

  /// \ingroup lemon_io

  ///  

  /// \brief LGF reader for undirected graphs

  ///

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

  template <typename _Graph>

  class GraphReader {

  public:

    ///

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

    /// file.

    GraphReader(const char* fn, Graph& graph) 

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

      if (local_is) {

	delete _is;

      }

    }

  private:

    GraphReader& operator=(const GraphReader&);

  public:

    /// \name Reading rules

    /// @{

  /// \relates GraphReader

  template <typename Graph>

  GraphReader<Graph> graphReader(const char* fn, Graph& graph) {

    GraphReader<Graph> tmp(fn, graph);

    return tmp;

  }

  /// \brief Section reader class

  ///

  /// In the \e 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 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

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

    /// \brief Constructor

    ///

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

    SectionReader(const char* fn) 

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

    /// \brief Destructor

    ~SectionReader() {

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

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

	delete it->second;

      }

      if (local_is) {

	delete _is;

      }

    }

  private:

    SectionReader& operator=(const SectionReader&);

  public:

    /// \name Section readers

    /// @{

    /// \brief Add a section processor with line oriented reading

    /// \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;

    }

    /// \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 {

      } else {

	os << str;

      }

      return os;

    }

  }

  /// \ingroup lemon_io

  ///  

  /// \brief 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

    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

  private:

    std::ostream* _os;

    bool local_os;

    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;

    bool _skip_arcs;

  public:

    /// \brief Constructor

    ///

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

    /// output stream.

      : _os(&is), 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.

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

      if (local_os) {

	delete _os;

      }

    }

  private:

    DigraphWriter& operator=(const DigraphWriter&);

  public:

    /// \name Writing rules

    /// @{

    /// \brief Node map reading rule

      return *_os;

    }

    /// @}

  };

  /// \relates DigraphWriter

  template <typename Digraph>

    DigraphWriter<Digraph> tmp(os, digraph);

    return tmp;

  }

  /// \relates DigraphWriter

  template <typename Digraph>

  DigraphWriter<Digraph> digraphWriter(const std::string& fn, 

    DigraphWriter<Digraph> tmp(fn, digraph);

    return tmp;

  }

  /// \relates DigraphWriter

  template <typename Digraph>

    DigraphWriter<Digraph> tmp(fn, digraph);

    return tmp;

  }

  /// \ingroup lemon_io

  ///  

  /// \brief LGF writer for directed graphs

  ///

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

  template <typename _Graph>

  class GraphWriter {

  public:

    bool _skip_edges;

  public:

    /// \brief Constructor

    ///

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

    /// output stream.

      : _os(&is), 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.

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

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

      if (local_os) {

	delete _os;

      }

    }

  private:

    GraphWriter& operator=(const GraphWriter&);

  public:

    /// \name Writing rules

    /// @{

    /// \brief Node map reading rule

      return *_os;

    }

    /// @}

  };

  /// \relates GraphWriter

  template <typename Graph>

    GraphWriter<Graph> tmp(os, graph);

    return tmp;

  }

  /// \relates GraphWriter

  template <typename Graph>

    GraphWriter<Graph> tmp(fn, graph);

    return tmp;

  }

  /// \relates GraphWriter

  template <typename Graph>

    GraphWriter<Graph> tmp(fn, graph);

    return tmp;

  }

}

#endif