virtual LabelReaderBase<_Item>* clone() const = 0;

   };

   /// \ingroup section_io

   /// \brief SectionReader for reading extra node maps.

   ///

   /// The lemon format can store maps in the nodeset sections. This

   /// class let you make distinict section to store maps.  The main

   /// purpose of this class is a logical separation of some maps. The

   /// other useful application could be to store paths in node maps.

   ///

   /// The first line of the section contains the names of the maps

   /// separated with white spaces. Each next line describes an item

   /// in the itemset, and contains in the first column the label of

   /// the item and then the mapped values for each map.

   ///

   /// \relates LemonReader

   template <typename _Graph, typename _Traits = DefaultReaderTraits>

   class NodeMapReader : public LemonReader::SectionReader {

     typedef LemonReader::SectionReader Parent;

   public:

     typedef _Graph Graph;

     typedef typename Graph::Node Node;

     typedef _Traits Traits;

     typedef typename Traits::Skipper DefaultSkipper;

     /// \brief Constructor.

     ///

     /// Constructor for NodeMapReader. It creates the NodeMapReader and

     /// attach it into the given LemonReader. The reader will read

     /// the section when the \c section_name and the \c _name are the same.

     template <typename _LabelReader>

     NodeMapReader(LemonReader& _reader, 

 		  const Graph& _graph, 

 		  const _LabelReader& _labelReader,

 		  const std::string& _name = std::string(),

 		  const DefaultSkipper& _skipper = DefaultSkipper()) 

       : Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {

       labelReader.reset(new _reader_bits::

 			LabelReader<Node, _LabelReader>(_labelReader));

     } 

     /// \brief Destructor.

     ///

     /// Destructor for NodeMapReader.

     virtual ~NodeMapReader() {

       for (typename MapReaders::iterator it = readers.begin(); 

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

 	delete it->second;

       }

     }

   private:

     NodeMapReader(const NodeMapReader&);

     void operator=(const NodeMapReader&);

   public:

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

     ///

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

     template <typename Map>

     NodeMapReader& readNodeMap(std::string label, Map& map) {

       return _readMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

     template <typename Map>

     NodeMapReader& readNodeMap(std::string label, const Map& map) {

       return _readMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

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

     ///

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

     template <typename ItemReader, typename Map>

     NodeMapReader& readNodeMap(std::string label, Map& map, 

 			       const ItemReader& ir = ItemReader()) {

       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

     template <typename ItemReader, typename Map>

     NodeMapReader& readNodeMap(std::string label, const Map& map, 

 			       const ItemReader& ir = ItemReader()) {

       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

   private:

     template <typename ItemReader, typename Map, typename MapParameter>

     NodeMapReader& _readMap(std::string label, MapParameter map, 

 			   const ItemReader& ir = ItemReader()) {

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

       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();

       if (readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for map: " << label;

 	throw IoParameterError(msg.message());

       }      

       readers.insert(

 	make_pair(label, new _reader_bits::

 		  MapReader<Node, Map, ItemReader>(map, ir)));

       return *this;

     }

   public:

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

     ///

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

     template <typename ItemReader>

     NodeMapReader& skipNodeMap(std::string label, 

 			       const ItemReader& ir = ItemReader()) {

       if (readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for map: " << label;

 	throw IoParameterError(msg.message());

       }

       readers.insert(make_pair(label, new _reader_bits::

 			       SkipReader<Node, ItemReader>(ir)));

       return *this;

     }

   protected:

     /// \brief Gives back true when the SectionReader can process 

     /// the section with the given header line.

     ///

     /// It gives back true when the header line starts with \c \@mapset,

     /// and the header line's name and the mapset's name are the same.

     virtual bool header(const std::string& line) {

       std::istringstream ls(line);

       std::string command;

       std::string id;

       ls >> command >> id;

       return command == "@nodemaps" && name == id;

     }

     /// \brief Reader function of the section.

     ///

     /// It reads the content of the section.

     virtual void read(std::istream& is) {

       std::vector<_reader_bits::MapReaderBase<Node>* > index;

       std::string line;

       {

         getline(is, line);

         std::istringstream ls(line);

         std::string id;

         while (ls >> id) {

           typename MapReaders::iterator it = readers.find(id);

           if (it != readers.end()) {

             it->second->touch();

             index.push_back(it->second);

           } else {

             index.push_back(&skipper);

           }

         }

       }

       for (typename MapReaders::iterator it = readers.begin();

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

 	if (!it->second->touched()) {

 	  ErrorMessage msg;

 	  msg << "Map not found in file: " << it->first;

 	  throw IoParameterError(msg.message());

 	}

       }

       while (getline(is, line)) {	

 	std::istringstream ls(line);

 	Node node = labelReader->read(ls);

 	for (int i = 0; i < int(index.size()); ++i) {

 	  index[i]->read(ls, node);

 	}

       }

     }

     virtual void missing() {

       if (readers.empty()) return;

       ErrorMessage msg;

       msg << "NodeMap section not found in file: @nodemaps " << name;

       throw IoParameterError(msg.message());

     }

   private:

     typedef std::map<std::string, _reader_bits::MapReaderBase<Node>*> MapReaders;

     MapReaders readers;

     const Graph& graph;   

     std::string name;

     _reader_bits::SkipReader<Node, DefaultSkipper> skipper;

     std::auto_ptr<_reader_bits::LabelReaderBase<Node> > labelReader;

   };

   /// \ingroup section_io

   /// \brief SectionReader for reading extra edge maps.

   ///

   /// The lemon format can store maps in the edgeset sections. This

   /// class let you make distinict section to store maps.  The main

   /// purpose of this class is a logical separation of some maps. The

   /// other useful application could be to store paths in edge maps.

   ///

   /// The first line of the section contains the names of the maps

   /// separated with white spaces. Each next line describes an item

   /// in the itemset, and contains in the first column the label of

   /// the item and then the mapped values for each map.

   ///

   /// \relates LemonReader

   template <typename _Graph, typename _Traits = DefaultReaderTraits>

   class EdgeMapReader : public LemonReader::SectionReader {

     typedef LemonReader::SectionReader Parent;

   public:

     typedef _Graph Graph;

     typedef typename Graph::Edge Edge;

     typedef _Traits Traits;

     typedef typename Traits::Skipper DefaultSkipper;

     /// \brief Constructor.

     ///

     /// Constructor for EdgeMapReader. It creates the EdgeMapReader and

     /// attach it into the given LemonReader. The reader will read

     /// the section when the \c section_name and the \c _name are the same.

     template <typename _LabelReader>

     EdgeMapReader(LemonReader& _reader, 

 		   const Graph& _graph, 

 		   const _LabelReader& _labelReader,

 		   const std::string& _name = std::string(),

 		   const DefaultSkipper& _skipper = DefaultSkipper()) 

       : Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {

       labelReader.reset(new _reader_bits::

 			LabelReader<Edge, _LabelReader>(_labelReader));

     } 

     /// \brief Destructor.

     ///

     /// Destructor for EdgeMapReader.

     virtual ~EdgeMapReader() {

       for (typename MapReaders::iterator it = readers.begin(); 

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

 	delete it->second;

       }

     }

   private:

     EdgeMapReader(const EdgeMapReader&);

     void operator=(const EdgeMapReader&);

   public:

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

     ///

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

     template <typename Map>

     EdgeMapReader& readEdgeMap(std::string label, Map& map) {

       return _readMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

     template <typename Map>

     EdgeMapReader& readEdgeMap(std::string label, const Map& map) {

       return _readMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

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

     ///

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

     template <typename ItemReader, typename Map>

     EdgeMapReader& readEdgeMap(std::string label, Map& map, 

 			  const ItemReader& ir = ItemReader()) {

       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

     template <typename ItemReader, typename Map>

     EdgeMapReader& readEdgeMap(std::string label, const Map& map, 

 			  const ItemReader& ir = ItemReader()) {

       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

   private:

     template <typename ItemReader, typename Map, typename MapParameter>

     EdgeMapReader& _readMap(std::string label, MapParameter map, 

 				const ItemReader& ir = ItemReader()) {

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

       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();

       if (readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for map: " << label;

 	throw IoParameterError(msg.message());

       }      

       readers.insert(

 	make_pair(label, new _reader_bits::

 		  MapReader<Edge, Map, ItemReader>(map, ir)));

       return *this;

     }

   public:

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

     ///

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

     template <typename ItemReader>

     EdgeMapReader& skipEdgeMap(std::string label, 

 			  const ItemReader& ir = ItemReader()) {

       if (readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for map: " << label;

 	throw IoParameterError(msg.message());

       }

       readers.insert(make_pair(label, new _reader_bits::

 			       SkipReader<Edge, ItemReader>(ir)));

       return *this;

     }

   protected:

     /// \brief Gives back true when the SectionReader can process 

     /// the section with the given header line.

     ///

     /// It gives back true when the header line starts with \c \@mapset,

     /// and the header line's name and the mapset's name are the same.

     virtual bool header(const std::string& line) {

       std::istringstream ls(line);

       std::string command;

       std::string id;

       ls >> command >> id;

       return (command == "@edgemaps" || command == "@uedgemaps") && name == id;

     }

     /// \brief Reader function of the section.

     ///

     /// It reads the content of the section.

     virtual void read(std::istream& is) {

       std::vector<_reader_bits::MapReaderBase<Edge>* > index;

       std::string line;

       {

         getline(is, line);

         std::istringstream ls(line);

         std::string id;

         while (ls >> id) {

           typename MapReaders::iterator it = readers.find(id);

           if (it != readers.end()) {

             it->second->touch();

             index.push_back(it->second);

           } else {

             index.push_back(&skipper);

           }

         }

       }

       for (typename MapReaders::iterator it = readers.begin();

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

 	if (!it->second->touched()) {

 	  ErrorMessage msg;

 	  msg << "Map not found in file: " << it->first;

 	  throw IoParameterError(msg.message());

 	}

       }

       while (getline(is, line)) {	

 	std::istringstream ls(line);

 	Edge edge = labelReader->read(ls);

 	for (int i = 0; i < int(index.size()); ++i) {

 	  index[i]->read(ls, edge);

 	}

       }

     }

     virtual void missing() {

       if (readers.empty()) return;

       ErrorMessage msg;

       msg << "EdgeMap section not found in file: @edgemaps " << name;

       throw IoParameterError(msg.message());

     }

   private:

     typedef std::map<std::string, _reader_bits::MapReaderBase<Edge>*> MapReaders;

     MapReaders readers;

     const Graph& graph;   

     std::string name;

     _reader_bits::SkipReader<Edge, DefaultSkipper> skipper;

     std::auto_ptr<_reader_bits::LabelReaderBase<Edge> > labelReader;

   };

   /// \ingroup section_io

   /// \brief SectionReader for reading extra undirected edge maps.

   ///

   /// The lemon format can store maps in the uedgeset sections. This

   /// class let you make distinict section to store maps.  The main

   /// purpose of this class is a logical separation of some maps. The

   /// other useful application could be to store paths in undirected

   /// edge maps.

   ///

   /// The first line of the section contains the names of the maps

   /// separated with white spaces. Each next line describes an item

   /// in the itemset, and contains in the first column the label of

   /// the item and then the mapped values for each map.

   ///

   /// \relates LemonReader

   template <typename _Graph, typename _Traits = DefaultReaderTraits>

   class UEdgeMapReader : public LemonReader::SectionReader {

     typedef LemonReader::SectionReader Parent;

   public:

     typedef _Graph Graph;

     typedef typename Graph::Edge Edge;

     typedef typename Graph::UEdge UEdge;

     typedef _Traits Traits;

     typedef typename Traits::Skipper DefaultSkipper;

     /// \brief Constructor.

     ///

     /// Constructor for UEdgeMapReader. It creates the UEdgeMapReader and

     /// attach it into the given LemonReader. The reader will read

     /// the section when the \c section_name and the \c _name are the same.

     template <typename _LabelReader>

     UEdgeMapReader(LemonReader& _reader, const Graph& _graph, 

 		   const _LabelReader& _labelReader,

 		   const std::string& _name = std::string(),

 		   const DefaultSkipper& _skipper = DefaultSkipper()) 

       : Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {

       labelReader.reset(new _reader_bits::

 			LabelReader<UEdge, _LabelReader>(_labelReader));

     } 

     /// \brief Destructor.

     ///

     /// Destructor for UEdgeMapReader.

     virtual ~UEdgeMapReader() {

       for (typename MapReaders::iterator it = readers.begin(); 

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

 	delete it->second;

       }

     }

   private:

     UEdgeMapReader(const UEdgeMapReader&);

     void operator=(const UEdgeMapReader&);

   public:

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

     UEdgeMapReader& readUEdgeMap(std::string label, Map& map) {

       return _readMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

     template <typename Map>

     UEdgeMapReader& readUEdgeMap(std::string label, const Map& map) {

       return _readMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

     /// \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 ItemReader, typename Map>

     UEdgeMapReader& readUEdgeMap(std::string label, Map& map, 

 			  const ItemReader& ir = ItemReader()) {

       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

     template <typename ItemReader, typename Map>

     UEdgeMapReader& readUEdgeMap(std::string label, const Map& map, 

 			  const ItemReader& ir = ItemReader()) {

       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>

 	(label, map, ir);

     }

   private:

     template <typename ItemReader, typename Map, typename MapParameter>

     UEdgeMapReader& _readMap(std::string label, MapParameter map, 

 				const ItemReader& ir = ItemReader()) {

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

       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();

       if (readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for map: " << label;

 	throw IoParameterError(msg.message());

       }      

       readers.insert(

 	make_pair(label, new _reader_bits::

 		  MapReader<UEdge, Map, ItemReader>(map, ir)));

       return *this;

     }

   public:

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

     UEdgeMapReader& skipUEdgeMap(std::string label, 

 			  const ItemReader& ir = ItemReader()) {

       if (readers.find(label) != readers.end()) {

 	ErrorMessage msg;

 	msg << "Multiple read rule for map: " << label;

 	throw IoParameterError(msg.message());

       }

       readers.insert(make_pair(label, new _reader_bits::

 			       SkipReader<Edge, ItemReader>(ir)));

       return *this;

     }

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

     ///

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

     template <typename Map>

     UEdgeMapReader& readEdgeMap(std::string label, Map& map) {

       return _readDirMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

     template <typename Map>

     UEdgeMapReader& readEdgeMap(std::string label, const Map& map) {

       return _readDirMap<

 	typename Traits::template Reader<typename Map::Value>, Map,

 	typename _reader_bits::Arg<Map>::Type>(label, map);

     }

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

     ///

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

     template <typename ItemReader, typename Map>

     UEdgeMapReader& readEdgeMap(std::string label, Map& map, 

 				    const ItemReader& ir = ItemReader()) {

       return _readDirMap<ItemReader, Map, 

         typename _reader_bits::Arg<Map>::Type>(label, map, ir);

     }

     template <typename ItemReader, typename Map>

     UEdgeMapReader& readEdgeMap(std::string label, const Map& map, 

 				    const ItemReader& ir = ItemReader()) {

       return _readDirMap<ItemReader, Map, 

         typename _reader_bits::Arg<Map>::Type>(label, map, ir);

     }

   private:

     template <typename ItemReader, typename Map, typename MapParameter>

     UEdgeMapReader& _readDirMap(std::string label, MapParameter map,

 				    const ItemReader& ir = ItemReader()) { 

       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();

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

       readUEdgeMap("+" + label, 

                    _reader_bits::forwardComposeMap(graph, map), ir);

       readUEdgeMap("-" + label, 

                    _reader_bits::backwardComposeMap(graph, map), ir);

       return *this;      

     }

   public:

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

     ///

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

     template <typename ItemReader>

     UEdgeMapReader& skipEdgeMap(std::string label, 

                                 const ItemReader& ir = ItemReader()) {

       skipUEdgeMap("+" + label, ir);

       skipUEdgeMap("-" + label, ir);

       return *this;

     }

   protected:

     /// \brief Gives back true when the SectionReader can process 

     /// the section with the given header line.

     ///

     /// It gives back true when the header line starts with \c \@mapset,

     /// and the header line's name and the mapset's name are the same.

     virtual bool header(const std::string& line) {

       std::istringstream ls(line);

       std::string command;

       std::string id;

       ls >> command >> id;

       return (command == "@edgemaps" || command == "@uedgemaps") && name == id;

     }

     /// \brief Reader function of the section.

     ///

     /// It reads the content of the section.

     virtual void read(std::istream& is) {

       std::vector<_reader_bits::MapReaderBase<UEdge>* > index;

       std::string line;

       {

         getline(is, line);

         std::istringstream ls(line);

         std::string id;

         while (ls >> id) {

           typename MapReaders::iterator it = readers.find(id);

           if (it != readers.end()) {

             it->second->touch();

             index.push_back(it->second);

           } else {

             index.push_back(&skipper);

           }

         }

       }

       for (typename MapReaders::iterator it = readers.begin();

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

 	if (!it->second->touched()) {

 	  ErrorMessage msg;

 	  msg << "Map not found in file: " << it->first;

 	  throw IoParameterError(msg.message());

 	}

       }

       while (getline(is, line)) {	

 	std::istringstream ls(line);

 	UEdge uedge = labelReader->read(ls);

 	for (int i = 0; i < int(index.size()); ++i) {

 	  index[i]->read(ls, uedge);

 	}

       }

     }

     virtual void missing() {

       if (readers.empty()) return;

       ErrorMessage msg;

       msg << "UEdgeMap section not found in file: @uedgemaps " << name;

       throw IoParameterError(msg.message());

     }

   private:

     const Graph& graph;   

     std::string name;

     typedef std::map<std::string, 

 		     _reader_bits::MapReaderBase<UEdge>*> MapReaders;

     MapReaders readers;

     _reader_bits::SkipReader<UEdge, DefaultSkipper> skipper;

     std::auto_ptr<_reader_bits::LabelReaderBase<UEdge> > labelReader;