/// \brief The undir graph reader class.

   ///

   /// 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 GraphReader is very similar to

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

   /// given commands.

   ///

   /// The reader object suppose that each not readed 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

   /// UndirGraphReader<UndirListGraph> 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.readNodeMap<QuotedStringReader>("label", labelMap);

   /// reader.skipNodeMap<QuotedStringReader>("description");

   ///

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

   /// \endcode

   ///

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

   /// undir edge map reading command similar to the NodeMaps. 

   ///

   /// \code

   /// reader.readUndirEdgeMap("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 readUndirEdge() functions you can read 

   /// labeled Nodes and UndirEdges.

   ///

   /// \code

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

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

   ///

   /// reader.readUndirEdge("observed", undirEdge);

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

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

   ///

   /// \author Balazs Dezso

   template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 

   class UndirGraphReader {

   public:

     typedef _Graph Graph;

     typedef typename Graph::Node Node;

     typedef typename Graph::Edge Edge;

     typedef typename Graph::UndirEdge UndirEdge;

     typedef _ReaderTraits ReaderTraits;

     typedef typename ReaderTraits::Skipper DefaultSkipper;

     /// \brief Construct a new UndirGraphReader.

     ///

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

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

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

 	undir_edgeset_reader(*reader, _graph, nodeset_reader, 

 			     std::string(), skipper),

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

 	undir_edge_reader(*reader, undir_edgeset_reader, std::string()),

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

     /// \brief Construct a new UndirGraphReader.

     ///

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

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

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

 	undir_edgeset_reader(*reader, _graph, nodeset_reader, 

 			     std::string(), skipper),

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

 	undir_edge_reader(*reader, undir_edgeset_reader, std::string()),

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

     /// \brief Construct a new UndirGraphReader.

     ///

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

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

     UndirGraphReader(LemonReader& _reader, Graph& _graph, 

 		     const DefaultSkipper& _skipper = DefaultSkipper()) 

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

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

 	undir_edgeset_reader(*reader, _graph, nodeset_reader, 

 			     std::string(), skipper),

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

 	undir_edge_reader(*reader, undir_edgeset_reader, std::string()),

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

     /// \brief Destruct the graph reader.

     ///

     /// Destruct the graph reader.

     ~UndirGraphReader() {

       if (own_reader) 

 	delete reader;

     }

     /// \brief Add a new node map reader command for the reader.

     ///

     /// Add a new node map reader command for the reader.

     template <typename Map>

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

       nodeset_reader.readNodeMap(name, map);

       return *this;

     }

     template <typename Map>

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

       nodeset_reader.readNodeMap(name, map);

       return *this;

     }

     /// \brief Add a new node map reader command for the reader.

     ///

     /// Add a new node map reader command for the reader.

     template <typename Reader, typename Map>

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

 				  const Reader& reader = Reader()) {

       nodeset_reader.readNodeMap(name, map, reader);

       return *this;

     }

     template <typename Reader, typename Map>

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

 				  const Reader& reader = Reader()) {

       nodeset_reader.readNodeMap(name, map, reader);

       return *this;

     }

     /// \brief Add a new node map skipper command for the reader.

     ///

     /// Add a new node map skipper command for the reader.

     template <typename Reader>

     UndirGraphReader& skipNodeMap(std::string name, 

 			     const Reader& reader = Reader()) {

       nodeset_reader.skipNodeMap(name, reader);

       return *this;

     }

     /// \brief Add a new undirected edge map reader command for the reader.

     ///

     /// Add a new undirected edge map reader command for the reader.

     template <typename Map>

     UndirGraphReader& readUndirEdgeMap(std::string name, Map& map) { 

       undir_edgeset_reader.readUndirEdgeMap(name, map);

       return *this;

     }

     template <typename Map>

     UndirGraphReader& readUndirEdgeMap(std::string name, const Map& map) { 

       undir_edgeset_reader.readUndirEdgeMap(name, map);

       return *this;

     }

     /// \brief Add a new undirected edge map reader command for the reader.

     ///

     /// Add a new undirected edge map reader command for the reader.

     template <typename Reader, typename Map>

     UndirGraphReader& readUndirEdgeMap(std::string name, Map& map,

 				       const Reader& reader = Reader()) {

       undir_edgeset_reader.readUndirEdgeMap(name, map, reader);

       return *this;

     }

     template <typename Reader, typename Map>

     UndirGraphReader& readUndirEdgeMap(std::string name, const Map& map,

 				       const Reader& reader = Reader()) {

       undir_edgeset_reader.readUndirEdgeMap(name, map, reader);

       return *this;

     }

     /// \brief Add a new undirected edge map skipper command for the reader.

     ///

     /// Add a new undirected edge map skipper command for the reader.

     template <typename Reader>

     UndirGraphReader& skipUndirEdgeMap(std::string name,

 				       const Reader& reader = Reader()) {

       undir_edgeset_reader.skipUndirMap(name, reader);

       return *this;

     }

     /// \brief Add a new edge map reader command for the reader.

     ///

     /// Add a new edge map reader command for the reader.

     template <typename Map>

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

       undir_edgeset_reader.readEdgeMap(name, map);

       return *this;

     }

     template <typename Map>

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

       undir_edgeset_reader.readEdgeMap(name, map);

       return *this;

     }

     /// \brief Add a new edge map reader command for the reader.

     ///

     /// Add a new edge map reader command for the reader.

     template <typename Reader, typename Map>

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

 				       const Reader& reader = Reader()) {

       undir_edgeset_reader.readEdgeMap(name, map, reader);

       return *this;

     }

     template <typename Reader, typename Map>

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

 				       const Reader& reader = Reader()) {

       undir_edgeset_reader.readEdgeMap(name, map, reader);

       return *this;

     }

     /// \brief Add a new edge map skipper command for the reader.

     ///

     /// Add a new edge map skipper command for the reader.

     template <typename Reader>

     UndirGraphReader& skipEdgeMap(std::string name,

 				       const Reader& reader = Reader()) {

       undir_edgeset_reader.skipEdgeMap(name, reader);

       return *this;

     }

     /// \brief Add a new labeled node reader for the reader.

     ///

     /// Add a new labeled node reader for the reader.

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

       node_reader.readNode(name, node);

       return *this;

     }

     /// \brief Add a new labeled edge reader for the reader.

     ///

     /// Add a new labeled edge reader for the reader.

     UndirGraphReader& readUndirEdge(std::string name, UndirEdge& edge) {

       undir_edge_reader.readUndirEdge(name, edge);

     }

     /// \brief Add a new attribute reader command.

     ///

     ///  Add a new attribute reader command.

     template <typename Value>

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

       attribute_reader.readAttribute(name, value);

       return *this;

     }

     /// \brief Add a new attribute reader command.

     ///

     ///  Add a new attribute reader command.

     template <typename Reader, typename Value>

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

 			       const Reader& reader) {

       attribute_reader.readAttribute<Reader>(name, value, reader);

       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 reader commands.

     ///

     /// Executes the reader commands.

     void run() {

       reader->run();

     }

   private:

     LemonReader* reader;

     bool own_reader;

     DefaultSkipper skipper;

     NodeSetReader<Graph, ReaderTraits> nodeset_reader;

     UndirEdgeSetReader<Graph, ReaderTraits> undir_edgeset_reader;

     NodeReader<Graph> node_reader;

     UndirEdgeReader<Graph> undir_edge_reader;

     AttributeReader<ReaderTraits> attribute_reader;

   };

   /// \brief Read an undir graph from the input.

   ///

   /// Read an undir graph from the input.

   /// \param is The input stream.

   /// \param g The graph.

   /// \param capacity The capacity map.

   template<typename Graph, typename CapacityMap>

   void readUndirGraph(std::istream& is, Graph &g, CapacityMap& capacity) {

     UndirGraphReader<Graph> reader(is, g);

     reader.readUndirEdgeMap("capacity", capacity);

     reader.run();

   }

   /// \brief Read an undir graph from the input.

   ///

   /// Read an undir graph from the input.

   /// \param is The input stream.

   /// \param g The graph.

   template<typename Graph>

   void readUndirGraph(std::istream& is, Graph &g) {

     UndirGraphReader<Graph> reader(is, g);

     reader.run();

   }