RhodeCode

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

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

  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;

/**

@defgroup lemon_io Lemon Input-Output

@ingroup io_group

*/

/**

@defgroup eps_io Postscript exporting

character sequence surrounded by double quotes, and it can also

contain whitespaces and escape sequences. 

The \c \@nodes section describes a set of nodes and associated

maps appearing in the following lines.

One of the maps must be called \c

"label", which plays special role in the file.

The following

 3       (40,10)     10      "Third node"

\endcode

The \c \@arcs section is very similar to the \c \@nodes section,

but the \c "label" map is not obligatory here. The following lines

describe the arcs. The first two tokens of each line are

the source and the target node of the arc, respectively, then come the map

values. The source and target tokens must be node labels.

 */

///\ingroup lemon_io

///\file

#ifndef LEMON_LGF_READER_H

#define LEMON_LGF_READER_H

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

  /// \ingroup lemon_io

  ///  

  ///

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

  ///

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

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

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

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

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

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

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

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

  /// maps are read.

  template <typename _Digraph>

  class DigraphReader {

    /// \brief Use previously constructed node set

    ///

    /// Use previously constructed node set, and specify the node

    /// label map and a functor which converts the label map values to

    template <typename Map, typename Converter>

    DigraphReader& useNodes(const Map& map, 

			    const Converter& converter = Converter()) {

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

    /// \brief Use previously constructed arc set

    ///

    /// Use previously constructed arc set, and specify the arc

    /// label map and a functor which converts the label map values to

    template <typename Map, typename Converter>

    DigraphReader& useArcs(const Map& map, 

			   const Converter& converter = Converter()) {

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

    /// \brief Skips the reading of node section

    ///

    /// Omit the reading of the node section. This implies that each node

    /// will not be constructed, which usually cause that the arc set

    DigraphReader& skipNodes() {

      LEMON_ASSERT(!_skip_nodes, "Skip nodes already set"); 

      _skip_nodes = true;

      return *this;

    /// \brief Skips the reading of arc section

    ///

    /// Omit the reading of the arc section. This implies that each arc

    /// will not be constructed.

    DigraphReader& skipArcs() {

      LEMON_ASSERT(!_skip_arcs, "Skip arcs already set"); 

      _skip_arcs = true;

    /// @}

  };

  /// \relates DigraphReader

  template <typename Digraph>

  DigraphReader<Digraph> digraphReader(std::istream& is, Digraph& digraph) {

    DigraphReader<Digraph> tmp(is, digraph);

    return tmp;

  }

  /// \relates DigraphReader

  template <typename Digraph>

  DigraphReader<Digraph> digraphReader(const std::string& fn, 

				       Digraph& digraph) {

    DigraphReader<Digraph> tmp(fn, digraph);

    return tmp;

  }

  /// \relates DigraphReader

  template <typename Digraph>

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

    DigraphReader<Digraph> tmp(fn, digraph);

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

  /// \ingroup lemon_io

  ///  

  ///

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

  template <typename _Graph>

  class GraphReader {

  public:

  public:

    /// \brief Constructor

    ///

    /// input stream.

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

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

	_use_nodes(false), _use_edges(false),

	_skip_nodes(false), _skip_edges(false) {}

    /// \brief Constructor

    ///

    /// file.

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

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

    ///

    /// file.

    GraphReader(const char* fn, Graph& graph) 

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

    	_use_nodes(false), _use_edges(false),

    /// @{

    /// \brief Set \c \@nodes section to be read

    ///

    GraphReader& nodes(const std::string& caption) {

      _nodes_caption = caption;

      return *this;

    }

    /// \brief Set \c \@edges section to be read

    ///

    GraphReader& edges(const std::string& caption) {

      _edges_caption = caption;

      return *this;

    }

    /// \brief Set \c \@attributes section to be read

    ///

    GraphReader& attributes(const std::string& caption) {

      _attributes_caption = caption;

      return *this;

    }

    /// \brief Use previously constructed node set

    ///

    /// Use previously constructed node set, and specify the node

    /// label map and a functor which converts the label map values to

    template <typename Map, typename Converter>

    GraphReader& useNodes(const Map& map, 

			    const Converter& converter = Converter()) {

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

    /// \brief Use previously constructed edge set

    ///

    /// Use previously constructed edge set, and specify the edge

    /// label map and a functor which converts the label map values to

    template <typename Map, typename Converter>

    GraphReader& useEdges(const Map& map, 

			    const Converter& converter = Converter()) {

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

      }

      return *this;

    }

    ///

    /// Omit the reading of the node section. This implies that each node

    /// will not be constructed, which usually cause that the edge set

    /// could not be read due to lack of node name

    GraphReader& skipNodes() {

      LEMON_ASSERT(!_skip_nodes, "Skip nodes already set"); 

      _skip_nodes = true;

      return *this;

    }

    ///

    /// Omit the reading of the edge section. This implies that each edge

    /// will not be constructed.

    GraphReader& skipEdges() {

      LEMON_ASSERT(!_skip_edges, "Skip edges already set"); 

      _skip_edges = true;

    /// @}

  };

  /// \relates GraphReader

  template <typename Graph>

  GraphReader<Graph> graphReader(std::istream& is, Graph& graph) {

    GraphReader<Graph> tmp(is, graph);

    return tmp;

  }

  /// \relates GraphReader

  template <typename Graph>

  GraphReader<Graph> graphReader(const std::string& fn, 

				       Graph& graph) {

    GraphReader<Graph> tmp(fn, graph);

    return tmp;

  }

  /// \relates GraphReader

  template <typename Graph>

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

    GraphReader<Graph> tmp(fn, graph);

  SectionReader sectionReader(std::istream& is);

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

  SectionReader sectionReader(const char* fn);

  /// \brief Section reader class

  ///

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

  /// stream.

  class SectionReader {

  private:

    ///  4

    ///  23 6

    ///\endcode

    ///

    ///\code

    ///  struct NumberSection {

    ///    std::vector<int>& _data;

    ///    NumberSection(std::vector<int>& data) : _data(data) {}

    ///  reader.sectionLines("numbers", NumberSection(vec));  

    ///\endcode

    template <typename Functor>

    SectionReader& sectionLines(const std::string& type, Functor functor) {

      LEMON_ASSERT(_sections.find(type) == _sections.end(), 

		   "Multiple reading of section.");

      _sections.insert(std::make_pair(type, 

        new _reader_bits::LineSection<Functor>(functor)));

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

    ///

    /// The first parameter is the type of the section, the second is

    /// parameter, the latter regard to the line number of stream. The

    /// functor can read the input while the section go on, and the

    /// line number should be modified accordingly.

    template <typename Functor>

    SectionReader& sectionStream(const std::string& type, Functor functor) {

      LEMON_ASSERT(_sections.find(type) == _sections.end(), 

		   "Multiple reading of section.");

      _sections.insert(std::make_pair(type, 

	 new _reader_bits::StreamSection<Functor>(functor)));

    /// @{

    /// \brief Start the batch processing

    ///

    void run() {

      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");

    /// @}

  };

  /// \relates SectionReader

  inline SectionReader sectionReader(std::istream& is) {

    SectionReader tmp(is);

    return tmp;

  }

  /// \relates SectionReader

  inline SectionReader sectionReader(const std::string& fn) {

    SectionReader tmp(fn);

    return tmp;

  }

  /// \relates SectionReader

  inline SectionReader sectionReader(const char* fn) {

    SectionReader tmp(fn);

    return tmp;

  /// the contents of an LGF file should be guessed somehow. This class

  /// reads the graph and stores the appropriate information for

  /// reading the graph.

  ///

  /// contents.run();

  ///

  /// if (contents.nodeSectionNum() == 0 || contents.arcSectionNum()) {

  ///   return -1;

  /// }

  ///           << contents.nodeSection(0) << std::endl;

  ///           << contents.arcMaps(0).size() << std::endl;

  ///           << contents.arcMaps(0)[1] << std::endl;

  ///\endcode

  class LgfContents {    

  private:

    int nodeSectionNum() const {

      return _node_sections.size();

    }

    ///

    const std::string& nodeSection(int i) const {

      return _node_sections[i];

    }

    int arcSectionNum() const {

      return _edge_sections.size();

    }

    ///

    /// \note It is synonym of \c edgeSection().

    const std::string& arcSection(int i) const {

      return _edge_sections[i];

    }

    int attributeSectionNum() const {

      return _attribute_sections.size();

    }

    ///

    const std::string& attributeSectionNames(int i) const {

      return _attribute_sections[i];

    }

    /// \name Execution of the contents reader    

    /// @{

    ///

    void run() {

      readLine();

      skipSection();

 */

///\ingroup lemon_io

///\file

#ifndef LEMON_LGF_WRITER_H

#define LEMON_LGF_WRITER_H

				       const Digraph& digraph);

  /// \ingroup lemon_io

  ///  

  ///

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

  ///

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

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

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

  ///\endcode

  ///

  ///

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

    /// \name Writing rules

    /// @{

    ///

    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 = 

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

      return *this;

    }

    /// @{

    ///

    DigraphWriter& nodes(const std::string& caption) {

      _nodes_caption = caption;

      return *this;

    }

    ///

    DigraphWriter& arcs(const std::string& caption) {

      _arcs_caption = caption;

      return *this;

    }

    ///

    DigraphWriter& attributes(const std::string& caption) {

      _attributes_caption = caption;

      return *this;

    }

    /// @{

    /// \brief Skip writing the node set

    ///

    DigraphWriter& skipNodes() {

      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");

      _skip_nodes = true;

      return *this;

    }

    /// \brief Skip writing arc set

    ///

    DigraphWriter& skipArcs() {

      LEMON_ASSERT(!_skip_arcs, "Multiple usage of skipArcs() member");

      _skip_arcs = true;

      return *this;

    /// @{

    /// \brief Start the batch processing

    ///

    void run() {

      if (!_skip_nodes) {

	writeNodes();

      } else {

      }

      writeAttributes();

    }

    ///

    std::ostream& ostream() {

      return *_os;

    }

    /// @}

  };

  /// \relates DigraphWriter

  template <typename Digraph>

  DigraphWriter<Digraph> digraphWriter(std::ostream& os, 

				       const Digraph& digraph) {

    DigraphWriter<Digraph> tmp(os, digraph);

    return tmp;

  }

  /// \relates DigraphWriter

  template <typename Digraph>

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

				       const Digraph& digraph) {

    DigraphWriter<Digraph> tmp(fn, digraph);

    return tmp;

  }

  /// \relates DigraphWriter

  template <typename Digraph>

  DigraphWriter<Digraph> digraphWriter(const char* fn, 

				       const Digraph& digraph) {

  GraphWriter<Graph> graphWriter(const char *fn, const Graph& graph);    

  /// \ingroup lemon_io

  ///  

  ///

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

  template <typename _Graph>

  class GraphWriter {

  public:

    /// \name Writing rules

    /// @{

    ///

    template <typename Map>

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

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

      _writer_bits::MapStorageBase<Node>* storage = 

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

      return *this;

    }

    /// @{

    ///

    GraphWriter& nodes(const std::string& caption) {

      _nodes_caption = caption;

      return *this;

    }

    ///

    GraphWriter& edges(const std::string& caption) {

      _edges_caption = caption;

      return *this;

    }

    ///

    GraphWriter& attributes(const std::string& caption) {

      _attributes_caption = caption;

      return *this;

    }

    /// @{

    /// \brief Skip writing the node set

    ///

    GraphWriter& skipNodes() {

      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");

      _skip_nodes = true;

      return *this;

    }

    /// \brief Skip writing edge set

    ///

    GraphWriter& skipEdges() {

      LEMON_ASSERT(!_skip_edges, "Multiple usage of skipEdges() member");

      _skip_edges = true;

      return *this;

    /// @{

    /// \brief Start the batch processing

    ///

    void run() {

      if (!_skip_nodes) {

	writeNodes();

      } else {

      }

      writeAttributes();

    }

    ///

    std::ostream& ostream() {

      return *_os;

    }

    /// @}

  };

  /// \relates GraphWriter

  template <typename Graph>

  GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph) {

    GraphWriter<Graph> tmp(os, graph);

    return tmp;

  }

  /// \relates GraphWriter

  template <typename Graph>

  GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph) {

    GraphWriter<Graph> tmp(fn, graph);

    return tmp;

  }

  /// \relates GraphWriter

  template <typename Graph>

  GraphWriter<Graph> graphWriter(const char* fn, const Graph& graph) {

    GraphWriter<Graph> tmp(fn, graph);