/* -*- 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 Format reader.

#ifndef LEMON_LEMON_READER_H

#define LEMON_LEMON_READER_H

#include <iostream>

#include <fstream>

#include <string>

#include <vector>

#include <algorithm>

#include <map>

#include <memory>

#include <lemon/error.h>

#include <lemon/graph_utils.h>

#include <lemon/bits/utility.h>

#include <lemon/bits/item_reader.h>

#include <lemon/dim2.h>

#include <lemon/concept_check.h>

#include <lemon/concepts/maps.h>

namespace lemon {

  namespace _reader_bits {

    template <typename T>

    bool operator<(T, T) {

      throw DataFormatError("Label is not comparable");

    }

    template <typename T>

    struct Less {

      bool operator()(const T& p, const T& q) const {

	return p < q;

      }

    };

    template <typename Item>

    class ItemLabelReader {

    public:

      bool isLabelReader() { return true; }

      void readLabel(std::istream&, Item&) {}

      template <class _ItemLabelReader>

      struct Constraints {

	void constraints() {

	  bool b = reader.isLabelReader();

	  ignore_unused_variable_warning(b);

	  Item item;

	  reader.readLabel(is, item);

	}

	_ItemLabelReader& reader;

	std::istream& is;

      };

    };

    template <typename Item>

    class ItemReader {

    public:

      void read(std::istream&, Item&) {}

      template <class _ItemReader>

      struct Constraints {

	void constraints() {

	  Item item;

	  reader.read(is, item);

	}

	_ItemReader& reader;

	std::istream& is;

      };

    };

    template <typename Map>

    struct Ref { typedef Map& Type; };

    template <typename Map>

    struct Arg { typedef Map& Type; };

    template <typename Graph, typename Map>

    class ForwardComposeMap {

    public:

      typedef typename Graph::UEdge Key;

      typedef typename Map::Value Value;

      ForwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map) 

	: graph(_graph), map(_map) {}

      void set(const Key& key, const Value& val) {

	map.set(graph.direct(key, true), val);

      }

    private:

      const Graph& graph;

      typename Ref<Map>::Type map;

    };

    template <typename Graph, typename Map>

    ForwardComposeMap<Graph, Map>

    forwardComposeMap(const Graph& graph, const Map& map) {

      return ForwardComposeMap<Graph, Map>(graph, map);

    }

    template <typename Graph, typename Map>

    ForwardComposeMap<Graph, Map>

    forwardComposeMap(const Graph& graph, Map& map) {

      return ForwardComposeMap<Graph, Map>(graph, map);

    }

    template <typename Graph, typename Map>

    class BackwardComposeMap {

    public:

      typedef typename Graph::UEdge Key;

      typedef typename Map::Value Value;

      BackwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map) 

	: graph(_graph), map(_map) {}

      void set(const Key& key, const Value& val) {

	map.set(graph.direct(key, false), val);

      }

    private:

      const Graph& graph;

      typename Ref<Map>::Type map;

    };

    template <typename Graph, typename Map>

    BackwardComposeMap<Graph, Map>

    backwardComposeMap(const Graph& graph, const Map& map) {

      return BackwardComposeMap<Graph, Map>(graph, map);

    }

    template <typename Graph, typename Map>

    BackwardComposeMap<Graph, Map>

    backwardComposeMap(const Graph& graph, Map& map) {

      return BackwardComposeMap<Graph, Map>(graph, map);

    }

    template <typename Graph, typename Map>

    struct Ref<ForwardComposeMap<Graph, Map> > { 

      typedef ForwardComposeMap<Graph, Map> Type;

    };

    template <typename Graph, typename Map>

    struct Arg<ForwardComposeMap<Graph, Map> > { 

      typedef const ForwardComposeMap<Graph, Map>& Type;

    };

    template <typename Graph, typename Map>

    struct Ref<BackwardComposeMap<Graph, Map> > { 

      typedef BackwardComposeMap<Graph, Map> Type; 

    };

    template <typename Graph, typename Map>

    struct Arg<BackwardComposeMap<Graph, Map> > { 

      typedef const BackwardComposeMap<Graph, Map>& Type; 

    };

    template <typename Map>

    struct Ref<dim2::XMap<Map> > { 

      typedef dim2::XMap<Map> Type;

    };

    template <typename Map>

    struct Arg<dim2::XMap<Map> > { 

      typedef const dim2::XMap<Map>& Type;

    };

    template <typename Map>

    struct Ref<dim2::YMap<Map> > { 

      typedef dim2::YMap<Map> Type;

    };

    template <typename Map>

    struct Arg<dim2::YMap<Map> > { 

      typedef const dim2::YMap<Map>& Type;

    };

    template <typename _Item>

    class MapReaderBase;

    template <typename _Item>

    class MapInverterBase : public MapReaderBase<_Item> {

    public:

      typedef _Item Item;

      virtual void read(std::istream&, const Item&) = 0;

      virtual Item read(std::istream&) const = 0;

      virtual MapInverterBase<_Item>* getInverter() {

	return this;

      }

    };

    template <typename _Item, typename _Map, typename _Reader>

    class MapReaderInverter : public MapInverterBase<_Item> {

    public:

      typedef _Item Item;

      typedef _Reader Reader;

      typedef typename Reader::Value Value;

      typedef _Map Map;

      typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;

      typename _reader_bits::Ref<Map>::Type map;

      Reader reader;

      Inverse inverse;

      MapReaderInverter(typename _reader_bits::Arg<Map>::Type _map,

			const Reader& _reader) 

	: map(_map), reader(_reader) {}

      virtual ~MapReaderInverter() {}

      virtual void read(std::istream& is, const Item& item) {

	Value value;

	reader.read(is, value);

	map.set(item, value);

	typename Inverse::iterator it = inverse.find(value);

	if (it == inverse.end()) {

	  inverse.insert(std::make_pair(value, item));

	} else {

	  throw DataFormatError("Multiple label occurence");

	}

      }

      virtual Item read(std::istream& is) const {

	Value value;

	reader.read(is, value);	

	typename Inverse::const_iterator it = inverse.find(value);

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

	  return it->second;

	} else {

	  ErrorMessage msg;

	  msg << "Invalid label error"; 

	  throw DataFormatError(msg.message());

	}

      }      

    };

    template <typename _Item, typename _Reader>

    class SkipReaderInverter : public MapInverterBase<_Item> {

    public:

      typedef _Item Item;

      typedef _Reader Reader;

      typedef typename Reader::Value Value;

      typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;

      Reader reader;

      SkipReaderInverter(const Reader& _reader) 

	: reader(_reader) {}

      virtual ~SkipReaderInverter() {}

      virtual void read(std::istream& is, const Item& item) {

	Value value;

	reader.read(is, value);

	typename Inverse::iterator it = inverse.find(value);

	if (it == inverse.end()) {

	  inverse.insert(std::make_pair(value, item));

	} else {

	  throw DataFormatError("Multiple label occurence error");

	}

      }

      virtual Item read(std::istream& is) const {

	Value value;

	reader.read(is, value);

	typename Inverse::const_iterator it = inverse.find(value);

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

	  return it->second;

	} else {

	  ErrorMessage msg;

	  msg << "Invalid label error: " << value; 

	  throw DataFormatError(msg.message());

	}

      }

    private:

      Inverse inverse;

    };

    template <typename _Item>    

    class MapReaderBase {

    public:

      typedef _Item Item;

      MapReaderBase() { _touched = false; }

      void touch() { _touched = true; }

      bool touched() const { return _touched; }

      virtual ~MapReaderBase() {}

      virtual void read(std::istream& is, const Item& item) = 0;

      virtual MapInverterBase<_Item>* getInverter() = 0;

    private:      

      bool _touched;

    };

    template <typename _Item, typename _Map, typename _Reader>

    class MapReader : public MapReaderBase<_Item> {

    public:

      typedef _Map Map;

      typedef _Reader Reader;

      typedef typename Reader::Value Value;

      typedef _Item Item;

      typename _reader_bits::Ref<Map>::Type map;

      Reader reader;

      MapReader(typename _reader_bits::Arg<Map>::Type _map, 

		const Reader& _reader) 

	: map(_map), reader(_reader) {}

      virtual ~MapReader() {}

      virtual void read(std::istream& is, const Item& item) {

	Value value;

	reader.read(is, value);

	map.set(item, value);

      }

      virtual MapInverterBase<_Item>* getInverter() {

	return new MapReaderInverter<Item, Map, Reader>(map, reader);

      }

    };

    template <typename _Item, typename _Reader>

    class SkipReader : public MapReaderBase<_Item> {

    public:

      typedef _Reader Reader;

      typedef typename Reader::Value Value;

      typedef _Item Item;

      Reader reader;

      SkipReader(const Reader& _reader) : reader(_reader) {}

      virtual ~SkipReader() {}

      virtual void read(std::istream& is, const Item&) {

	Value value;

	reader.read(is, value);

      }      

      virtual MapInverterBase<Item>* getInverter() {

	return new SkipReaderInverter<Item, Reader>(reader);

      }

    };

    template <typename _Item>

    class LabelReaderBase {

    public:

      typedef _Item Item;

      virtual ~LabelReaderBase() {}

      virtual Item read(std::istream& is) const = 0;

      virtual bool isLabelReader() const = 0;

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

    };

    template <typename _Item, typename _BoxedLabelReader>

    class LabelReader : public LabelReaderBase<_Item> {

    public:

      typedef _Item Item;

      typedef _BoxedLabelReader BoxedLabelReader;

      const BoxedLabelReader& labelReader;

      LabelReader(const BoxedLabelReader& _labelReader) 

	: labelReader(_labelReader) {}

      virtual Item read(std::istream& is) const {

	Item item;

	labelReader.readLabel(is, item);

	return item;

      }

      virtual bool isLabelReader() const {

	return labelReader.isLabelReader();

      }

      LabelReader<Item, BoxedLabelReader>* clone() const {

	return new LabelReader<Item, BoxedLabelReader>(labelReader);

      }

    };

    template <typename _Item>

    class ItemStore {

    public:

      typedef _Item Item;

      ItemStore(Item& _item) : item(&_item) { 

	_touched = false; 

      }

      void touch() { _touched = true; }

      bool touched() const { return _touched; }

      void read(const Item& _item) {

	*item = _item;

      }

    private:

      Item* item;

      bool _touched;

    };

    class ValueReaderBase {

    public:

      virtual void read(std::istream&) {};

      ValueReaderBase() { _touched = false; }

      void touch() { _touched = true; }

      bool touched() const { return _touched; }

      virtual ~ValueReaderBase() {}

    private:

      bool _touched;

    };

    template <typename _Value, typename _Reader>

    class ValueReader : public ValueReaderBase {

    public:

      typedef _Value Value;

      typedef _Reader Reader;

      ValueReader(Value& _value, const Reader& _reader)

 	: value(_value), reader(_reader) {}

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

	reader.read(is, value);

      }

    private:

      Value& value;

      Reader reader;

    };

  }

  /// \ingroup lemon_io

  /// \brief Lemon Format reader class.

  /// 

  /// The Lemon Format contains several sections. We do not want to

  /// determine what sections are in a lemon file we give only a framework

  /// to read a section oriented format.

  ///

  /// In the Lemon Format each section starts with a line containing a

  /// \c \@ character on the first not white space position. This line

  /// is the header line of the section. Each of the next lines belong

  /// to this section until a line starting with \c \@ character is

  /// found. This line can start a new section or it can close the

  /// file with the \c \@end line.  The file format ignores the empty

  /// and comment lines. The line is comment line if it starts with a

  /// \c # character.

  ///

  /// The framework provides an abstract LemonReader::SectionReader class

  /// that defines the interface of a SectionReader. The SectionReader

  /// has the \c header() member function that gets a header line string and

  /// decides if it wants to process the next section. Several SectionReaders

  /// can be attached to a LemonReader and the first attached that can

  /// process the section will be used. Its \c read() member will be called

  /// with a stream containing the section. From this stream the empty and

  /// comment lines are filtered out.

  ///

  /// \relates GraphReader

  /// \relates NodeSetReader

  /// \relates EdgeSetReader

  /// \relates NodesReader

  /// \relates EdgesReader

  /// \relates AttributeReader

  class LemonReader {

  private:

    class FilterStreamBuf : public std::streambuf {

    public:

      typedef std::streambuf Parent;

      typedef Parent::char_type char_type;

      FilterStreamBuf(std::istream& is, int& num) 

	: _is(is), _base(0), _eptr(0), 

	  _num(num), skip_state(after_endl) {}

    protected:

      enum skip_state_type {

	no_skip,

	after_endl,

	comment_line

      };

      char_type small_buf[1];

      std::istream& _is;

      char_type* _base;

      char_type* _eptr;

      int& _num;

      skip_state_type skip_state;

      char_type* base() { return _base; }

      char_type* eptr() { return _eptr; }

      int_type blen() { return _eptr - _base; }

      void setb(char_type* buf, int_type len) {

	_base = buf;

	_eptr = buf + len;

      }

      virtual std::streambuf* setbuf(char *buf, std::streamsize len) {

	if (base()) return 0;

	if (buf != 0 && len >= int(sizeof(small_buf))) {

	  setb(buf, len);

	} else {

	  setb(small_buf, sizeof(small_buf));

	}

	setg(0, 0, 0);

	return this;

      }

      bool put_char(char c) {

	switch (skip_state) {

	case no_skip:

	  switch (c) {

	  case '\n': 

	    skip_state = after_endl;

	    return true;

	  default:

	    return true;

	  }

	case after_endl:

	  switch (c) {

	  case '@':

	    return false;

	  case '\n': 

	    return false;

	  case '#':

	    skip_state = comment_line;

	    return false;

	  default:

	    if (!isspace(c)) {

	      skip_state = no_skip;

	      return true;

	    } else {

	      return false;

	    }

	  }

	  break;

	case comment_line:

	  switch (c) {

	  case '\n': 

	    skip_state = after_endl;

	    return false;

	  default:

	    return false;

	  }

	}

	return false;

      }

      virtual int_type underflow() {

	char c;

	if (_is.read(&c, 1)) {

	  _is.putback(c);

	  if (c == '@') {

	    return EOF;

	  }

	} else {

	  return EOF;

	}

	char_type *ptr;

	for (ptr = base(); ptr != eptr(); ++ptr) {

	  if (_is.read(&c, 1)) {

	    if (c == '\n') ++_num;

	    if (put_char(c)) {

	      *ptr = c;

	    } else {

	      if (skip_state == after_endl && c == '@') {

		_is.putback('@');

		break;

	      }

	      --ptr;

	    }

	  } else {

	    break;

	  }

	}

	setg(base(), base(), ptr);

	return *base();

      }

      virtual int_type sync() {

	return EOF;

      }

    public:

      int line_num() const {

	int r = _num;

	for (char_type* p = gptr(); p != egptr(); ++p) {

	  if (*p == '\n') --r;

	}

	return r;

      }

    };

  public:

    /// \brief Abstract base class for reading a section.

    ///

    /// This class has an \c header() member function what get a 

    /// header line string and decides if it want to process the next 

    /// section. Several SectionReaders can be attached to an LemonReader 

    /// and the first attached what can process the section will be used. 

    /// Its \c read() member will called with a stream contains the section. 

    /// From this stream the empty lines and comments are filtered out.

    class SectionReader {

      friend class LemonReader;

    protected:

      /// \brief Constructor for SectionReader.

      ///

      /// Constructor for SectionReader. It attach this reader to

      /// the given LemonReader.

      SectionReader(LemonReader& reader) {

	reader.attach(*this);

      }

      virtual ~SectionReader() {}

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

      /// the section with the given header line.

      ///

      /// It gives back true when the SectionReader can process

      /// the section with the given header line.

      virtual bool header(const std::string& line) = 0;

      /// \brief Reader function of the section.

      ///

      /// It reads the content of the section.

      virtual void read(std::istream& is) = 0;

      /// \brief The given section missing in the file.

      ///

      /// The given section missing in the file.

      virtual void missing() {};

    };

    /// \brief Constructor for LemonReader.

    ///

    /// Constructor for LemonReader which reads from the given stream.

    LemonReader(std::istream& _is) 

      : is(&_is), own_is(false) {}

    /// \brief Constructor for LemonReader.

    ///

    /// Constructor for LemonReader which reads from the given file.

    LemonReader(const std::string& filename) 

      : is(0), own_is(true) {

      is = new std::ifstream(filename.c_str());

      if (is->fail()) {

	throw FileOpenError(filename);

      }

    }

    /// \brief Desctructor for LemonReader.

    ///

    /// Desctructor for LemonReader.

    ~LemonReader() {

      if (own_is) {

	delete is;

      }

    }

  private:

    LemonReader(const LemonReader&);

    void operator=(const LemonReader&);

    void attach(SectionReader& reader) {

      readers.push_back(std::make_pair(&reader, false));

    }

  public:

    /// \brief Executes the LemonReader.

    /// 

    /// It executes the LemonReader.

    void run() {

      int line_num = 0;

      std::string line;

      SectionReaders::iterator it;

      while ((++line_num, getline(*is, line)) && line.find("@end") != 0) {

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

	  if (it->first->header(line)) {

	    it->second = true;

	    char buf[2048];

	    FilterStreamBuf buffer(*is, line_num);

	    try {

	      buffer.pubsetbuf(buf, sizeof(buf));

	      std::istream ss(&buffer);

	      it->first->read(ss);

	      break;

	    } catch (DataFormatError& error) {

	      error.line(buffer.line_num());

	      throw;

	    }	

	  }

	}

      }

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

	if (!it->second) {

	  try {

	    it->first->missing();

	  } catch (DataFormatError& error) {

	    error.line(line_num);

	    throw;

	  }	

	}

      }

    }

  private:

    std::istream* is;

    bool own_is;

    typedef std::vector<std::pair<SectionReader*, bool> > SectionReaders;

    SectionReaders readers;

  };

  /// \ingroup section_io

  /// \brief SectionReader for reading a graph's nodeset.

  ///

  /// The lemon format can store multiple graph nodesets with several

  /// maps.  The nodeset section's header line is \c \@nodeset \c

  /// nodeset_name, but the \c nodeset_name may be empty.

  ///

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

  /// with white spaces. Each next lines describes a node in the nodeset, and

  /// contains the mapped values for each map.

  ///

  /// If the nodeset contains an \c "label" named map then it will be regarded

  /// as id map. This map should contain only unique values and when the 

  /// \c readLabel() member will read a value from the given stream it will

  /// give back that node which is mapped to this value.

  ///

  /// \relates LemonReader

  template <typename _Graph, typename _Traits = DefaultReaderTraits>

  class NodeSetReader : public LemonReader::SectionReader {

    typedef LemonReader::SectionReader Parent;

  public:

    typedef _Graph Graph;

    typedef _Traits Traits;

    typedef typename Graph::Node Node;

    typedef typename Traits::Skipper DefaultSkipper;

    /// \brief Constructor.

    ///

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

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

    /// add the read nodes to the given Graph. The reader will read

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

    NodeSetReader(LemonReader& _reader, 

		  Graph& _graph, 

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

		  const DefaultSkipper& _skipper = DefaultSkipper()) 

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

    /// \brief Destructor.

    ///

    /// Destructor for NodeSetReader.

    virtual ~NodeSetReader() {

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

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

	delete it->second;

      }

    }

  private:

    NodeSetReader(const NodeSetReader&);

    void operator=(const NodeSetReader&);

  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>

    NodeSetReader& 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>

    NodeSetReader& 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>

    NodeSetReader& 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>

    NodeSetReader& 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>

    NodeSetReader& _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 node 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>

    NodeSetReader& skipNodeMap(std::string label, 

                               const ItemReader& ir = ItemReader()) {

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

	ErrorMessage msg;

	msg << "Multiple read rule for node 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 \@nodeset,

    /// and the header line's name and the nodeset'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 == "@nodeset" && 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);

          }

          if (id == "label") {

            inverter.reset(index.back()->getInverter());

            index.back() = inverter.get();

          }

        }

      }

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

	Node node = graph.addNode();

	std::istringstream ls(line);

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

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

	}

      }

    }

    virtual void missing() {

      if (readers.empty()) return;

      ErrorMessage msg;

      msg << "NodeSet section not found in file: @nodeset " << name;

      throw IoParameterError(msg.message());

    }

  public:

    /// \brief Returns true if the nodeset can give back the node by its label.

    ///

    /// Returns true if the nodeset can give back the node by its label.

    /// It is possible only if an "label" named map was read.

    bool isLabelReader() const {

      return inverter.get() != 0;

    }

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

    ///

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

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

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

      node = inverter->read(is);

    } 

  private:

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

    MapReaders readers;

    Graph& graph;   

    std::string name;

    _reader_bits::SkipReader<Node, DefaultSkipper> skipper;

    std::auto_ptr<_reader_bits::MapInverterBase<Node> > inverter;

  };

  /// \ingroup section_io

  /// \brief SectionReader for reading a graph's edgeset.

  ///

  /// The lemon format can store multiple graph edgesets with several maps.

  /// The edgeset section's header line is \c \@edgeset \c edgeset_name, but the

  /// \c edgeset_name may be empty.

  ///

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