RhodeCode

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;

  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;

  }

  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.

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

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

      }

    }

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

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

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

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

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

  }

  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.

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

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

        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;

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

  }

  template <typename Graph>

  class GraphWriter;

  template <typename Graph>

  template <typename Graph>

  template <typename Graph>

  /// \ingroup lemon_io

  ///

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

  ///

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

  public:

    /// \brief Constructor

    ///

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

    /// output stream.

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

        delete _os;

      }

    }

  private:

    GraphWriter(GraphWriter& other)

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

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

      other._os = 0;

  /// \brief Return a \ref GraphWriter class

  ///

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

  /// \relates GraphWriter

  template <typename Graph>

    return tmp;

  }

  /// \brief Return a \ref GraphWriter class

  ///

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

  /// \relates GraphWriter

  template <typename Graph>

    return tmp;

  }

  /// \brief Return a \ref GraphWriter class

  ///

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

  /// \relates GraphWriter

  template <typename Graph>

    return tmp;

  }

  class SectionWriter;

  SectionWriter sectionWriter(std::istream& is);

  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

  Digraph G;

  Node s, t;

  std::istringstream input(test_lgf);

    node("source", s).

    node("target", t).

    run();

  Bfs<Digraph> bfs_test(G);

  bfs_test.run(s);

  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

  Digraph G;

  Node s, t;

  std::istringstream input(test_lgf);

    node("source", s).

    node("target", t).

    run();

  Dfs<Digraph> dfs_test(G);

  dfs_test.run(s);

  Digraph G;

  Node s, t;

  LengthMap length(G);

  std::istringstream input(test_lgf);

    arcMap("length", length).

    node("source", s).

    node("target", t).

    run();

  Dijkstra<Digraph, LengthMap>

  Digraph digraph;

  IntArcMap length(digraph);

  Node source;

  std::istringstream input(test_lgf);

    arcMap("capacity", length).

    node("source", source).

    run();

  {

    typedef BinHeap<Prio, ItemIntMap> IntHeap;