/* -*- C++ -*-

  *

  * This file is a part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2003-2007

  * 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 lemon_io

 ///\file

 ///\brief Lemon Graph Format reader.

 #ifndef LEMON_GRAPH_READER_H

 #define LEMON_GRAPH_READER_H

 #include <iostream>

 #include <lemon/error.h>

 #include <lemon/lemon_reader.h>

 namespace lemon {

   /// \addtogroup lemon_io

   /// @{

   /// \brief The graph reader class.

   ///

   /// The \c GraphReader class provides the graph input. 

   /// Before you read this documentation it might be useful to read the general

   /// description of  \ref graph-io-page "Graph Input-Output".

   ///

   /// The file to be read may contain several maps and labeled

   /// (designated) nodes or edges.

   ///

   /// If you read a graph you need not read all the maps and items just those

   /// that you need. The interface of the \c GraphReader is very similar to

   /// the GraphWriter but the reading method does not depend on the order the

   /// given commands (i.e. you don't have to insist on the order in which the

   /// maps are given in the file).

   ///

   /// The reader object assumes that not read values do not contain 

   /// whitespaces, therefore it has some extra possibilities to control how

   /// it should skip the values when the string representation contains spaces.

   ///

   ///\code

   /// GraphReader<ListGraph> reader(std::cin, graph);

   ///\endcode

   ///

   /// The \c readNodeMap() function reads a map from the \c \@nodeset section.

   /// If there is a map that you do not want to read from the file and there is

   /// whitespace in the string represenation of the values then you should

   /// call the \c skipNodeMap() template member function with proper 

   /// parameters.

   ///

   ///\code

   /// reader.readNodeMap("coords", coords);

   ///

   /// reader.skipNodeMap("description", desc);

   ///

   /// reader.readNodeMap("color", colorMap);

   ///\endcode

   ///

   /// With the \c readEdgeMap() member function you can give an edge map

   /// reading command similar to the NodeMaps. 

   ///

   ///\code

   /// reader.readEdgeMap("weight", weightMap);

   /// reader.readEdgeMap("label", labelMap);

   ///\endcode

   ///

   /// With \c readNode() and \c readEdge() functions you can read 

   /// labeled Nodes and Edges.

   ///

   ///\code

   /// reader.readNode("source", sourceNode);

   /// reader.readNode("target", targetNode);

   ///

   /// reader.readEdge("observed", edge);

   ///\endcode

   ///

   /// With the \c readAttribute() functions you can read an attribute

   /// into a variable. You can specify the reader for the attribute as

   /// the nodemaps.

   ///

   /// After you give all read commands you must call the \c run() member

   /// function, which executes all the commands.

   ///

   ///\code

   /// reader.run();

   ///\endcode

   ///

   /// \see DefaultReaderTraits

   /// \see QuotedStringReader

   /// \see \ref GraphWriter

   /// \see \ref graph-io-page

   /// \author Balazs Dezso

   template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 

   class GraphReader {

   public:

     typedef _Graph Graph;

     typedef typename Graph::Node Node;

     typedef typename Graph::Edge Edge;

     typedef _ReaderTraits ReaderTraits;

     typedef typename ReaderTraits::Skipper DefaultSkipper;

     /// \brief Construct a new GraphReader.

     ///

     /// Construct a new GraphReader. It reads into the given graph

     /// and it uses the given reader as the default skipper.

     GraphReader(std::istream& _is, Graph& _graph, 

 		const DefaultSkipper& _skipper = DefaultSkipper()) 

       : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper),

 	nodeset_reader(*reader, _graph, std::string(), skipper),

 	edgeset_reader(*reader, _graph, nodeset_reader, 

 		       std::string(), skipper),

 	node_reader(*reader, nodeset_reader, std::string()),

 	edge_reader(*reader, edgeset_reader, std::string()),

 	attribute_reader(*reader, std::string()) {}

     /// \brief Construct a new GraphReader.

     ///

     /// Construct a new GraphReader. It reads into the given graph

     /// and it uses the given reader as the default skipper.

     GraphReader(const std::string& _filename, Graph& _graph, 

 		const DefaultSkipper& _skipper = DefaultSkipper()) 

       : reader(new LemonReader(_filename)), own_reader(true), 

 	skipper(_skipper),

 	nodeset_reader(*reader, _graph, std::string(), skipper),

 	edgeset_reader(*reader, _graph, nodeset_reader, 

 		       std::string(), skipper),

 	node_reader(*reader, nodeset_reader, std::string()),

 	edge_reader(*reader, edgeset_reader, std::string()),

 	attribute_reader(*reader, std::string()) {}

     /// \brief Construct a new GraphReader.

     ///

     /// Construct a new GraphReader. It reads into the given graph

     /// and it uses the given reader as the default skipper.

     GraphReader(LemonReader& _reader, Graph& _graph, 

 		const DefaultSkipper& _skipper = DefaultSkipper()) 

       : reader(_reader), own_reader(false), skipper(_skipper),

 	nodeset_reader(*reader, _graph, std::string(), skipper),

 	edgeset_reader(*reader, _graph, nodeset_reader, 

 		       std::string(), skipper),

 	node_reader(*reader, nodeset_reader, std::string()),

 	edge_reader(*reader, edgeset_reader, std::string()),

 	attribute_reader(*reader, std::string()) {}

     /// \brief Destruct the graph reader.

     ///

     /// Destruct the graph reader.

     ~GraphReader() {

       if (own_reader) 

 	delete reader;

     }

     /// \brief Give a new node map reading command to the reader.

     ///

     /// Give a new node map reading command to the reader.

     template <typename Map>

     GraphReader& readNodeMap(std::string name, Map& map) {

       nodeset_reader.readNodeMap(name, map);

       return *this;

     }

     template <typename Map>

     GraphReader& readNodeMap(std::string name, const Map& map) {

       nodeset_reader.readNodeMap(name, map);

       return *this;

     }

     /// \brief Give a new node map reading command to the reader.

     ///

     /// Give a new node map reading command to the reader.

     template <typename ItemReader, typename Map>

     GraphReader& readNodeMap(std::string name, Map& map, 

 			     const ItemReader& ir = ItemReader()) {

       nodeset_reader.readNodeMap(name, map, ir);

       return *this;

     }

     template <typename ItemReader, typename Map>

     GraphReader& readNodeMap(std::string name, const Map& map, 

 			     const ItemReader& ir = ItemReader()) {

       nodeset_reader.readNodeMap(name, map, ir);

       return *this;

     }

     /// \brief Give a new node map skipping command to the reader.

     ///

     /// Give a new node map skipping command to the reader.

     template <typename ItemReader>

     GraphReader& skipNodeMap(std::string name, 

 			     const ItemReader& ir = ItemReader()) {

       nodeset_reader.skipNodeMap(name, ir);

       return *this;

     }

     /// \brief Give a new edge map reading command to the reader.

     ///

     /// Give a new edge map reading command to the reader.

     template <typename Map>

     GraphReader& readEdgeMap(std::string name, Map& map) { 

       edgeset_reader.readEdgeMap(name, map);

       return *this;

     }

     template <typename Map>

     GraphReader& readEdgeMap(std::string name, const Map& map) { 

       edgeset_reader.readEdgeMap(name, map);

       return *this;

     }

     /// \brief Give a new edge map reading command to the reader.

     ///

     /// Give a new edge map reading command to the reader.

     template <typename ItemReader, typename Map>

     GraphReader& readEdgeMap(std::string name, Map& map,

 			     const ItemReader& ir = ItemReader()) {

       edgeset_reader.readEdgeMap(name, map, ir);

       return *this;

     }

     template <typename ItemReader, typename Map>

     GraphReader& readEdgeMap(std::string name, const Map& map,

 			     const ItemReader& ir = ItemReader()) {

       edgeset_reader.readEdgeMap(name, map, ir);

       return *this;

     }

     /// \brief Give a new edge map skipping command to the reader.

     ///

     /// Give a new edge map skipping command to the reader.

     template <typename ItemReader>

     GraphReader& skipEdgeMap(std::string name, 

 			     const ItemReader& ir = ItemReader()) {

       edgeset_reader.skipEdgeMap(name, ir);

       return *this;

     }

     /// \brief Give a new labeled node reading command to the reader.

     ///

     /// Give a new labeled node reading command to the reader.

     GraphReader& readNode(std::string name, Node& node) {

       node_reader.readNode(name, node);

       return *this;

     }

     /// \brief Give a new labeled edge reading command to the reader.

     ///

     /// Give a new labeled edge reading command to the reader.

     GraphReader& readEdge(std::string name, Edge& edge) {

       edge_reader.readEdge(name, edge);

       return *this;

     }

     /// \brief Give a new attribute reading command.

     ///

     ///  Give a new attribute reading command.

     template <typename Value>

     GraphReader& readAttribute(std::string name, Value& value) {

       attribute_reader.readAttribute(name, value);

       return *this;

     }

     /// \brief Give a new attribute reading command.

     ///

     ///  Give a new attribute reading command.

     template <typename ItemReader, typename Value>

     GraphReader& readAttribute(std::string name, Value& value, 

 			       const ItemReader& ir = ItemReader()) {

       attribute_reader.readAttribute(name, value, ir);

       return *this;

     }

     /// \brief Conversion operator to LemonReader.

     ///

     /// Conversion operator to LemonReader. It makes possible to access the

     /// encapsulated \e LemonReader, this way you can attach to this reader

     /// new instances of \e LemonReader::SectionReader. For more details see

     /// the \ref rwbackground "Background of Reading and Writing".

     operator LemonReader&() {

       return *reader;

     }

     /// \brief Executes the reading commands.

     ///

     /// Executes the reading commands.

     void run() {

       reader->run();

     }

     /// \brief Returns true if the reader can give back the items by its label.

     ///

     /// \brief Returns true if the reader can give back the items by its label.

     bool isLabelReader() const {

       return nodeset_reader.isLabelReader() && edgeset_reader.isLabelReader();

     }

     /// \brief Gives back the node by its label.

     ///

     /// It reads an label from the stream and gives back which node belongs to

     /// it. It is possible only if there was read a "label" named node map.

     void readLabel(std::istream& is, Node& node) const {

       nodeset_reader.readLabel(is, node);

     } 

     /// \brief Gives back the edge by its label.

     ///

     /// It reads an label from the stream and gives back which edge belongs to

     /// it. It is possible only if there was read a "label" named edge map.

     void readLabel(std::istream& is, Edge& edge) const {

       edgeset_reader.readLabel(is, edge);

     } 

   private:

     LemonReader* reader;

     bool own_reader;

     DefaultSkipper skipper;

     NodeSetReader<Graph, ReaderTraits> nodeset_reader;

     EdgeSetReader<Graph, ReaderTraits> edgeset_reader;

     NodeReader<Graph> node_reader;

     EdgeReader<Graph> edge_reader;

     AttributeReader<ReaderTraits> attribute_reader;

   };

   /// \brief The undirected graph reader class.

   ///

   /// The \c UGraphReader class provides the graph input. 

   /// Before you read this documentation it might be useful to read the general

   /// description of  \ref graph-io-page "Graph Input-Output".

   ///

   /// The given file format may contain several maps and labeled nodes or 

   /// edges.

   ///

   /// If you read a graph you need not read all the maps and items just those

   /// that you need. The interface of the \c UGraphReader is very similar

   /// to the UGraphWriter but the reading method does not depend on the

   /// order of the given commands.

   ///

   /// The reader object suppose that each not read value does not contain 

   /// whitespaces, therefore it has some extra possibilities to control how

   /// it should skip the values when the string representation contains spaces.

   ///

   ///\code

   /// UGraphReader<ListUGraph> reader(std::cin, graph);

   ///\endcode

   ///

   /// The \c readNodeMap() function reads a map from the \c \@nodeset section.

   /// If there is a map that you do not want to read from the file and there is

   /// whitespace in the string represenation of the values then you should

   /// call the \c skipNodeMap() template member function with proper 

   /// parameters.

   ///

   ///\code

   /// reader.readNodeMap("coords", coords);

   ///

   /// reader.skipNodeMap("description", desc);

   ///

   /// reader.readNodeMap("color", colorMap);

   ///\endcode

   ///

   /// With the \c readUEdgeMap() member function you can give an 

   /// uedge map reading command similar to the NodeMaps. 

   ///

   ///\code

   /// reader.readUEdgeMap("capacity", capacityMap);

   ///\endcode

   ///

   /// The reading of the directed edge maps is just a syntactical sugar.

   /// It reads two undirected edgemaps into a directed edge map. The 

   /// undirected edge maps' name should be start with the \c '+' and the

   /// \c '-' character and the same.

   ///

   ///\code

   /// reader.readEdgeMap("flow", flowMap);

   ///\endcode 

   ///

   /// With \c readNode() and \c readUEdge() functions you can read 

   /// labeled Nodes and UEdges.

   ///

   ///\code

   /// reader.readNode("source", sourceNode);

   /// reader.readNode("target", targetNode);

   ///

   /// reader.readUEdge("observed", uEdge);

   ///\endcode

   ///

   /// With the \c readAttribute() functions you can read an attribute

   /// in a variable. You can specify the reader for the attribute as

   /// the nodemaps.

   ///

   /// After you give all read commands you must call the \c run() member

   /// function, which execute all the commands.

   ///

   ///\code

   /// reader.run();

   ///\endcode

   ///

   /// \see GraphReader

   /// \see DefaultReaderTraits

   /// \see \ref UGraphWriter

   /// \see \ref graph-io-page

   ///

   /// \author Balazs Dezso

   template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 

   class UGraphReader {

   public:

     typedef _Graph Graph;

     typedef typename Graph::Node Node;

     typedef typename Graph::Edge Edge;

     typedef typename Graph::UEdge UEdge;

     typedef _ReaderTraits ReaderTraits;

     typedef typename ReaderTraits::Skipper DefaultSkipper;

     /// \brief Construct a new UGraphReader.

     ///

     /// Construct a new UGraphReader. It reads into the given graph

     /// and it use the given reader as the default skipper.

     UGraphReader(std::istream& _is, Graph& _graph, 

 		     const DefaultSkipper& _skipper = DefaultSkipper()) 

       : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper),

 	nodeset_reader(*reader, _graph, std::string(), skipper),

 	uedgeset_reader(*reader, _graph, nodeset_reader, 

 			     std::string(), skipper),

 	node_reader(*reader, nodeset_reader, std::string()),

 	uedge_reader(*reader, uedgeset_reader, std::string()),

 	attribute_reader(*reader, std::string()) {}

     /// \brief Construct a new UGraphReader.

     ///

     /// Construct a new UGraphReader. It reads into the given graph

     /// and it use the given reader as the default skipper.

     UGraphReader(const std::string& _filename, Graph& _graph, 

 		     const DefaultSkipper& _skipper = DefaultSkipper()) 

       : reader(new LemonReader(_filename)), own_reader(true), 

 	skipper(_skipper),

 	nodeset_reader(*reader, _graph, std::string(), skipper),

 	uedgeset_reader(*reader, _graph, nodeset_reader, 

 			     std::string(), skipper),

 	node_reader(*reader, nodeset_reader, std::string()),

 	uedge_reader(*reader, uedgeset_reader, std::string()),

 	attribute_reader(*reader, std::string()) {}

     /// \brief Construct a new UGraphReader.

     ///

     /// Construct a new UGraphReader. It reads into the given graph

     /// and it use the given reader as the default skipper.

     UGraphReader(LemonReader& _reader, Graph& _graph, 

 		     const DefaultSkipper& _skipper = DefaultSkipper()) 

       : reader(_reader), own_reader(false), skipper(_skipper),

 	nodeset_reader(*reader, _graph, std::string(), skipper),

 	uedgeset_reader(*reader, _graph, nodeset_reader, 

 			     std::string(), skipper),

 	node_reader(*reader, nodeset_reader, std::string()),

 	uedge_reader(*reader, uedgeset_reader, std::string()),

 	attribute_reader(*reader, std::string()) {}

     /// \brief Destruct the graph reader.

     ///

     /// Destruct the graph reader.

     ~UGraphReader() {

       if (own_reader) 

 	delete reader;

     }

     /// \brief Give a new node map reading command to the reader.

     ///

     /// Give a new node map reading command to the reader.

     template <typename Map>

     UGraphReader& readNodeMap(std::string name, Map& map) {

       nodeset_reader.readNodeMap(name, map);

       return *this;

     }

     template <typename Map>

     UGraphReader& readNodeMap(std::string name, const Map& map) {

       nodeset_reader.readNodeMap(name, map);

       return *this;

     }

     /// \brief Give a new node map reading command to the reader.

     ///

     /// Give a new node map reading command to the reader.

     template <typename ItemReader, typename Map>

     UGraphReader& readNodeMap(std::string name, Map& map, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.readNodeMap(name, map, ir);

       return *this;

     }

     template <typename ItemReader, typename Map>

     UGraphReader& readNodeMap(std::string name, const Map& map, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.readNodeMap(name, map, ir);

       return *this;

     }

     /// \brief Give a new node map skipping command to the reader.

     ///

     /// Give a new node map skipping command to the reader.

     template <typename ItemReader>

     UGraphReader& skipNodeMap(std::string name, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.skipNodeMap(name, ir);

       return *this;

     }

     /// \brief Give a new undirected edge map reading command to the reader.

     ///

     /// Give a new undirected edge map reading command to the reader.

     template <typename Map>

     UGraphReader& readUEdgeMap(std::string name, Map& map) { 

       uedgeset_reader.readUEdgeMap(name, map);

       return *this;

     }

     template <typename Map>

     UGraphReader& readUEdgeMap(std::string name, const Map& map) { 

       uedgeset_reader.readUEdgeMap(name, map);

       return *this;

     }

     /// \brief Give a new undirected edge map reading command to the reader.

     ///

     /// Give a new undirected edge map reading command to the reader.

     template <typename ItemReader, typename Map>

     UGraphReader& readUEdgeMap(std::string name, Map& map,

                                const ItemReader& ir = ItemReader()) {

       uedgeset_reader.readUEdgeMap(name, map, ir);

       return *this;

     }

     template <typename ItemReader, typename Map>

     UGraphReader& readUEdgeMap(std::string name, const Map& map,

                                const ItemReader& ir = ItemReader()) {

       uedgeset_reader.readUEdgeMap(name, map, ir);

       return *this;

     }

     /// \brief Give a new undirected edge map skipping command to the reader.

     ///

     /// Give a new undirected edge map skipping command to the reader.

     template <typename ItemReader>

     UGraphReader& skipUEdgeMap(std::string name,

 				       const ItemReader& ir = ItemReader()) {

       uedgeset_reader.skipUMap(name, ir);

       return *this;

     }

     /// \brief Give a new edge map reading command to the reader.

     ///

     /// Give a new edge map reading command to the reader.

     template <typename Map>

     UGraphReader& readEdgeMap(std::string name, Map& map) { 

       uedgeset_reader.readEdgeMap(name, map);

       return *this;

     }

     template <typename Map>

     UGraphReader& readEdgeMap(std::string name, const Map& map) { 

       uedgeset_reader.readEdgeMap(name, map);

       return *this;

     }

     /// \brief Give a new edge map reading command to the reader.

     ///

     /// Give a new edge map reading command to the reader.

     template <typename ItemReader, typename Map>

     UGraphReader& readEdgeMap(std::string name, Map& map,

                               const ItemReader& ir = ItemReader()) {

       uedgeset_reader.readEdgeMap(name, map, ir);

       return *this;

     }

     template <typename ItemReader, typename Map>

     UGraphReader& readEdgeMap(std::string name, const Map& map,

                               const ItemReader& ir = ItemReader()) {

       uedgeset_reader.readEdgeMap(name, map, ir);

       return *this;

     }

     /// \brief Give a new edge map skipping command to the reader.

     ///

     /// Give a new edge map skipping command to the reader.

     template <typename ItemReader>

     UGraphReader& skipEdgeMap(std::string name,

                               const ItemReader& ir = ItemReader()) {

       uedgeset_reader.skipEdgeMap(name, ir);

       return *this;

     }

     /// \brief Give a new labeled node reading command to the reader.

     ///

     /// Give a new labeled node reading command to the reader.

     UGraphReader& readNode(std::string name, Node& node) {

       node_reader.readNode(name, node);

       return *this;

     }

     /// \brief Give a new labeled edge reading command to the reader.

     ///

     /// Give a new labeled edge reading command to the reader.

     UGraphReader& readEdge(std::string name, Edge& edge) {

       uedge_reader.readEdge(name, edge);

     }

     /// \brief Give a new labeled undirected edge reading command to the

     /// reader.

     ///

     /// Give a new labeled undirected edge reading command to the reader.

     UGraphReader& readUEdge(std::string name, UEdge& edge) {

       uedge_reader.readUEdge(name, edge);

     }

     /// \brief Give a new attribute reading command.

     ///

     ///  Give a new attribute reading command.

     template <typename Value>

     UGraphReader& readAttribute(std::string name, Value& value) {

       attribute_reader.readAttribute(name, value);

       return *this;

     }

     /// \brief Give a new attribute reading command.

     ///

     ///  Give a new attribute reading command.

     template <typename ItemReader, typename Value>

     UGraphReader& readAttribute(std::string name, Value& value, 

 			       const ItemReader& ir = ItemReader()) {

       attribute_reader.readAttribute(name, value, ir);

       return *this;

     }

     /// \brief Conversion operator to LemonReader.

     ///

     /// Conversion operator to LemonReader. It make possible

     /// to access the encapsulated \e LemonReader, this way

     /// you can attach to this reader new instances of 

     /// \e LemonReader::SectionReader.

     operator LemonReader&() {

       return *reader;

     }

     /// \brief Executes the reading commands.

     ///

     /// Executes the reading commands.

     void run() {

       reader->run();

     }

     /// \brief Returns true if the reader can give back the items by its label.

     ///

     /// Returns true if the reader can give back the items by its label.

     bool isLabelReader() const {

       return nodeset_reader.isLabelReader() && 

         uedgeset_reader.isLabelReader();

     }

     /// \brief Gives back the node by its label.

     ///

     /// It reads an label from the stream and gives back which node belongs to

     /// it. It is possible only if there was read a "label" named node map.

     void readLabel(std::istream& is, Node& node) const {

       return nodeset_reader.readLabel(is, node);

     } 

     /// \brief Gives back the edge by its label

     ///

     /// It reads an label from the stream and gives back which edge belongs to

     /// it. It is possible only if there was read a "label" named edge map.

     void readLabel(std::istream& is, Edge& edge) const {

       return uedgeset_reader.readLabel(is, edge);

     } 

     /// \brief Gives back the undirected edge by its label.

     ///

     /// It reads an label from the stream and gives back which undirected edge 

     /// belongs to it. It is possible only if there was read a "label" named 

     /// edge map.

     void readLabel(std::istream& is, UEdge& uedge) const {

       return uedgeset_reader.readLabel(is, uedge);

     } 

   private:

     LemonReader* reader;

     bool own_reader;

     DefaultSkipper skipper;

     NodeSetReader<Graph, ReaderTraits> nodeset_reader;

     UEdgeSetReader<Graph, ReaderTraits> uedgeset_reader;

     NodeReader<Graph> node_reader;

     UEdgeReader<Graph> uedge_reader;

     AttributeReader<ReaderTraits> attribute_reader;

   };

   /// \brief The bipartite graph reader class.

   ///

   /// The \c BpUGraphReader class provides the graph input. 

   /// Before you read this documentation it might be useful to read the general

   /// description of  \ref graph-io-page "Graph Input-Output".

   ///

   /// The given file format may contain several maps and labeled nodes or 

   /// edges.

   ///

   /// If you read a graph you need not read all the maps and items just those

   /// that you need. The interface of the \c BpUGraphReader is very similar

   /// to the BpUGraphWriter but the reading method does not depend on the

   /// order of the given commands.

   ///

   /// The reader object suppose that each not read value does not contain 

   /// whitespaces, therefore it has some extra possibilities to control how

   /// it should skip the values when the string representation contains spaces.

   ///

   ///\code

   /// BpUGraphReader<ListBpUGraph> reader(std::cin, graph);

   ///\endcode

   ///

   /// The \c readANodeMap() function reads a map from the A-part of

   /// the\c \@bpnodeset section, while the \c readBNodeMap() reads

   /// from the B-part of the section.  If you use the \c readNodeMap()

   /// function, then the given map should appear in both part of the

   /// section. If there is a map that you do not want to read from the

   /// file and there is whitespace in the string represenation of the

   /// values then you should call the \c skipANodeMap(), \c

   /// skipBNodeMap() or \c skipNodeMap() template member function with

   /// proper parameters.

   ///

   ///\code

   /// reader.readNodeMap("coords", coords);

   /// reader.readANodeMap("range", range);

   /// reader.readANodeMap("benefit", benefit);

   ///

   /// reader.skipNodeMap("description", desc);

   ///

   /// reader.readNodeMap("color", colorMap);

   ///\endcode

   ///

   /// With the \c readUEdgeMap() member function you can give an 

   /// uedge map reading command similar to the NodeMaps. 

   ///

   ///\code

   /// reader.readUEdgeMap("capacity", capacityMap);

   /// reader.readEdgeMap("flow", flowMap);

   ///\endcode 

   ///

   /// With \c readNode() and \c readUEdge() functions you can read 

   /// labeled Nodes and UEdges.

   ///

   ///\code

   /// reader.readNode("source", sourceNode);

   /// reader.readNode("target", targetNode);

   ///

   /// reader.readUEdge("observed", uEdge);

   ///\endcode

   ///

   /// With the \c readAttribute() functions you can read an attribute

   /// in a variable. You can specify the reader for the attribute as

   /// the nodemaps.

   ///

   /// After you give all read commands you must call the \c run() member

   /// function, which execute all the commands.

   ///

   ///\code

   /// reader.run();

   ///\endcode

   ///

   /// \see GraphReader

   /// \see DefaultReaderTraits

   /// \see \ref UGraphWriter

   /// \see \ref graph-io-page

   ///

   /// \author Balazs Dezso

   template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 

   class BpUGraphReader {

   public:

     typedef _Graph Graph;

     typedef typename Graph::Node Node;

     typedef typename Graph::Edge Edge;

     typedef typename Graph::UEdge UEdge;

     typedef _ReaderTraits ReaderTraits;

     typedef typename ReaderTraits::Skipper DefaultSkipper;

     /// \brief Construct a new BpUGraphReader.

     ///

     /// Construct a new BpUGraphReader. It reads into the given graph

     /// and it use the given reader as the default skipper.

     BpUGraphReader(std::istream& _is, Graph& _graph, 

 		     const DefaultSkipper& _skipper = DefaultSkipper()) 

       : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper),

 	nodeset_reader(*reader, _graph, std::string(), skipper),

 	uedgeset_reader(*reader, _graph, nodeset_reader, 

 			     std::string(), skipper),

 	node_reader(*reader, nodeset_reader, std::string()),

 	uedge_reader(*reader, uedgeset_reader, std::string()),

 	attribute_reader(*reader, std::string()) {}

     /// \brief Construct a new BpUGraphReader.

     ///

     /// Construct a new BpUGraphReader. It reads into the given graph

     /// and it use the given reader as the default skipper.

     BpUGraphReader(const std::string& _filename, Graph& _graph, 

 		     const DefaultSkipper& _skipper = DefaultSkipper()) 

       : reader(new LemonReader(_filename)), own_reader(true), 

 	skipper(_skipper),

 	nodeset_reader(*reader, _graph, std::string(), skipper),

 	uedgeset_reader(*reader, _graph, nodeset_reader, 

 			     std::string(), skipper),

 	node_reader(*reader, nodeset_reader, std::string()),

 	uedge_reader(*reader, uedgeset_reader, std::string()),

 	attribute_reader(*reader, std::string()) {}

     /// \brief Construct a new BpUGraphReader.

     ///

     /// Construct a new BpUGraphReader. It reads into the given graph

     /// and it use the given reader as the default skipper.

     BpUGraphReader(LemonReader& _reader, Graph& _graph, 

 		     const DefaultSkipper& _skipper = DefaultSkipper()) 

       : reader(_reader), own_reader(false), skipper(_skipper),

 	nodeset_reader(*reader, _graph, std::string(), skipper),

 	uedgeset_reader(*reader, _graph, nodeset_reader, 

 			     std::string(), skipper),

 	node_reader(*reader, nodeset_reader, std::string()),

 	uedge_reader(*reader, uedgeset_reader, std::string()),

 	attribute_reader(*reader, std::string()) {}

     /// \brief Destruct the graph reader.

     ///

     /// Destruct the graph reader.

     ~BpUGraphReader() {

       if (own_reader) 

 	delete reader;

     }

     /// \brief Give a new node map reading command to the reader.

     ///

     /// Give a new node map reading command to the reader.

     template <typename Map>

     BpUGraphReader& readNodeMap(std::string name, Map& map) {

       nodeset_reader.readNodeMap(name, map);

       return *this;

     }

     template <typename Map>

     BpUGraphReader& readNodeMap(std::string name, const Map& map) {

       nodeset_reader.readNodeMap(name, map);

       return *this;

     }

     /// \brief Give a new node map reading command to the reader.

     ///

     /// Give a new node map reading command to the reader.

     template <typename ItemReader, typename Map>

     BpUGraphReader& readNodeMap(std::string name, Map& map, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.readNodeMap(name, map, ir);

       return *this;

     }

     template <typename ItemReader, typename Map>

     BpUGraphReader& readNodeMap(std::string name, const Map& map, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.readNodeMap(name, map, ir);

       return *this;

     }

     /// \brief Give a new node map skipping command to the reader.

     ///

     /// Give a new node map skipping command to the reader.

     template <typename ItemReader>

     BpUGraphReader& skipNodeMap(std::string name, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.skipNodeMap(name, ir);

       return *this;

     }

     /// \brief Give a new A-node map reading command to the reader.

     ///

     /// Give a new A-node map reading command to the reader.

     template <typename Map>

     BpUGraphReader& readANodeMap(std::string name, Map& map) {

       nodeset_reader.readANodeMap(name, map);

       return *this;

     }

     template <typename Map>

     BpUGraphReader& readANodeMap(std::string name, const Map& map) {

       nodeset_reader.readANodeMap(name, map);

       return *this;

     }

     /// \brief Give a new A-node map reading command to the reader.

     ///

     /// Give a new A-node map reading command to the reader.

     template <typename ItemReader, typename Map>

     BpUGraphReader& readANodeMap(std::string name, Map& map, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.readANodeMap(name, map, ir);

       return *this;

     }

     template <typename ItemReader, typename Map>

     BpUGraphReader& readANodeMap(std::string name, const Map& map, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.readNodeMap(name, map, ir);

       return *this;

     }

     /// \brief Give a new A-node map skipping command to the reader.

     ///

     /// Give a new A-node map skipping command to the reader.

     template <typename ItemReader>

     BpUGraphReader& skipANodeMap(std::string name, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.skipANodeMap(name, ir);

       return *this;

     }

     /// \brief Give a new B-node map reading command to the reader.

     ///

     /// Give a new B-node map reading command to the reader.

     template <typename Map>

     BpUGraphReader& readBNodeMap(std::string name, Map& map) {

       nodeset_reader.readBNodeMap(name, map);

       return *this;

     }

     template <typename Map>

     BpUGraphReader& readBNodeMap(std::string name, const Map& map) {

       nodeset_reader.readBNodeMap(name, map);

       return *this;

     }

     /// \brief Give a new B-node map reading command to the reader.

     ///

     /// Give a new B-node map reading command to the reader.

     template <typename ItemReader, typename Map>

     BpUGraphReader& readBNodeMap(std::string name, Map& map, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.readBNodeMap(name, map, ir);

       return *this;

     }

     template <typename ItemReader, typename Map>

     BpUGraphReader& readBNodeMap(std::string name, const Map& map, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.readNodeMap(name, map, ir);

       return *this;

     }

     /// \brief Give a new B-node map skipping command to the reader.

     ///

     /// Give a new B-node map skipping command to the reader.

     template <typename ItemReader>

     BpUGraphReader& skipBNodeMap(std::string name, 

                               const ItemReader& ir = ItemReader()) {

       nodeset_reader.skipBNodeMap(name, ir);

       return *this;

     }

     /// \brief Give a new undirected edge map reading command to the reader.

     ///

     /// Give a new undirected edge map reading command to the reader.

     template <typename Map>

     BpUGraphReader& readUEdgeMap(std::string name, Map& map) { 

       uedgeset_reader.readUEdgeMap(name, map);

       return *this;

     }

     template <typename Map>

     BpUGraphReader& readUEdgeMap(std::string name, const Map& map) { 

       uedgeset_reader.readUEdgeMap(name, map);

       return *this;

     }

     /// \brief Give a new undirected edge map reading command to the reader.

     ///

     /// Give a new undirected edge map reading command to the reader.

     template <typename ItemReader, typename Map>

     BpUGraphReader& readUEdgeMap(std::string name, Map& map,

                                const ItemReader& ir = ItemReader()) {

       uedgeset_reader.readUEdgeMap(name, map, ir);

       return *this;

     }

     template <typename ItemReader, typename Map>

     BpUGraphReader& readUEdgeMap(std::string name, const Map& map,

                                const ItemReader& ir = ItemReader()) {

       uedgeset_reader.readUEdgeMap(name, map, ir);

       return *this;

     }

     /// \brief Give a new undirected edge map skipping command to the reader.

     ///

     /// Give a new undirected edge map skipping command to the reader.

     template <typename ItemReader>

     BpUGraphReader& skipUEdgeMap(std::string name,

 				       const ItemReader& ir = ItemReader()) {

       uedgeset_reader.skipUMap(name, ir);

       return *this;

     }

     /// \brief Give a new edge map reading command to the reader.

     ///

     /// Give a new edge map reading command to the reader.

     template <typename Map>

     BpUGraphReader& readEdgeMap(std::string name, Map& map) { 

       uedgeset_reader.readEdgeMap(name, map);

       return *this;

     }

     template <typename Map>

     BpUGraphReader& readEdgeMap(std::string name, const Map& map) { 

       uedgeset_reader.readEdgeMap(name, map);

       return *this;

     }

     /// \brief Give a new edge map reading command to the reader.

     ///

     /// Give a new edge map reading command to the reader.

     template <typename ItemReader, typename Map>

     BpUGraphReader& readEdgeMap(std::string name, Map& map,

                               const ItemReader& ir = ItemReader()) {

       uedgeset_reader.readEdgeMap(name, map, ir);

       return *this;

     }

     template <typename ItemReader, typename Map>

     BpUGraphReader& readEdgeMap(std::string name, const Map& map,

                               const ItemReader& ir = ItemReader()) {

       uedgeset_reader.readEdgeMap(name, map, ir);

       return *this;

     }

     /// \brief Give a new edge map skipping command to the reader.

     ///

     /// Give a new edge map skipping command to the reader.

     template <typename ItemReader>

     BpUGraphReader& skipEdgeMap(std::string name,

                               const ItemReader& ir = ItemReader()) {

       uedgeset_reader.skipEdgeMap(name, ir);

       return *this;

     }

     /// \brief Give a new labeled node reading command to the reader.

     ///

     /// Give a new labeled node reading command to the reader.

     BpUGraphReader& readNode(std::string name, Node& node) {

       node_reader.readNode(name, node);

       return *this;

     }

     /// \brief Give a new labeled edge reading command to the reader.

     ///

     /// Give a new labeled edge reading command to the reader.

     BpUGraphReader& readEdge(std::string name, Edge& edge) {

       uedge_reader.readEdge(name, edge);

     }

     /// \brief Give a new labeled undirected edge reading command to the

     /// reader.

     ///

     /// Give a new labeled undirected edge reading command to the reader.

     BpUGraphReader& readUEdge(std::string name, UEdge& edge) {

       uedge_reader.readUEdge(name, edge);

     }

     /// \brief Give a new attribute reading command.

     ///

     ///  Give a new attribute reading command.

     template <typename Value>

     BpUGraphReader& readAttribute(std::string name, Value& value) {

       attribute_reader.readAttribute(name, value);

       return *this;

     }

     /// \brief Give a new attribute reading command.

     ///

     ///  Give a new attribute reading command.

     template <typename ItemReader, typename Value>

     BpUGraphReader& readAttribute(std::string name, Value& value, 

 			       const ItemReader& ir = ItemReader()) {

       attribute_reader.readAttribute(name, value, ir);

       return *this;

     }

     /// \brief Conversion operator to LemonReader.

     ///

     /// Conversion operator to LemonReader. It make possible

     /// to access the encapsulated \e LemonReader, this way

     /// you can attach to this reader new instances of 

     /// \e LemonReader::SectionReader.

     operator LemonReader&() {

       return *reader;

     }

     /// \brief Executes the reading commands.

     ///

     /// Executes the reading commands.

     void run() {

       reader->run();

     }

     /// \brief Returns true if the reader can give back the items by its label.

     ///

     /// Returns true if the reader can give back the items by its label.

     bool isLabelReader() const {

       return nodeset_reader.isLabelReader() && 

         uedgeset_reader.isLabelReader();

     }

     /// \brief Gives back the node by its label.

     ///

     /// It reads an label from the stream and gives back which node belongs to

     /// it. It is possible only if there was read a "label" named node map.

     void readLabel(std::istream& is, Node& node) const {

       return nodeset_reader.readLabel(is, node);

     } 

     /// \brief Gives back the edge by its label

     ///

     /// It reads an label from the stream and gives back which edge belongs to

     /// it. It is possible only if there was read a "label" named edge map.

     void readLabel(std::istream& is, Edge& edge) const {

       return uedgeset_reader.readLabel(is, edge);

     } 

     /// \brief Gives back the undirected edge by its label.

     ///

     /// It reads an label from the stream and gives back which undirected edge 

     /// belongs to it. It is possible only if there was read a "label" named 

     /// edge map.

     void readLabel(std::istream& is, UEdge& uedge) const {

       return uedgeset_reader.readLabel(is, uedge);

     } 

   private:

     LemonReader* reader;

     bool own_reader;

     DefaultSkipper skipper;

     BpNodeSetReader<Graph, ReaderTraits> nodeset_reader;

     UEdgeSetReader<Graph, ReaderTraits> uedgeset_reader;

     NodeReader<Graph> node_reader;

     UEdgeReader<Graph> uedge_reader;

     AttributeReader<ReaderTraits> attribute_reader;

   };

   /// @}

 }

 #endif