lemon/lemon_reader.h
author deba
Fri, 31 Aug 2007 08:40:49 +0000
changeset 2469 d6f12a9b5cbf
parent 2464 d4bdbc35c927
child 2476 059dcdda37c5
permissions -rw-r--r--
Invalid assignments ambiguity handling
     1 /* -*- C++ -*-
     2  *
     3  * This file is a part of LEMON, a generic C++ optimization library
     4  *
     5  * Copyright (C) 2003-2007
     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).
     8  *
     9  * Permission to use, modify and distribute this software is granted
    10  * provided that this copyright notice appears in all copies. For
    11  * precise terms see the accompanying LICENSE file.
    12  *
    13  * This software is provided "AS IS" with no warranty of any kind,
    14  * express or implied, and with no claim as to its suitability for any
    15  * purpose.
    16  *
    17  */
    18 
    19 ///\ingroup lemon_io
    20 ///\file
    21 ///\brief Lemon Format reader.
    22 
    23 
    24 #ifndef LEMON_LEMON_READER_H
    25 #define LEMON_LEMON_READER_H
    26 
    27 
    28 #include <iostream>
    29 #include <fstream>
    30 #include <string>
    31 #include <vector>
    32 #include <algorithm>
    33 #include <map>
    34 #include <memory>
    35 
    36 #include <lemon/error.h>
    37 #include <lemon/graph_utils.h>
    38 #include <lemon/bits/utility.h>
    39 #include <lemon/bits/item_reader.h>
    40 
    41 #include <lemon/dim2.h>
    42 
    43 #include <lemon/concept_check.h>
    44 #include <lemon/concepts/maps.h>
    45 
    46 namespace lemon {
    47 
    48   namespace _reader_bits {
    49 
    50     template <typename T>
    51     bool operator<(T, T) {
    52       throw DataFormatError("Label is not comparable");
    53     }
    54 
    55     template <typename T>
    56     struct Less {
    57       bool operator()(const T& p, const T& q) const {
    58 	return p < q;
    59       }
    60     };
    61     
    62     template <typename Item>
    63     class ItemLabelReader {
    64     public:
    65 
    66       bool isLabelReader() { return true; }
    67 
    68       void readLabel(std::istream&, Item&) {}
    69       
    70       template <class _ItemLabelReader>
    71       struct Constraints {
    72 	void constraints() {
    73 	  bool b = reader.isLabelReader();
    74 	  ignore_unused_variable_warning(b);
    75 	  Item item;
    76 	  reader.readLabel(is, item);
    77 	}
    78 	_ItemLabelReader& reader;
    79 	std::istream& is;
    80       };
    81 
    82     };
    83 
    84     template <typename Item>
    85     class ItemReader {
    86     public:
    87       void read(std::istream&, Item&) {}
    88       
    89       template <class _ItemReader>
    90       struct Constraints {
    91 	void constraints() {
    92 	  Item item;
    93 	  reader.read(is, item);
    94 	}
    95 	_ItemReader& reader;
    96 	std::istream& is;
    97       };
    98 
    99     };
   100 
   101     template <typename Map>
   102     struct Ref { typedef Map& Type; };
   103     template <typename Map>
   104     struct Arg { typedef Map& Type; };
   105 
   106     template <typename Graph, typename Map>
   107     class ForwardComposeMap {
   108     public:
   109       typedef typename Graph::UEdge Key;
   110       typedef typename Map::Value Value;
   111 
   112       ForwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map) 
   113 	: graph(_graph), map(_map) {}
   114       
   115       void set(const Key& key, const Value& val) {
   116 	map.set(graph.direct(key, true), val);
   117       }
   118 
   119     private:
   120       const Graph& graph;
   121       typename Ref<Map>::Type map;
   122     };
   123 
   124     template <typename Graph, typename Map>
   125     ForwardComposeMap<Graph, Map>
   126     forwardComposeMap(const Graph& graph, const Map& map) {
   127       return ForwardComposeMap<Graph, Map>(graph, map);
   128     }
   129 
   130     template <typename Graph, typename Map>
   131     ForwardComposeMap<Graph, Map>
   132     forwardComposeMap(const Graph& graph, Map& map) {
   133       return ForwardComposeMap<Graph, Map>(graph, map);
   134     }
   135 
   136     template <typename Graph, typename Map>
   137     class BackwardComposeMap {
   138     public:
   139       typedef typename Graph::UEdge Key;
   140       typedef typename Map::Value Value;
   141 
   142       BackwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map) 
   143 	: graph(_graph), map(_map) {}
   144       
   145       void set(const Key& key, const Value& val) {
   146 	map.set(graph.direct(key, false), val);
   147       }
   148 
   149     private:
   150       const Graph& graph;
   151       typename Ref<Map>::Type map;
   152     };
   153 
   154 
   155     template <typename Graph, typename Map>
   156     BackwardComposeMap<Graph, Map>
   157     backwardComposeMap(const Graph& graph, const Map& map) {
   158       return BackwardComposeMap<Graph, Map>(graph, map);
   159     }
   160 
   161     template <typename Graph, typename Map>
   162     BackwardComposeMap<Graph, Map>
   163     backwardComposeMap(const Graph& graph, Map& map) {
   164       return BackwardComposeMap<Graph, Map>(graph, map);
   165     }
   166 
   167     template <typename Graph, typename Map>
   168     struct Ref<ForwardComposeMap<Graph, Map> > { 
   169       typedef ForwardComposeMap<Graph, Map> Type;
   170     };
   171     template <typename Graph, typename Map>
   172     struct Arg<ForwardComposeMap<Graph, Map> > { 
   173       typedef const ForwardComposeMap<Graph, Map>& Type;
   174     };
   175 
   176     template <typename Graph, typename Map>
   177     struct Ref<BackwardComposeMap<Graph, Map> > { 
   178       typedef BackwardComposeMap<Graph, Map> Type; 
   179     };
   180     template <typename Graph, typename Map>
   181     struct Arg<BackwardComposeMap<Graph, Map> > { 
   182       typedef const BackwardComposeMap<Graph, Map>& Type; 
   183     };
   184 
   185     template <typename Map>
   186     struct Ref<dim2::XMap<Map> > { 
   187       typedef dim2::XMap<Map> Type;
   188     };
   189     template <typename Map>
   190     struct Arg<dim2::XMap<Map> > { 
   191       typedef const dim2::XMap<Map>& Type;
   192     };
   193 
   194     template <typename Map>
   195     struct Ref<dim2::YMap<Map> > { 
   196       typedef dim2::YMap<Map> Type;
   197     };
   198     template <typename Map>
   199     struct Arg<dim2::YMap<Map> > { 
   200       typedef const dim2::YMap<Map>& Type;
   201     };
   202 
   203 
   204     template <typename _Item>
   205     class MapReaderBase;
   206     
   207     template <typename _Item>
   208     class MapInverterBase : public MapReaderBase<_Item> {
   209     public:
   210       typedef _Item Item;
   211       virtual void read(std::istream&, const Item&) = 0;
   212       virtual Item read(std::istream&) const = 0;
   213 
   214       virtual MapInverterBase<_Item>* getInverter() {
   215 	return this;
   216       }
   217     };
   218 
   219     template <typename _Item, typename _Map, typename _Reader>
   220     class MapReaderInverter : public MapInverterBase<_Item> {
   221     public:
   222       typedef _Item Item;
   223       typedef _Reader Reader;
   224       typedef typename Reader::Value Value;
   225       typedef _Map Map;
   226       typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
   227 
   228       typename _reader_bits::Ref<Map>::Type map;
   229       Reader reader;
   230       Inverse inverse;
   231 
   232       MapReaderInverter(typename _reader_bits::Arg<Map>::Type _map,
   233 			const Reader& _reader) 
   234 	: map(_map), reader(_reader) {}
   235 
   236       virtual ~MapReaderInverter() {}
   237 
   238       virtual void read(std::istream& is, const Item& item) {
   239 	Value value;
   240 	reader.read(is, value);
   241 	map.set(item, value);
   242 	typename Inverse::iterator it = inverse.find(value);
   243 	if (it == inverse.end()) {
   244 	  inverse.insert(std::make_pair(value, item));
   245 	} else {
   246 	  throw DataFormatError("Multiple label occurence");
   247 	}
   248       }
   249 
   250       virtual Item read(std::istream& is) const {
   251 	Value value;
   252 	reader.read(is, value);	
   253 	typename Inverse::const_iterator it = inverse.find(value);
   254 	if (it != inverse.end()) {
   255 	  return it->second;
   256 	} else {
   257 	  ErrorMessage msg;
   258 	  msg << "Invalid label error"; 
   259 	  throw DataFormatError(msg.message());
   260 	}
   261       }      
   262     };
   263 
   264     template <typename _Item, typename _Reader>
   265     class SkipReaderInverter : public MapInverterBase<_Item> {
   266     public:
   267       typedef _Item Item;
   268       typedef _Reader Reader;
   269       typedef typename Reader::Value Value;
   270       typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
   271 
   272       Reader reader;
   273 
   274       SkipReaderInverter(const Reader& _reader) 
   275 	: reader(_reader) {}
   276 
   277       virtual ~SkipReaderInverter() {}
   278 
   279       virtual void read(std::istream& is, const Item& item) {
   280 	Value value;
   281 	reader.read(is, value);
   282 	typename Inverse::iterator it = inverse.find(value);
   283 	if (it == inverse.end()) {
   284 	  inverse.insert(std::make_pair(value, item));
   285 	} else {
   286 	  throw DataFormatError("Multiple label occurence error");
   287 	}
   288       }
   289 
   290       virtual Item read(std::istream& is) const {
   291 	Value value;
   292 	reader.read(is, value);
   293 	typename Inverse::const_iterator it = inverse.find(value);
   294 	if (it != inverse.end()) {
   295 	  return it->second;
   296 	} else {
   297 	  ErrorMessage msg;
   298 	  msg << "Invalid label error: " << value; 
   299 	  throw DataFormatError(msg.message());
   300 	}
   301       }
   302 
   303     private:
   304       Inverse inverse;
   305     };
   306 
   307     template <typename _Item>    
   308     class MapReaderBase {
   309     public:
   310       typedef _Item Item;
   311 
   312       MapReaderBase() { _touched = false; }
   313       
   314       void touch() { _touched = true; }
   315       bool touched() const { return _touched; }
   316 
   317       virtual ~MapReaderBase() {}
   318 
   319       virtual void read(std::istream& is, const Item& item) = 0;
   320       virtual MapInverterBase<_Item>* getInverter() = 0;
   321 
   322     private:      
   323       bool _touched;
   324 
   325     };
   326 
   327     template <typename _Item, typename _Map, typename _Reader>
   328     class MapReader : public MapReaderBase<_Item> {
   329     public:
   330       typedef _Map Map;
   331       typedef _Reader Reader;
   332       typedef typename Reader::Value Value;
   333       typedef _Item Item;
   334       
   335       typename _reader_bits::Ref<Map>::Type map;
   336       Reader reader;
   337 
   338       MapReader(typename _reader_bits::Arg<Map>::Type _map, 
   339 		const Reader& _reader) 
   340 	: map(_map), reader(_reader) {}
   341 
   342       virtual ~MapReader() {}
   343 
   344       virtual void read(std::istream& is, const Item& item) {
   345 	Value value;
   346 	reader.read(is, value);
   347 	map.set(item, value);
   348       }
   349 
   350       virtual MapInverterBase<_Item>* getInverter() {
   351 	return new MapReaderInverter<Item, Map, Reader>(map, reader);
   352       }
   353     };
   354 
   355 
   356     template <typename _Item, typename _Reader>
   357     class SkipReader : public MapReaderBase<_Item> {
   358     public:
   359       typedef _Reader Reader;
   360       typedef typename Reader::Value Value;
   361       typedef _Item Item;
   362 
   363       Reader reader;
   364       SkipReader(const Reader& _reader) : reader(_reader) {}
   365 
   366       virtual ~SkipReader() {}
   367 
   368       virtual void read(std::istream& is, const Item&) {
   369 	Value value;
   370 	reader.read(is, value);
   371       }      
   372 
   373       virtual MapInverterBase<Item>* getInverter() {
   374 	return new SkipReaderInverter<Item, Reader>(reader);
   375       }
   376     };
   377 
   378     template <typename _Item>
   379     class LabelReaderBase {
   380     public:
   381       typedef _Item Item;
   382       virtual ~LabelReaderBase() {}
   383       virtual Item read(std::istream& is) const = 0;
   384       virtual bool isLabelReader() const = 0;
   385       virtual LabelReaderBase<_Item>* clone() const = 0;
   386     };
   387 
   388     template <typename _Item, typename _BoxedLabelReader>
   389     class LabelReader : public LabelReaderBase<_Item> {
   390     public:
   391       typedef _Item Item;
   392       typedef _BoxedLabelReader BoxedLabelReader;
   393       
   394       const BoxedLabelReader& labelReader;
   395 
   396       LabelReader(const BoxedLabelReader& _labelReader) 
   397 	: labelReader(_labelReader) {}
   398 
   399       virtual Item read(std::istream& is) const {
   400 	Item item;
   401 	labelReader.readLabel(is, item);
   402 	return item;
   403       }
   404 
   405       virtual bool isLabelReader() const {
   406 	return labelReader.isLabelReader();
   407       }
   408       
   409       LabelReader<Item, BoxedLabelReader>* clone() const {
   410 	return new LabelReader<Item, BoxedLabelReader>(labelReader);
   411       }
   412     };
   413 
   414     template <typename _Item>
   415     class ItemStore {
   416     public:
   417 
   418       typedef _Item Item;
   419 
   420       ItemStore(Item& _item) : item(&_item) { 
   421 	_touched = false; 
   422       }
   423       
   424       void touch() { _touched = true; }
   425       bool touched() const { return _touched; }
   426 
   427       void read(const Item& _item) {
   428 	*item = _item;
   429       }
   430       
   431     private:
   432       Item* item;
   433       bool _touched;
   434     };
   435 
   436     class ValueReaderBase {
   437     public:
   438       virtual void read(std::istream&) {};
   439       ValueReaderBase() { _touched = false; }
   440 
   441       void touch() { _touched = true; }
   442       bool touched() const { return _touched; }
   443 
   444       virtual ~ValueReaderBase() {}
   445     private:
   446       bool _touched;
   447     };
   448 
   449     template <typename _Value, typename _Reader>
   450     class ValueReader : public ValueReaderBase {
   451     public:
   452       typedef _Value Value;
   453       typedef _Reader Reader;
   454 
   455       ValueReader(Value& _value, const Reader& _reader)
   456  	: value(_value), reader(_reader) {}
   457 
   458       virtual void read(std::istream& is) {
   459 	reader.read(is, value);
   460       }
   461     private:
   462       Value& value;
   463       Reader reader;
   464     };
   465 
   466   }
   467 
   468   /// \ingroup lemon_io
   469   /// \brief Lemon Format reader class.
   470   /// 
   471   /// The Lemon Format contains several sections. We do not want to
   472   /// determine what sections are in a lemon file we give only a framework
   473   /// to read a section oriented format.
   474   ///
   475   /// In the Lemon Format each section starts with a line containing a
   476   /// \c \@ character on the first not white space position. This line
   477   /// is the header line of the section. Each of the next lines belong
   478   /// to this section until a line starting with \c \@ character is
   479   /// found. This line can start a new section or it can close the
   480   /// file with the \c \@end line.  The file format ignores the empty
   481   /// and comment lines. The line is comment line if it starts with a
   482   /// \c # character.
   483   ///
   484   /// The framework provides an abstract LemonReader::SectionReader class
   485   /// that defines the interface of a SectionReader. The SectionReader
   486   /// has the \c header() member function that gets a header line string and
   487   /// decides if it wants to process the next section. Several SectionReaders
   488   /// can be attached to a LemonReader and the first attached that can
   489   /// process the section will be used. Its \c read() member will be called
   490   /// with a stream containing the section. From this stream the empty and
   491   /// comment lines are filtered out.
   492   ///
   493   /// \relates GraphReader
   494   /// \relates NodeSetReader
   495   /// \relates EdgeSetReader
   496   /// \relates NodesReader
   497   /// \relates EdgesReader
   498   /// \relates AttributeReader
   499   class LemonReader {
   500   private:
   501     
   502     class FilterStreamBuf : public std::streambuf {
   503     public:
   504 
   505       typedef std::streambuf Parent;
   506       typedef Parent::char_type char_type;
   507       FilterStreamBuf(std::istream& is, int& num) 
   508 	: _is(is), _base(0), _eptr(0), 
   509 	  _num(num), skip_state(after_endl) {}
   510 
   511     protected:
   512 
   513       enum skip_state_type {
   514 	no_skip,
   515 	after_endl,
   516 	comment_line
   517       };
   518 
   519       char_type small_buf[1];
   520 
   521 
   522       std::istream& _is;
   523 
   524       char_type* _base;
   525       char_type* _eptr;
   526 
   527       int& _num;
   528 
   529       skip_state_type skip_state;
   530 
   531 
   532       char_type* base() { return _base; }
   533 
   534       char_type* eptr() { return _eptr; }
   535 
   536       int_type blen() { return _eptr - _base; }
   537 
   538       void setb(char_type* buf, int_type len) {
   539 	_base = buf;
   540 	_eptr = buf + len;
   541       }
   542   
   543       virtual std::streambuf* setbuf(char *buf, std::streamsize len) {
   544 	if (base()) return 0;
   545 	if (buf != 0 && len >= int(sizeof(small_buf))) {
   546 	  setb(buf, len);
   547 	} else {
   548 	  setb(small_buf, sizeof(small_buf));
   549 	}
   550 	setg(0, 0, 0);
   551 	return this;
   552       }
   553 
   554       bool put_char(char c) {
   555 	switch (skip_state) {
   556 	case no_skip:
   557 	  switch (c) {
   558 	  case '\n': 
   559 	    skip_state = after_endl;
   560 	    return true;
   561 	  default:
   562 	    return true;
   563 	  }
   564 	case after_endl:
   565 	  switch (c) {
   566 	  case '@':
   567 	    return false;
   568 	  case '\n': 
   569 	    return false;
   570 	  case '#':
   571 	    skip_state = comment_line;
   572 	    return false;
   573 	  default:
   574 	    if (!isspace(c)) {
   575 	      skip_state = no_skip;
   576 	      return true;
   577 	    } else {
   578 	      return false;
   579 	    }
   580 	  }
   581 	  break;
   582 	case comment_line:
   583 	  switch (c) {
   584 	  case '\n': 
   585 	    skip_state = after_endl;
   586 	    return false;
   587 	  default:
   588 	    return false;
   589 	  }
   590 	}
   591 	return false;
   592       }
   593 
   594       virtual int_type underflow() {
   595 	char c;
   596 	if (_is.read(&c, 1)) {
   597 	  _is.putback(c);
   598 	  if (c == '@') {
   599 	    return EOF;
   600 	  }
   601 	} else {
   602 	  return EOF;
   603 	}
   604 	char_type *ptr;
   605 	for (ptr = base(); ptr != eptr(); ++ptr) {
   606 	  if (_is.read(&c, 1)) {
   607 	    if (c == '\n') ++_num;
   608 	    if (put_char(c)) {
   609 	      *ptr = c;
   610 	    } else {
   611 	      if (skip_state == after_endl && c == '@') {
   612 		_is.putback('@');
   613 		break;
   614 	      }
   615 	      --ptr;
   616 	    }
   617 	  } else {
   618 	    break;
   619 	  }
   620 	}
   621 	setg(base(), base(), ptr);
   622 	return *base();
   623       }
   624 
   625       virtual int_type sync() {
   626 	return EOF;
   627       }
   628 
   629     public:
   630 
   631       int line_num() const {
   632 	int r = _num;
   633 	for (char_type* p = gptr(); p != egptr(); ++p) {
   634 	  if (*p == '\n') --r;
   635 	}
   636 	return r;
   637       }
   638 
   639     };
   640 
   641   public:
   642 
   643     /// \brief Abstract base class for reading a section.
   644     ///
   645     /// This class has an \c header() member function what get a 
   646     /// header line string and decides if it want to process the next 
   647     /// section. Several SectionReaders can be attached to an LemonReader 
   648     /// and the first attached what can process the section will be used. 
   649     /// Its \c read() member will called with a stream contains the section. 
   650     /// From this stream the empty lines and comments are filtered out.
   651     class SectionReader {
   652       friend class LemonReader;
   653     protected:
   654       /// \brief Constructor for SectionReader.
   655       ///
   656       /// Constructor for SectionReader. It attach this reader to
   657       /// the given LemonReader.
   658       SectionReader(LemonReader& reader) {
   659 	reader.attach(*this);
   660       }
   661 
   662       virtual ~SectionReader() {}
   663 
   664       /// \brief Gives back true when the SectionReader can process 
   665       /// the section with the given header line.
   666       ///
   667       /// It gives back true when the SectionReader can process
   668       /// the section with the given header line.
   669       virtual bool header(const std::string& line) = 0;
   670 
   671       /// \brief Reader function of the section.
   672       ///
   673       /// It reads the content of the section.
   674       virtual void read(std::istream& is) = 0;
   675 
   676       /// \brief The given section missing in the file.
   677       ///
   678       /// The given section missing in the file.
   679       virtual void missing() {};
   680     };
   681 
   682     /// \brief Constructor for LemonReader.
   683     ///
   684     /// Constructor for LemonReader which reads from the given stream.
   685     LemonReader(std::istream& _is) 
   686       : is(&_is), own_is(false) {}
   687 
   688     /// \brief Constructor for LemonReader.
   689     ///
   690     /// Constructor for LemonReader which reads from the given file.
   691     LemonReader(const std::string& filename) 
   692       : is(0), own_is(true) {
   693       is = new std::ifstream(filename.c_str());
   694       if (is->fail()) {
   695 	throw FileOpenError(filename);
   696       }
   697     }
   698 
   699     /// \brief Desctructor for LemonReader.
   700     ///
   701     /// Desctructor for LemonReader.
   702     ~LemonReader() {
   703       if (own_is) {
   704 	delete is;
   705       }
   706     }
   707 
   708   private:
   709     LemonReader(const LemonReader&);
   710     void operator=(const LemonReader&);
   711 
   712     void attach(SectionReader& reader) {
   713       readers.push_back(std::make_pair(&reader, false));
   714     }
   715 
   716   public:
   717     /// \brief Executes the LemonReader.
   718     /// 
   719     /// It executes the LemonReader.
   720     void run() {
   721       int line_num = 0;
   722       std::string line;
   723       
   724       SectionReaders::iterator it;
   725       while ((++line_num, getline(*is, line)) && line.find("@end") != 0) {
   726 	for (it = readers.begin(); it != readers.end(); ++it) {
   727 	  if (it->first->header(line)) {
   728 	    it->second = true;
   729 	    char buf[2048];
   730 	    FilterStreamBuf buffer(*is, line_num);
   731 	    try {
   732 	      buffer.pubsetbuf(buf, sizeof(buf));
   733 	      std::istream ss(&buffer);
   734 	      it->first->read(ss);
   735 	      break;
   736 	    } catch (DataFormatError& error) {
   737 	      error.line(buffer.line_num());
   738 	      throw;
   739 	    }	
   740 	  }
   741 	}
   742       }
   743       for (it = readers.begin(); it != readers.end(); ++it) {
   744 	if (!it->second) {
   745 	  try {
   746 	    it->first->missing();
   747 	  } catch (DataFormatError& error) {
   748 	    error.line(line_num);
   749 	    throw;
   750 	  }	
   751 	}
   752       }
   753     }
   754 
   755 
   756   private:
   757 
   758     std::istream* is;
   759     bool own_is;
   760 
   761     typedef std::vector<std::pair<SectionReader*, bool> > SectionReaders;
   762     SectionReaders readers;
   763 
   764   };
   765 
   766   /// \ingroup section_io
   767   /// \brief SectionReader for reading a graph's nodeset.
   768   ///
   769   /// The lemon format can store multiple graph nodesets with several
   770   /// maps.  The nodeset section's header line is \c \@nodeset \c
   771   /// nodeset_name, but the \c nodeset_name may be empty.
   772   ///
   773   /// The first line of the section contains the names of the maps separated
   774   /// with white spaces. Each next lines describes a node in the nodeset, and
   775   /// contains the mapped values for each map.
   776   ///
   777   /// If the nodeset contains an \c "label" named map then it will be regarded
   778   /// as id map. This map should contain only unique values and when the 
   779   /// \c readLabel() member will read a value from the given stream it will
   780   /// give back that node which is mapped to this value.
   781   ///
   782   /// \relates LemonReader
   783   template <typename _Graph, typename _Traits = DefaultReaderTraits>
   784   class NodeSetReader : public LemonReader::SectionReader {
   785     typedef LemonReader::SectionReader Parent;
   786   public:
   787 
   788     typedef _Graph Graph;
   789     typedef _Traits Traits;
   790     typedef typename Graph::Node Node;
   791     typedef typename Traits::Skipper DefaultSkipper;
   792 
   793     /// \brief Constructor.
   794     ///
   795     /// Constructor for NodeSetReader. It creates the NodeSetReader and
   796     /// attach it into the given LemonReader. The nodeset reader will
   797     /// add the read nodes to the given Graph. The reader will read
   798     /// the section when the \c section_name and the \c _name are the same. 
   799     NodeSetReader(LemonReader& _reader, 
   800 		  Graph& _graph, 
   801 		  const std::string& _name = std::string(),
   802 		  const DefaultSkipper& _skipper = DefaultSkipper()) 
   803       : Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {} 
   804 
   805 
   806     /// \brief Destructor.
   807     ///
   808     /// Destructor for NodeSetReader.
   809     virtual ~NodeSetReader() {
   810       for (typename MapReaders::iterator it = readers.begin(); 
   811 	   it != readers.end(); ++it) {
   812 	delete it->second;
   813       }
   814     }
   815 
   816   private:
   817     NodeSetReader(const NodeSetReader&);
   818     void operator=(const NodeSetReader&);
   819   
   820   public:
   821 
   822     /// \brief Add a new node map reader command for the reader.
   823     ///
   824     /// Add a new node map reader command for the reader.
   825     template <typename Map>
   826     NodeSetReader& readNodeMap(std::string label, Map& map) {
   827       return _readMap<
   828 	typename Traits::template Reader<typename Map::Value>, Map,
   829 	typename _reader_bits::Arg<Map>::Type>(label, map);
   830     }
   831 
   832     template <typename Map>
   833     NodeSetReader& readNodeMap(std::string label, const Map& map) {
   834       return _readMap<
   835 	typename Traits::template Reader<typename Map::Value>, Map,
   836 	typename _reader_bits::Arg<Map>::Type>(label, map);
   837     }
   838 
   839     /// \brief Add a new node map reader command for the reader.
   840     ///
   841     /// Add a new node map reader command for the reader.
   842     template <typename ItemReader, typename Map>
   843     NodeSetReader& readNodeMap(std::string label, Map& map, 
   844 			       const ItemReader& ir = ItemReader()) {
   845       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
   846 	(label, map, ir);
   847     }
   848 
   849     template <typename ItemReader, typename Map>
   850     NodeSetReader& readNodeMap(std::string label, const Map& map, 
   851 			       const ItemReader& ir = ItemReader()) {
   852       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
   853 	(label, map, ir);
   854     }
   855 
   856   private:
   857 
   858     template <typename ItemReader, typename Map, typename MapParameter>
   859     NodeSetReader& _readMap(std::string label, MapParameter map, 
   860 			    const ItemReader& ir = ItemReader()) {
   861       checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
   862       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
   863       if (readers.find(label) != readers.end()) {
   864 	ErrorMessage msg;
   865 	msg << "Multiple read rule for node map: " << label;
   866 	throw IoParameterError(msg.message());
   867       }      
   868       readers.insert(
   869         make_pair(label, new _reader_bits::
   870 		  MapReader<Node, Map, ItemReader>(map, ir)));
   871       return *this;
   872     }
   873 
   874   public:
   875 
   876     /// \brief Add a new node map skipper command for the reader.
   877     ///
   878     /// Add a new node map skipper command for the reader.
   879     template <typename ItemReader>
   880     NodeSetReader& skipNodeMap(std::string label, 
   881                                const ItemReader& ir = ItemReader()) {
   882       if (readers.find(label) != readers.end()) {
   883 	ErrorMessage msg;
   884 	msg << "Multiple read rule for node map: " << label;
   885 	throw IoParameterError(msg.message());
   886       }
   887       readers.insert(make_pair(label, new _reader_bits::
   888 			       SkipReader<Node, ItemReader>(ir)));
   889       return *this;
   890     }
   891 
   892   protected:
   893 
   894     /// \brief Gives back true when the SectionReader can process 
   895     /// the section with the given header line.
   896     ///
   897     /// It gives back true when the header line starts with \c \@nodeset,
   898     /// and the header line's name and the nodeset's name are the same.
   899     virtual bool header(const std::string& line) {
   900       std::istringstream ls(line);
   901       std::string command;
   902       std::string id;
   903       ls >> command >> id;
   904       return command == "@nodeset" && name == id;
   905     }
   906 
   907     /// \brief Reader function of the section.
   908     ///
   909     /// It reads the content of the section.
   910     virtual void read(std::istream& is) {
   911       std::vector<_reader_bits::MapReaderBase<Node>* > index;
   912       std::string line;
   913 
   914       {
   915         getline(is, line);
   916         std::istringstream ls(line);
   917         std::string id;
   918         while (ls >> id) {
   919           typename MapReaders::iterator it = readers.find(id);
   920           if (it != readers.end()) {
   921             it->second->touch();
   922             index.push_back(it->second);
   923           } else {
   924             index.push_back(&skipper);
   925           }
   926           if (id == "label") {
   927             inverter.reset(index.back()->getInverter());
   928             index.back() = inverter.get();
   929           }
   930         }
   931       }
   932       for (typename MapReaders::iterator it = readers.begin();
   933 	   it != readers.end(); ++it) {
   934 	if (!it->second->touched()) {
   935 	  ErrorMessage msg;
   936 	  msg << "Map not found in file: " << it->first;
   937 	  throw IoParameterError(msg.message());
   938 	}
   939       }
   940       while (getline(is, line)) {	
   941 	Node node = graph.addNode();
   942 	std::istringstream ls(line);
   943 	for (int i = 0; i < int(index.size()); ++i) {
   944 	  index[i]->read(ls, node);
   945 	}
   946       }
   947     }
   948 
   949     virtual void missing() {
   950       if (readers.empty()) return;
   951       ErrorMessage msg;
   952       msg << "NodeSet section not found in file: @nodeset " << name;
   953       throw IoParameterError(msg.message());
   954     }
   955 
   956   public:
   957 
   958     /// \brief Returns true if the nodeset can give back the node by its label.
   959     ///
   960     /// Returns true if the nodeset can give back the node by its label.
   961     /// It is possible only if an "label" named map was read.
   962     bool isLabelReader() const {
   963       return inverter.get() != 0;
   964     }
   965 
   966     /// \brief Gives back the node by its label.
   967     ///
   968     /// It reads an id from the stream and gives back which node belongs to
   969     /// it. It is possible only if there was read an "label" named map.
   970     void readLabel(std::istream& is, Node& node) const {
   971       node = inverter->read(is);
   972     } 
   973 
   974   private:
   975 
   976     typedef std::map<std::string, _reader_bits::MapReaderBase<Node>*> MapReaders;
   977     MapReaders readers;
   978    
   979     Graph& graph;   
   980     std::string name;
   981     _reader_bits::SkipReader<Node, DefaultSkipper> skipper;
   982 
   983     std::auto_ptr<_reader_bits::MapInverterBase<Node> > inverter;
   984   };
   985 
   986   /// \ingroup section_io
   987   /// \brief SectionReader for reading a graph's edgeset.
   988   ///
   989   /// The lemon format can store multiple graph edgesets with several maps.
   990   /// The edgeset section's header line is \c \@edgeset \c edgeset_name, but the
   991   /// \c edgeset_name may be empty.
   992   ///
   993   /// The first line of the section contains the names of the maps separated
   994   /// with white spaces. Each next lines describes an edge in the edgeset. The
   995   /// line contains the source and the target nodes' id and the mapped 
   996   /// values for each map.
   997   ///
   998   /// If the edgeset contains an \c "label" named map then it will be regarded
   999   /// as id map. This map should contain only unique values and when the 
  1000   /// \c readLabel() member will read a value from the given stream it will
  1001   /// give back that edge which is mapped to this value.
  1002   ///
  1003   /// The edgeset reader needs a node id reader to identify which nodes
  1004   /// have to be connected. If a NodeSetReader reads an "label" named map,
  1005   /// it will be able to resolve the nodes by ids.
  1006   ///
  1007   /// \relates LemonReader
  1008   template <typename _Graph, typename _Traits = DefaultReaderTraits>
  1009   class EdgeSetReader : public LemonReader::SectionReader {
  1010     typedef LemonReader::SectionReader Parent;
  1011   public:
  1012 
  1013     typedef _Graph Graph;
  1014     typedef _Traits Traits;
  1015     typedef typename Graph::Node Node;
  1016     typedef typename Graph::Edge Edge;
  1017     typedef typename Traits::Skipper DefaultSkipper;
  1018 
  1019     /// \brief Constructor.
  1020     ///
  1021     /// Constructor for EdgeSetReader. It creates the EdgeSetReader and
  1022     /// attach it into the given LemonReader. The edgeset reader will
  1023     /// add the read edges to the given Graph. It will use the given
  1024     /// node id reader to read the source and target nodes of the edges.
  1025     /// The reader will read the section only if the \c _name and the 
  1026     /// \c edgset_name are the same. 
  1027     template <typename NodeLabelReader>
  1028     EdgeSetReader(LemonReader& _reader, 
  1029 		  Graph& _graph, 
  1030 		  const NodeLabelReader& _nodeLabelReader, 
  1031 		  const std::string& _name = std::string(),
  1032 		  const DefaultSkipper& _skipper = DefaultSkipper()) 
  1033       : Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {
  1034       checkConcept<_reader_bits::ItemLabelReader<Node>, NodeLabelReader>();
  1035       nodeLabelReader.reset(new _reader_bits::
  1036 			 LabelReader<Node, NodeLabelReader>(_nodeLabelReader));
  1037     }
  1038     /// \brief Destructor.
  1039     ///
  1040     /// Destructor for EdgeSetReader.
  1041     virtual ~EdgeSetReader() {
  1042       for (typename MapReaders::iterator it = readers.begin(); 
  1043 	   it != readers.end(); ++it) {
  1044 	delete it->second;
  1045       }
  1046     }
  1047 
  1048   private:
  1049     EdgeSetReader(const EdgeSetReader&);
  1050     void operator=(const EdgeSetReader&);
  1051 
  1052   public:
  1053 
  1054     /// \brief Add a new edge map reader command for the reader.
  1055     ///
  1056     /// Add a new edge map reader command for the reader.
  1057     template <typename Map>
  1058     EdgeSetReader& readEdgeMap(std::string label, Map& map) {
  1059       return _readMap<
  1060 	typename Traits::template Reader<typename Map::Value>, Map,
  1061 	typename _reader_bits::Arg<Map>::Type>(label, map);
  1062     }
  1063 
  1064     template <typename Map>
  1065     EdgeSetReader& readEdgeMap(std::string label, const Map& map) {
  1066       return _readMap<
  1067 	typename Traits::template Reader<typename Map::Value>, Map,
  1068 	typename _reader_bits::Arg<Map>::Type>(label, map);
  1069     }
  1070 
  1071     /// \brief Add a new edge map reader command for the reader.
  1072     ///
  1073     /// Add a new edge map reader command for the reader.
  1074     template <typename ItemReader, typename Map>
  1075     EdgeSetReader& readEdgeMap(std::string label, Map& map, 
  1076                                const ItemReader& ir = ItemReader()) {
  1077       return _readMap<ItemReader, Map,
  1078 	typename _reader_bits::Arg<Map>::Type>(label, map, ir);
  1079     }
  1080 
  1081     template <typename ItemReader, typename Map>
  1082     EdgeSetReader& readEdgeMap(std::string label, const Map& map, 
  1083 			       const ItemReader& ir = ItemReader()) {
  1084       return _readMap<ItemReader, Map,
  1085 	typename _reader_bits::Arg<Map>::Type>(label, map, ir);
  1086     }
  1087 
  1088   private:
  1089 
  1090     template <typename ItemReader, typename Map, typename MapParameter>
  1091     EdgeSetReader& _readMap(std::string label, MapParameter map, 
  1092 			    const ItemReader& ir = ItemReader()) {
  1093       checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
  1094       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
  1095       if (readers.find(label) != readers.end()) {
  1096 	ErrorMessage msg;
  1097 	msg << "Multiple read rule for edge map: " << label;
  1098 	throw IoParameterError(msg.message());
  1099       }
  1100       readers.insert(
  1101 	make_pair(label, new _reader_bits::
  1102 		  MapReader<Edge, Map, ItemReader>(map, ir)));
  1103       return *this;
  1104     }
  1105 
  1106   public:
  1107 
  1108     /// \brief Add a new edge map skipper command for the reader.
  1109     ///
  1110     /// Add a new edge map skipper command for the reader.
  1111     template <typename ItemReader>
  1112     EdgeSetReader& skipEdgeMap(std::string label, 
  1113 			       const ItemReader& ir = ItemReader()) {
  1114       if (readers.find(label) != readers.end()) {
  1115 	ErrorMessage msg;
  1116 	msg << "Multiple read rule for edge map: " << label;
  1117 	throw IoParameterError(msg.message());
  1118       }
  1119       readers.insert(make_pair(label, new _reader_bits::
  1120 			       SkipReader<Edge, ItemReader>(ir)));
  1121       return *this;
  1122     }
  1123 
  1124   protected:
  1125 
  1126     /// \brief Gives back true when the SectionReader can process 
  1127     /// the section with the given header line.
  1128     ///
  1129     /// It gives back true when the header line starts with \c \@edgeset,
  1130     /// and the header line's name and the edgeset's name are the same.
  1131     /// The sections with @uedgeset head line could be read with this
  1132     /// section reader too.
  1133     virtual bool header(const std::string& line) {
  1134       std::istringstream ls(line);
  1135       std::string command;
  1136       std::string id;
  1137       ls >> command >> id;
  1138       return (command == "@edgeset" || command == "@uedgeset") && name == id;
  1139     }
  1140 
  1141     /// \brief Reader function of the section.
  1142     ///
  1143     /// It reads the content of the section.
  1144     virtual void read(std::istream& is) {
  1145       if (!nodeLabelReader->isLabelReader()) {
  1146 	throw DataFormatError("Cannot find nodeset or label map");
  1147       }
  1148       std::vector<_reader_bits::MapReaderBase<Edge>* > index;
  1149       std::string line;
  1150 
  1151       {
  1152         getline(is, line);
  1153         std::istringstream ls(line);	
  1154         std::string id;
  1155         while (ls >> id) {
  1156           typename MapReaders::iterator it = readers.find(id);
  1157           if (it != readers.end()) {
  1158             index.push_back(it->second);
  1159             it->second->touch();
  1160           } else {
  1161             index.push_back(&skipper);
  1162           }
  1163           if (id == "label") {
  1164             inverter.reset(index.back()->getInverter());
  1165             index.back() = inverter.get();
  1166           }
  1167         }
  1168       }
  1169       for (typename MapReaders::iterator it = readers.begin();
  1170 	   it != readers.end(); ++it) {
  1171 	if (!it->second->touched()) {
  1172 	  ErrorMessage msg;
  1173 	  msg << "Map not found in file: " << it->first;
  1174 	  throw IoParameterError(msg.message());
  1175 	}
  1176       }
  1177       while (getline(is, line)) {	
  1178 	std::istringstream ls(line);
  1179 	Node from = nodeLabelReader->read(ls);
  1180 	Node to = nodeLabelReader->read(ls);
  1181 	Edge edge = graph.addEdge(from, to);
  1182 	for (int i = 0; i < int(index.size()); ++i) {
  1183 	  index[i]->read(ls, edge);
  1184 	}
  1185       }
  1186     }
  1187 
  1188     virtual void missing() {
  1189       if (readers.empty()) return;
  1190       ErrorMessage msg;
  1191       msg << "EdgeSet section not found in file: @edgeset " << name;
  1192       throw IoParameterError(msg.message());
  1193     }
  1194 
  1195   public:
  1196 
  1197     /// \brief Returns true if the edgeset can give back the edge by its label.
  1198     ///
  1199     /// Returns true if the edgeset can give back the edge by its label.
  1200     /// It is possible only if an "label" named map was read.
  1201     bool isLabelReader() const {
  1202       return inverter.get() != 0;
  1203     }
  1204 
  1205     /// \brief Gives back the edge by its label.
  1206     ///
  1207     /// It reads an id from the stream and gives back which edge belongs to
  1208     /// it. It is possible only if there was read an "label" named map.
  1209     void readLabel(std::istream& is, Edge& edge) const {
  1210       edge = inverter->read(is);
  1211     } 
  1212 
  1213   private:
  1214 
  1215     typedef std::map<std::string, _reader_bits::MapReaderBase<Edge>*> 
  1216     MapReaders;
  1217     
  1218     MapReaders readers;
  1219    
  1220     Graph& graph;   
  1221     std::string name;
  1222     _reader_bits::SkipReader<Edge, DefaultSkipper> skipper;
  1223 
  1224     std::auto_ptr<_reader_bits::MapInverterBase<Edge> > inverter;
  1225     std::auto_ptr<_reader_bits::LabelReaderBase<Node> > nodeLabelReader;
  1226   };
  1227 
  1228   /// \ingroup section_io
  1229   /// \brief SectionReader for reading a undirected graph's edgeset.
  1230   ///
  1231   /// The lemon format can store multiple undirected edgesets with several 
  1232   /// maps. The undirected edgeset section's header line is \c \@uedgeset 
  1233   /// \c uedgeset_name, but the \c uedgeset_name may be empty.
  1234   ///
  1235   /// The first line of the section contains the names of the maps separated
  1236   /// with white spaces. Each next lines describes an edge in the edgeset. The
  1237   /// line contains the connected nodes' id and the mapped values for each map.
  1238   ///
  1239   /// The section can handle the directed as a syntactical sugar. Two
  1240   /// undirected edge map describes one directed edge map. This two maps
  1241   /// are the forward map and the backward map and the names of this map
  1242   /// is near the same just with a prefix \c '+' or \c '-' character 
  1243   /// difference.
  1244   ///
  1245   /// If the edgeset contains an \c "label" named map then it will be regarded
  1246   /// as id map. This map should contain only unique values and when the 
  1247   /// \c readLabel() member will read a value from the given stream it will
  1248   /// give back that uicted edge which is mapped to this value.
  1249   ///
  1250   /// The undirected edgeset reader needs a node id reader to identify which 
  1251   /// nodes have to be connected. If a NodeSetReader reads an "label" named 
  1252   /// map, it will be able to resolve the nodes by ids.
  1253   ///
  1254   /// \relates LemonReader
  1255   template <typename _Graph, typename _Traits = DefaultReaderTraits>
  1256   class UEdgeSetReader : public LemonReader::SectionReader {
  1257     typedef LemonReader::SectionReader Parent;
  1258   public:
  1259 
  1260     typedef _Graph Graph;
  1261     typedef _Traits Traits;
  1262     typedef typename Graph::Node Node;
  1263     typedef typename Graph::Edge Edge;
  1264     typedef typename Graph::UEdge UEdge;
  1265     typedef typename Traits::Skipper DefaultSkipper;
  1266 
  1267     /// \brief Constructor.
  1268     ///
  1269     /// Constructor for UEdgeSetReader. It creates the UEdgeSetReader 
  1270     /// and attach it into the given LemonReader. The undirected edgeset 
  1271     /// reader will add the read undirected edges to the given Graph. It 
  1272     /// will use the given node id reader to read the source and target 
  1273     /// nodes of the edges. The reader will read the section only if the 
  1274     /// \c _name and the \c uedgset_name are the same. 
  1275     template <typename NodeLabelReader>
  1276     UEdgeSetReader(LemonReader& _reader, 
  1277 		       Graph& _graph, 
  1278 		       const NodeLabelReader& _nodeLabelReader, 
  1279 		       const std::string& _name = std::string(),
  1280 		       const DefaultSkipper& _skipper = DefaultSkipper()) 
  1281       : Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {
  1282       checkConcept<_reader_bits::ItemLabelReader<Node>, NodeLabelReader>();
  1283       nodeLabelReader.reset(new _reader_bits::
  1284 			 LabelReader<Node, NodeLabelReader>(_nodeLabelReader));
  1285     }
  1286     /// \brief Destructor.
  1287     ///
  1288     /// Destructor for UEdgeSetReader.
  1289     virtual ~UEdgeSetReader() {
  1290       for (typename MapReaders::iterator it = readers.begin(); 
  1291 	   it != readers.end(); ++it) {
  1292 	delete it->second;
  1293       }
  1294     }
  1295 
  1296   private:
  1297     UEdgeSetReader(const UEdgeSetReader&);
  1298     void operator=(const UEdgeSetReader&);
  1299 
  1300   public:
  1301 
  1302     /// \brief Add a new undirected edge map reader command for the reader.
  1303     ///
  1304     /// Add a new edge undirected map reader command for the reader.
  1305     template <typename Map>
  1306     UEdgeSetReader& readUEdgeMap(std::string label, Map& map) {
  1307       return _readMap<
  1308 	typename Traits::template Reader<typename Map::Value>, Map, 
  1309 	typename _reader_bits::Arg<Map>::Type>(label, map);
  1310     }
  1311 
  1312     template <typename Map>
  1313     UEdgeSetReader& readUEdgeMap(std::string label, const Map& map) {
  1314       return _readMap<
  1315 	typename Traits::template Reader<typename Map::Value>, Map, 
  1316 	typename _reader_bits::Arg<Map>::Type>(label, map);
  1317     }
  1318 
  1319     /// \brief Add a new undirected edge map reader command for the reader.
  1320     ///
  1321     /// Add a new edge undirected map reader command for the reader.
  1322     template <typename ItemReader, typename Map>
  1323     UEdgeSetReader& readUEdgeMap(std::string label, Map& map, 
  1324                                  const ItemReader& ir = ItemReader()) {
  1325       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
  1326 	(label, map, ir);
  1327     }
  1328 
  1329     template <typename ItemReader, typename Map>
  1330     UEdgeSetReader& readUEdgeMap(std::string label, const Map& map, 
  1331                                  const ItemReader& ir = ItemReader()) {
  1332       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type >
  1333 	(label, map, ir);
  1334     }
  1335 
  1336   private:
  1337 
  1338     template <typename ItemReader, typename Map, typename MapParameter>
  1339     UEdgeSetReader& _readMap(std::string label, MapParameter map,
  1340                              const ItemReader& ir = ItemReader()) {
  1341       checkConcept<concepts::WriteMap<UEdge, typename Map::Value>, Map>();
  1342       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
  1343       if (readers.find(label) != readers.end()) {
  1344 	ErrorMessage msg;
  1345 	msg << "Multiple read rule for edge map: " << label;
  1346 	throw IoParameterError(msg.message());
  1347       }
  1348       readers.insert(
  1349 	make_pair(label, new _reader_bits::
  1350 		  MapReader<UEdge, Map, ItemReader>(map, ir)));
  1351       return *this;
  1352     }
  1353 
  1354   public:
  1355 
  1356     /// \brief Add a new undirected edge map skipper command for the reader.
  1357     ///
  1358     /// Add a new undirected edge map skipper command for the reader.
  1359     template <typename ItemReader>
  1360     UEdgeSetReader& skipUEdgeMap(std::string label, 
  1361                                  const ItemReader& ir = ItemReader()) {
  1362       if (readers.find(label) != readers.end()) {
  1363 	ErrorMessage msg;
  1364 	msg << "Multiple read rule for node map: " << label;
  1365 	throw IoParameterError(msg.message());
  1366       }
  1367       readers.insert(make_pair(label, new _reader_bits::
  1368 			       SkipReader<UEdge, ItemReader>(ir)));
  1369       return *this;
  1370     }
  1371 
  1372     /// \brief Add a new directed edge map reader command for the reader.
  1373     ///
  1374     /// Add a new directed edge map reader command for the reader.
  1375     template <typename Map>
  1376     UEdgeSetReader& readEdgeMap(std::string label, Map& map) {
  1377       return _readDirMap<
  1378 	typename Traits::template Reader<typename Map::Value>, Map,
  1379 	typename _reader_bits::Arg<Map>::Type>(label, map);
  1380     }
  1381 
  1382     template <typename Map>
  1383     UEdgeSetReader& readEdgeMap(std::string label, const Map& map) {
  1384       return _readDirMap<
  1385 	typename Traits::template Reader<typename Map::Value>, Map,
  1386 	typename _reader_bits::Arg<Map>::Type>(label, map);
  1387     }
  1388 
  1389     /// \brief Add a new directed edge map reader command for the reader.
  1390     ///
  1391     /// Add a new directed edge map reader command for the reader.
  1392     template <typename ItemReader, typename Map>
  1393     UEdgeSetReader& readEdgeMap(std::string label, Map& map, 
  1394 				    const ItemReader& ir = ItemReader()) {
  1395       return _readDirMap<ItemReader, Map, 
  1396         typename _reader_bits::Arg<Map>::Type>(label, map, ir);
  1397     }
  1398 
  1399     template <typename ItemReader, typename Map>
  1400     UEdgeSetReader& readEdgeMap(std::string label, const Map& map, 
  1401 				    const ItemReader& ir = ItemReader()) {
  1402       return _readDirMap<ItemReader, Map, 
  1403         typename _reader_bits::Arg<Map>::Type>(label, map, ir);
  1404     }
  1405 
  1406   private:
  1407 
  1408     template <typename ItemReader, typename Map, typename MapParameter>
  1409     UEdgeSetReader& _readDirMap(std::string label, MapParameter map,
  1410 				    const ItemReader& ir = ItemReader()) { 
  1411       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
  1412       checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
  1413       readUEdgeMap("+" + label, 
  1414                    _reader_bits::forwardComposeMap(graph, map), ir);
  1415       readUEdgeMap("-" + label, 
  1416                    _reader_bits::backwardComposeMap(graph, map), ir);
  1417       return *this;      
  1418     }
  1419 
  1420   public:
  1421 
  1422     /// \brief Add a new directed edge map skipper command for the reader.
  1423     ///
  1424     /// Add a new directed edge map skipper command for the reader.
  1425     template <typename ItemReader>
  1426     UEdgeSetReader& skipEdgeMap(std::string label, 
  1427                                 const ItemReader& ir = ItemReader()) {
  1428       skipUEdgeMap("+" + label, ir);
  1429       skipUEdgeMap("-" + label, ir);
  1430       return *this;
  1431     }
  1432 
  1433   protected:
  1434 
  1435     /// \brief Gives back true when the SectionReader can process 
  1436     /// the section with the given header line.
  1437     ///
  1438     /// It gives back true when the header line starts with \c \@uedgeset,
  1439     /// and the header line's name and the edgeset's name are the same.
  1440     /// The sections with @edgeset head line could be read with this
  1441     /// section reader too.
  1442     virtual bool header(const std::string& line) {
  1443       std::istringstream ls(line);
  1444       std::string command;
  1445       std::string id;
  1446       ls >> command >> id;
  1447       return (command == "@edgeset" || command == "@uedgeset") && name == id;
  1448     }
  1449 
  1450     /// \brief Reader function of the section.
  1451     ///
  1452     /// It reads the content of the section.
  1453     virtual void read(std::istream& is) {
  1454       if (!nodeLabelReader->isLabelReader()) {
  1455 	throw DataFormatError("Cannot find nodeset or label map");
  1456       }
  1457       std::vector<_reader_bits::MapReaderBase<UEdge>* > index;
  1458       std::string line;
  1459 
  1460       {
  1461         getline(is, line);
  1462         std::istringstream ls(line);	
  1463         std::string id;
  1464         while (ls >> id) {
  1465           typename MapReaders::iterator it = readers.find(id);
  1466           if (it != readers.end()) {
  1467             index.push_back(it->second);
  1468             it->second->touch();
  1469           } else {
  1470             index.push_back(&skipper);
  1471           }
  1472           if (id == "label") {
  1473             inverter.reset(index.back()->getInverter());
  1474             index.back() = inverter.get();
  1475           }
  1476         }
  1477         for (typename MapReaders::iterator it = readers.begin();
  1478              it != readers.end(); ++it) {
  1479           if (!it->second->touched()) {
  1480             ErrorMessage msg;
  1481             msg << "Map not found in file: " << it->first;
  1482             throw IoParameterError(msg.message());
  1483           }
  1484         }
  1485       }
  1486       while (getline(is, line)) {	
  1487 	std::istringstream ls(line);
  1488 	Node from = nodeLabelReader->read(ls);
  1489 	Node to = nodeLabelReader->read(ls);
  1490 	UEdge edge = graph.addEdge(from, to);
  1491 	for (int i = 0; i < int(index.size()); ++i) {
  1492 	  index[i]->read(ls, edge);
  1493 	}
  1494       }
  1495     }
  1496 
  1497     virtual void missing() {
  1498       if (readers.empty()) return;
  1499       ErrorMessage msg;
  1500       msg << "UEdgeSet section not found in file: @uedgeset " << name;
  1501       throw IoParameterError(msg.message());
  1502     }
  1503 
  1504   public:
  1505 
  1506     /// \brief Returns true if the edgeset can give back the edge by its label.
  1507     ///
  1508     /// Returns true if the edgeset can give back the undirected edge by its 
  1509     /// id. It is possible only if an "label" named map was read.
  1510     bool isLabelReader() const {
  1511       return inverter.get() != 0;
  1512     }
  1513 
  1514     /// \brief Gives back the undirected edge by its label.
  1515     ///
  1516     /// It reads an id from the stream and gives back which undirected edge 
  1517     /// belongs to it. It is possible only if there was read an "label" named map.
  1518     void readLabel(std::istream& is, UEdge& uedge) const {
  1519       uedge = inverter->read(is);
  1520     } 
  1521 
  1522     /// \brief Gives back the directed edge by its label.
  1523     ///
  1524     /// It reads an id from the stream and gives back which directed edge 
  1525     /// belongs to it. The directed edge id is the \c '+' or \c '-' character
  1526     /// and the undirected edge id. It is possible only if there was read 
  1527     /// an "label" named map.
  1528     void readLabel(std::istream& is, Edge& edge) const {
  1529       char c;
  1530       is >> c;
  1531       UEdge uedge = inverter->read(is);
  1532       if (c == '+') {
  1533 	edge = graph.direct(uedge, true);
  1534       } else if (c == '-') {
  1535         edge = graph.direct(uedge, false);
  1536       } else {
  1537 	throw DataFormatError("Wrong id format for edge "
  1538 			      "in undirected edgeset");
  1539       }
  1540     } 
  1541 
  1542   private:
  1543 
  1544     typedef std::map<std::string, 
  1545 		     _reader_bits::MapReaderBase<UEdge>*> MapReaders;
  1546     MapReaders readers;
  1547    
  1548     Graph& graph;   
  1549     std::string name;
  1550     _reader_bits::SkipReader<UEdge, DefaultSkipper> skipper;
  1551 
  1552     std::auto_ptr<_reader_bits::MapInverterBase<UEdge> > inverter;
  1553     std::auto_ptr<_reader_bits::LabelReaderBase<Node> > nodeLabelReader;
  1554   };
  1555 
  1556   /// \ingroup section_io
  1557   /// \brief SectionReader for reading labeled nodes.
  1558   ///
  1559   /// The nodes section's header line is \c \@nodes \c nodes_name, but the
  1560   /// \c nodes_name may be empty.
  1561   ///
  1562   /// Each line in the section contains the name of the node 
  1563   /// and then the node id. 
  1564   ///
  1565   /// \relates LemonReader
  1566   template <typename _Graph>
  1567   class NodeReader : public LemonReader::SectionReader {
  1568     typedef LemonReader::SectionReader Parent;
  1569     typedef _Graph Graph;
  1570     typedef typename Graph::Node Node;
  1571   public:
  1572     
  1573     /// \brief Constructor.
  1574     ///
  1575     /// Constructor for NodeReader. It creates the NodeReader and
  1576     /// attach it into the given LemonReader. It will use the given
  1577     /// node id reader to give back the nodes. The reader will read the 
  1578     /// section only if the \c _name and the \c nodes_name are the same. 
  1579     template <typename _LabelReader>
  1580     NodeReader(LemonReader& _reader, const _LabelReader& _labelReader, 
  1581 	       const std::string& _name = std::string()) 
  1582       : Parent(_reader), name(_name) {
  1583       checkConcept<_reader_bits::ItemLabelReader<Node>, _LabelReader>();
  1584       nodeLabelReader.reset(new _reader_bits::
  1585 			 LabelReader<Node, _LabelReader>(_labelReader));
  1586     }
  1587 
  1588     /// \brief Destructor.
  1589     ///
  1590     /// Destructor for NodeReader.
  1591     virtual ~NodeReader() {}
  1592 
  1593   private:
  1594     NodeReader(const NodeReader&);
  1595     void operator=(const NodeReader&);
  1596 
  1597   public:
  1598 
  1599     /// \brief Add a node reader command for the NodeReader.
  1600     ///
  1601     /// Add a node reader command for the NodeReader.
  1602     void readNode(std::string label, Node& item) {
  1603       if (readers.find(label) != readers.end()) {
  1604 	ErrorMessage msg;
  1605 	msg << "Multiple read rule for node: " << label;
  1606 	throw IoParameterError(msg.message());
  1607       }
  1608       readers.insert(make_pair(label, _reader_bits::ItemStore<Node>(item)));
  1609     }
  1610 
  1611   protected:
  1612 
  1613     /// \brief Gives back true when the SectionReader can process 
  1614     /// the section with the given header line.
  1615     ///
  1616     /// It gives back true when the header line start with \c \@nodes,
  1617     /// and the header line's name and the reader's name are the same.
  1618     virtual bool header(const std::string& line) {
  1619       std::istringstream ls(line);
  1620       std::string command;
  1621       std::string id;
  1622       ls >> command >> id;
  1623       return command == "@nodes" && name == id;
  1624     }
  1625 
  1626     /// \brief Reader function of the section.
  1627     ///
  1628     /// It reads the content of the section.
  1629     virtual void read(std::istream& is) {
  1630       if (!nodeLabelReader->isLabelReader()) {
  1631 	throw DataFormatError("Cannot find nodeset or label map");
  1632       }
  1633       std::string line;
  1634       while (getline(is, line)) {
  1635 	std::istringstream ls(line);
  1636 	std::string id;
  1637 	ls >> id;
  1638 	typename NodeReaders::iterator it = readers.find(id);
  1639 	if (it != readers.end()) {
  1640 	  it->second.read(nodeLabelReader->read(ls));
  1641 	  it->second.touch();
  1642 	}	
  1643       }
  1644       for (typename NodeReaders::iterator it = readers.begin();
  1645 	   it != readers.end(); ++it) {
  1646 	if (!it->second.touched()) {
  1647 	  ErrorMessage msg;
  1648 	  msg << "Node not found in file: " << it->first;
  1649 	  throw IoParameterError(msg.message());
  1650 	}
  1651       }
  1652     }
  1653 
  1654     virtual void missing() {
  1655       if (readers.empty()) return;
  1656       ErrorMessage msg;
  1657       msg << "Nodes section not found in file: @nodes " << name;
  1658       throw IoParameterError(msg.message());
  1659     }
  1660     
  1661   private:
  1662 
  1663     std::string name;
  1664 
  1665     typedef std::map<std::string, _reader_bits::ItemStore<Node> > NodeReaders;
  1666     NodeReaders readers;
  1667     std::auto_ptr<_reader_bits::LabelReaderBase<Node> > nodeLabelReader;
  1668   };
  1669 
  1670   /// \ingroup section_io
  1671   /// \brief SectionReader for reading labeled edges.
  1672   ///
  1673   /// The edges section's header line is \c \@edges \c edges_name, but the
  1674   /// \c edges_name may be empty.
  1675   ///
  1676   /// Each line in the section contains the name of the edge 
  1677   /// and then the edge id. 
  1678   ///
  1679   /// \relates LemonReader
  1680   template <typename _Graph>
  1681   class EdgeReader : public LemonReader::SectionReader {
  1682     typedef LemonReader::SectionReader Parent;
  1683     typedef _Graph Graph;
  1684     typedef typename Graph::Edge Edge;
  1685   public:
  1686     
  1687     /// \brief Constructor.
  1688     ///
  1689     /// Constructor for EdgeReader. It creates the EdgeReader and
  1690     /// attach it into the given LemonReader. It will use the given
  1691     /// edge id reader to give back the edges. The reader will read the 
  1692     /// section only if the \c _name and the \c edges_name are the same. 
  1693     template <typename _LabelReader>
  1694     EdgeReader(LemonReader& _reader, const _LabelReader& _labelReader, 
  1695 	       const std::string& _name = std::string()) 
  1696       : Parent(_reader), name(_name) {
  1697       checkConcept<_reader_bits::ItemLabelReader<Edge>, _LabelReader>();
  1698       edgeLabelReader.reset(new _reader_bits::
  1699 			 LabelReader<Edge, _LabelReader>(_labelReader));
  1700     }
  1701 
  1702     /// \brief Destructor.
  1703     ///
  1704     /// Destructor for EdgeReader.
  1705     virtual ~EdgeReader() {}
  1706   private:
  1707     EdgeReader(const EdgeReader&);
  1708     void operator=(const EdgeReader&);
  1709 
  1710   public:
  1711 
  1712     /// \brief Add an edge reader command for the EdgeReader.
  1713     ///
  1714     /// Add an edge reader command for the EdgeReader.
  1715     void readEdge(std::string label, Edge& item) {
  1716       if (readers.find(label) != readers.end()) {
  1717 	ErrorMessage msg;
  1718 	msg << "Multiple read rule for edge: " << label;
  1719 	throw IoParameterError(msg.message());
  1720       }
  1721       readers.insert(make_pair(label, _reader_bits::ItemStore<Edge>(item)));
  1722     }
  1723 
  1724   protected:
  1725 
  1726     /// \brief Gives back true when the SectionReader can process 
  1727     /// the section with the given header line.
  1728     ///
  1729     /// It gives back true when the header line start with \c \@edges,
  1730     /// and the header line's name and the reader's name are the same.
  1731     virtual bool header(const std::string& line) {
  1732       std::istringstream ls(line);
  1733       std::string command;
  1734       std::string id;
  1735       ls >> command >> id;
  1736       return command == "@edges" && name == id;
  1737     }
  1738 
  1739     /// \brief Reader function of the section.
  1740     ///
  1741     /// It reads the content of the section.
  1742     virtual void read(std::istream& is) {
  1743       if (!edgeLabelReader->isLabelReader()) {
  1744 	throw DataFormatError("Cannot find edgeset or label map");
  1745       }
  1746       std::string line;
  1747       while (getline(is, line)) {
  1748 	std::istringstream ls(line);
  1749 	std::string id;
  1750 	ls >> id;
  1751 	typename EdgeReaders::iterator it = readers.find(id);
  1752 	if (it != readers.end()) {
  1753 	  it->second.read(edgeLabelReader->read(ls));
  1754 	  it->second.touch();
  1755 	}	
  1756       }
  1757       for (typename EdgeReaders::iterator it = readers.begin();
  1758 	   it != readers.end(); ++it) {
  1759 	if (!it->second.touched()) {
  1760 	  ErrorMessage msg;
  1761 	  msg << "Edge not found in file: " << it->first;
  1762 	  throw IoParameterError(msg.message());
  1763 	}
  1764       }
  1765     }
  1766 
  1767     virtual void missing() {
  1768       if (readers.empty()) return;
  1769       ErrorMessage msg;
  1770       msg << "Edges section not found in file: @edges " << name;
  1771       throw IoParameterError(msg.message());
  1772     }
  1773     
  1774   private:
  1775 
  1776     std::string name;
  1777 
  1778     typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders;
  1779     EdgeReaders readers;
  1780     std::auto_ptr<_reader_bits::LabelReaderBase<Edge> > edgeLabelReader;
  1781   };
  1782 
  1783   /// \ingroup section_io
  1784   /// \brief SectionReader for reading labeled undirected edges.
  1785   ///
  1786   /// The undirected edges section's header line is \c \@uedges 
  1787   /// \c uedges_name, but the \c uedges_name may be empty.
  1788   ///
  1789   /// Each line in the section contains the name of the undirected edge 
  1790   /// and then the undirected edge id. 
  1791   ///
  1792   /// \relates LemonReader
  1793   template <typename _Graph>
  1794   class UEdgeReader : public LemonReader::SectionReader {
  1795     typedef LemonReader::SectionReader Parent;
  1796     typedef _Graph Graph;
  1797     typedef typename Graph::Edge Edge;
  1798     typedef typename Graph::UEdge UEdge;
  1799   public:
  1800     
  1801     /// \brief Constructor.
  1802     ///
  1803     /// Constructor for UEdgeReader. It creates the UEdgeReader and
  1804     /// attach it into the given LemonReader. It will use the given
  1805     /// undirected edge id reader to give back the edges. The reader will 
  1806     /// read the section only if the \c _name and the \c uedges_name are 
  1807     /// the same. 
  1808     template <typename _LabelReader>
  1809     UEdgeReader(LemonReader& _reader, const _LabelReader& _labelReader, 
  1810 	       const std::string& _name = std::string()) 
  1811       : Parent(_reader), name(_name) {
  1812       checkConcept<_reader_bits::ItemLabelReader<UEdge>, _LabelReader>();
  1813       checkConcept<_reader_bits::ItemLabelReader<Edge>, _LabelReader>();
  1814       uedgeLabelReader.reset(new _reader_bits::
  1815 			     LabelReader<UEdge, _LabelReader>(_labelReader));
  1816       edgeLabelReader.reset(new _reader_bits::
  1817 			    LabelReader<Edge, _LabelReader>(_labelReader));
  1818     }
  1819 
  1820     /// \brief Destructor.
  1821     ///
  1822     /// Destructor for UEdgeReader.
  1823     virtual ~UEdgeReader() {}
  1824   private:
  1825     UEdgeReader(const UEdgeReader&);
  1826     void operator=(const UEdgeReader&);
  1827 
  1828   public:
  1829 
  1830     /// \brief Add an undirected edge reader command for the UEdgeReader.
  1831     ///
  1832     /// Add an undirected edge reader command for the UEdgeReader.
  1833     void readUEdge(std::string label, UEdge& item) {
  1834       if (uedgeReaders.find(label) != uedgeReaders.end()) {
  1835 	ErrorMessage msg;
  1836 	msg << "Multiple read rule for undirected edge: " << label;
  1837 	throw IoParameterError(msg.message());
  1838       }
  1839       uedgeReaders.insert(make_pair(label, _reader_bits::
  1840 					ItemStore<UEdge>(item)));
  1841     }
  1842 
  1843     /// \brief Add an edge reader command for the UEdgeReader.
  1844     ///
  1845     /// Add an edge reader command for the UEdgeReader.
  1846     void readEdge(std::string label, Edge& item) {
  1847       if (edgeReaders.find(label) != edgeReaders.end()) {
  1848 	ErrorMessage msg;
  1849 	msg << "Multiple read rule for edge: " << label;
  1850 	throw IoParameterError(msg.message());
  1851       }
  1852       edgeReaders.insert(make_pair(label, _reader_bits::ItemStore<Edge>(item)));
  1853     }
  1854 
  1855   protected:
  1856 
  1857     /// \brief Gives back true when the SectionReader can process 
  1858     /// the section with the given header line.
  1859     ///
  1860     /// It gives back true when the header line start with \c \@edges,
  1861     /// and the header line's name and the reader's name are the same.
  1862     virtual bool header(const std::string& line) {
  1863       std::istringstream ls(line);
  1864       std::string command;
  1865       std::string id;
  1866       ls >> command >> id;
  1867       return command == "@uedges" && name == id;
  1868     }
  1869 
  1870     /// \brief Reader function of the section.
  1871     ///
  1872     /// It reads the content of the section.
  1873     virtual void read(std::istream& is) {
  1874       if (!edgeLabelReader->isLabelReader()) {
  1875 	throw DataFormatError("Cannot find undirected edgeset or label map");
  1876       }
  1877       if (!uedgeLabelReader->isLabelReader()) {
  1878 	throw DataFormatError("Cannot find undirected edgeset or label map");
  1879       }
  1880       std::string line;
  1881       while (getline(is, line)) {
  1882 	std::istringstream ls(line);
  1883 	std::string id;
  1884 	ls >> id;
  1885 	{
  1886 	  typename UEdgeReaders::iterator it = uedgeReaders.find(id);
  1887 	  if (it != uedgeReaders.end()) {
  1888 	    it->second.read(uedgeLabelReader->read(ls));
  1889 	    it->second.touch();
  1890 	    continue;
  1891 	  }	
  1892 	} {
  1893 	  typename EdgeReaders::iterator it = edgeReaders.find(id);
  1894 	  if (it != edgeReaders.end()) {
  1895 	    it->second.read(edgeLabelReader->read(ls));
  1896 	    it->second.touch();
  1897 	    continue;
  1898 	  }	
  1899 	}
  1900       }
  1901       for (typename EdgeReaders::iterator it = edgeReaders.begin();
  1902 	   it != edgeReaders.end(); ++it) {
  1903 	if (!it->second.touched()) {
  1904 	  ErrorMessage msg;
  1905 	  msg << "Edge not found in file: " << it->first;
  1906 	  throw IoParameterError(msg.message());
  1907 	}
  1908       }
  1909       for (typename UEdgeReaders::iterator it = uedgeReaders.begin();
  1910 	   it != uedgeReaders.end(); ++it) {
  1911 	if (!it->second.touched()) {
  1912 	  ErrorMessage msg;
  1913 	  msg << "UEdge not found in file: " << it->first;
  1914 	  throw IoParameterError(msg.message());
  1915 	}
  1916       }
  1917     }
  1918 
  1919     virtual void missing() {
  1920       if (edgeReaders.empty() && uedgeReaders.empty()) return;
  1921       ErrorMessage msg;
  1922       msg << "UEdges section not found in file: @uedges " << name;
  1923       throw IoParameterError(msg.message());
  1924     }
  1925     
  1926   private:
  1927 
  1928     std::string name;
  1929 
  1930     typedef std::map<std::string, 
  1931 		     _reader_bits::ItemStore<UEdge> > UEdgeReaders;
  1932     UEdgeReaders uedgeReaders;
  1933     std::auto_ptr<_reader_bits::LabelReaderBase<UEdge> > uedgeLabelReader;
  1934 
  1935     typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders;
  1936     EdgeReaders edgeReaders;
  1937     std::auto_ptr<_reader_bits::LabelReaderBase<Edge> > edgeLabelReader;
  1938   };
  1939 
  1940   /// \ingroup section_io
  1941   /// \brief SectionReader for attributes.
  1942   ///
  1943   /// The lemon format can store multiple attribute set. Each set has
  1944   /// the header line \c \@attributes \c attributeset_name, but the 
  1945   /// attributeset_name may be empty.
  1946   ///
  1947   /// The attributeset section contains several lines. Each of them starts
  1948   /// with an attribute and then a the value for the id.
  1949   ///
  1950   /// \relates LemonReader
  1951   template <typename _Traits = DefaultReaderTraits>
  1952   class AttributeReader : public LemonReader::SectionReader {
  1953     typedef LemonReader::SectionReader Parent;
  1954     typedef _Traits Traits; 
  1955   public:
  1956     /// \brief Constructor.
  1957     ///
  1958     /// Constructor for AttributeReader. It creates the AttributeReader and
  1959     /// attach it into the given LemonReader. The reader process a section
  1960     /// only if the \c section_name and the \c _name are the same.
  1961     AttributeReader(LemonReader& _reader, 
  1962 		    const std::string& _name = std::string()) 
  1963       : Parent(_reader), name(_name) {}
  1964 
  1965     /// \brief Destructor.
  1966     ///
  1967     /// Destructor for AttributeReader.
  1968     virtual ~AttributeReader() {
  1969       for (typename Readers::iterator it = readers.begin(); 
  1970 	   it != readers.end(); ++it) {
  1971 	delete it->second;
  1972       }
  1973     }
  1974 
  1975   private:
  1976     AttributeReader(const AttributeReader&);
  1977     void operator=(AttributeReader&);
  1978 
  1979   public:
  1980     /// \brief Add an attribute reader command for the reader.
  1981     ///
  1982     /// Add an attribute reader command for the reader.
  1983     template <typename Value>
  1984     AttributeReader& readAttribute(const std::string& label, Value& value) {
  1985       return readAttribute<typename Traits::template Reader<Value> >
  1986 	(label, value);
  1987     }
  1988 
  1989     /// \brief Add an attribute reader command for the reader.
  1990     ///
  1991     /// Add an attribute reader command for the reader.
  1992     template <typename ItemReader, typename Value>
  1993     AttributeReader& readAttribute(const std::string& label, Value& value,
  1994 				   const ItemReader& ir = ItemReader()) {
  1995       checkConcept<_reader_bits::ItemReader<Value>, ItemReader>();
  1996       if (readers.find(label) != readers.end()) {
  1997 	ErrorMessage msg;
  1998 	msg << "Multiple read rule for attribute: " << label;
  1999 	throw IoParameterError(msg.message());
  2000       }
  2001       readers.insert(make_pair(label, new _reader_bits::
  2002 			       ValueReader<Value, ItemReader>(value, ir)));
  2003       return *this;
  2004     }
  2005 
  2006   protected:
  2007 
  2008     /// \brief Gives back true when the SectionReader can process 
  2009     /// the section with the given header line.
  2010     ///
  2011     /// It gives back true when the header line start with \c \@attributes,
  2012     /// and the header line's id and the attributeset's id are the same.
  2013     bool header(const std::string& line) {
  2014       std::istringstream ls(line);
  2015       std::string command;
  2016       std::string id;
  2017       ls >> command >> id;
  2018       return command == "@attributes" && name == id;
  2019     }
  2020 
  2021     /// \brief Reader function of the section.
  2022     ///
  2023     /// It reads the content of the section.
  2024     void read(std::istream& is) {
  2025       std::string line;
  2026       while (getline(is, line)) {
  2027 	std::istringstream ls(line);
  2028 	std::string id;
  2029 	ls >> id;
  2030 	typename Readers::iterator it = readers.find(id);
  2031 	if (it != readers.end()) {
  2032 	  it->second->read(ls);
  2033  	  it->second->touch();
  2034 	}
  2035       }
  2036       for (typename Readers::iterator it = readers.begin();
  2037 	   it != readers.end(); ++it) {
  2038 	if (!it->second->touched()) {
  2039 	  ErrorMessage msg;
  2040 	  msg << "Attribute not found in file: " << it->first;
  2041 	  throw IoParameterError(msg.message());
  2042 	}	
  2043       }
  2044     }    
  2045     
  2046     virtual void missing() {
  2047       if (readers.empty()) return;
  2048       ErrorMessage msg;
  2049       msg << "Attribute section not found in file: @attributes " << name;
  2050       throw IoParameterError(msg.message());
  2051     }
  2052 
  2053   private:
  2054     std::string name;
  2055 
  2056     typedef std::map<std::string, _reader_bits::ValueReaderBase*> Readers;
  2057     Readers readers;  
  2058   };
  2059 
  2060   /// \ingroup section_io
  2061   /// \brief SectionReader for reading extra node maps.
  2062   ///
  2063   /// The lemon format can store maps in the nodeset sections. This
  2064   /// class let you make distinict section to store maps.  The main
  2065   /// purpose of this class is a logical separation of some maps. The
  2066   /// other useful application could be to store paths in node maps.
  2067   ///
  2068   /// The first line of the section contains the names of the maps
  2069   /// separated with white spaces. Each next line describes an item
  2070   /// in the itemset, and contains in the first column the label of
  2071   /// the item and then the mapped values for each map.
  2072   ///
  2073   /// \relates LemonReader
  2074   template <typename _Graph, typename _Traits = DefaultReaderTraits>
  2075   class NodeMapReader : public LemonReader::SectionReader {
  2076     typedef LemonReader::SectionReader Parent;
  2077   public:
  2078 
  2079     typedef _Graph Graph;
  2080     typedef typename Graph::Node Node;
  2081     typedef _Traits Traits;
  2082     typedef typename Traits::Skipper DefaultSkipper;
  2083 
  2084     /// \brief Constructor.
  2085     ///
  2086     /// Constructor for NodeMapReader. It creates the NodeMapReader and
  2087     /// attach it into the given LemonReader. The reader will read
  2088     /// the section when the \c section_name and the \c _name are the same.
  2089     template <typename _LabelReader>
  2090     NodeMapReader(LemonReader& _reader, 
  2091 		  const Graph& _graph, 
  2092 		  const _LabelReader& _labelReader,
  2093 		  const std::string& _name = std::string(),
  2094 		  const DefaultSkipper& _skipper = DefaultSkipper()) 
  2095       : Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {
  2096       labelReader.reset(new _reader_bits::
  2097 			LabelReader<Node, _LabelReader>(_labelReader));
  2098     } 
  2099 
  2100 
  2101     /// \brief Destructor.
  2102     ///
  2103     /// Destructor for NodeMapReader.
  2104     virtual ~NodeMapReader() {
  2105       for (typename MapReaders::iterator it = readers.begin(); 
  2106 	   it != readers.end(); ++it) {
  2107 	delete it->second;
  2108       }
  2109     }
  2110 
  2111   private:
  2112     NodeMapReader(const NodeMapReader&);
  2113     void operator=(const NodeMapReader&);
  2114   
  2115   public:
  2116 
  2117     /// \brief Add a new node map reader command for the reader.
  2118     ///
  2119     /// Add a new node map reader command for the reader.
  2120     template <typename Map>
  2121     NodeMapReader& readNodeMap(std::string label, Map& map) {
  2122       return _readMap<
  2123 	typename Traits::template Reader<typename Map::Value>, Map,
  2124 	typename _reader_bits::Arg<Map>::Type>(label, map);
  2125     }
  2126 
  2127     template <typename Map>
  2128     NodeMapReader& readNodeMap(std::string label, const Map& map) {
  2129       return _readMap<
  2130 	typename Traits::template Reader<typename Map::Value>, Map,
  2131 	typename _reader_bits::Arg<Map>::Type>(label, map);
  2132     }
  2133 
  2134     /// \brief Add a new node map reader command for the reader.
  2135     ///
  2136     /// Add a new node map reader command for the reader.
  2137     template <typename ItemReader, typename Map>
  2138     NodeMapReader& readNodeMap(std::string label, Map& map, 
  2139 			       const ItemReader& ir = ItemReader()) {
  2140       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
  2141 	(label, map, ir);
  2142     }
  2143 
  2144     template <typename ItemReader, typename Map>
  2145     NodeMapReader& readNodeMap(std::string label, const Map& map, 
  2146 			       const ItemReader& ir = ItemReader()) {
  2147       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
  2148 	(label, map, ir);
  2149     }
  2150 
  2151   private:
  2152 
  2153     template <typename ItemReader, typename Map, typename MapParameter>
  2154     NodeMapReader& _readMap(std::string label, MapParameter map, 
  2155 			   const ItemReader& ir = ItemReader()) {
  2156       checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
  2157       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
  2158       if (readers.find(label) != readers.end()) {
  2159 	ErrorMessage msg;
  2160 	msg << "Multiple read rule for map: " << label;
  2161 	throw IoParameterError(msg.message());
  2162       }      
  2163       readers.insert(
  2164 	make_pair(label, new _reader_bits::
  2165 		  MapReader<Node, Map, ItemReader>(map, ir)));
  2166       return *this;
  2167     }
  2168 
  2169   public:
  2170 
  2171     /// \brief Add a new node map skipper command for the reader.
  2172     ///
  2173     /// Add a new node map skipper command for the reader.
  2174     template <typename ItemReader>
  2175     NodeMapReader& skipNodeMap(std::string label, 
  2176 			       const ItemReader& ir = ItemReader()) {
  2177       if (readers.find(label) != readers.end()) {
  2178 	ErrorMessage msg;
  2179 	msg << "Multiple read rule for map: " << label;
  2180 	throw IoParameterError(msg.message());
  2181       }
  2182       readers.insert(make_pair(label, new _reader_bits::
  2183 			       SkipReader<Node, ItemReader>(ir)));
  2184       return *this;
  2185     }
  2186 
  2187   protected:
  2188 
  2189     /// \brief Gives back true when the SectionReader can process 
  2190     /// the section with the given header line.
  2191     ///
  2192     /// It gives back true when the header line starts with \c \@mapset,
  2193     /// and the header line's name and the mapset's name are the same.
  2194     virtual bool header(const std::string& line) {
  2195       std::istringstream ls(line);
  2196       std::string command;
  2197       std::string id;
  2198       ls >> command >> id;
  2199       return command == "@nodemaps" && name == id;
  2200     }
  2201 
  2202     /// \brief Reader function of the section.
  2203     ///
  2204     /// It reads the content of the section.
  2205     virtual void read(std::istream& is) {
  2206       std::vector<_reader_bits::MapReaderBase<Node>* > index;
  2207       std::string line;
  2208 
  2209       {
  2210         getline(is, line);
  2211         std::istringstream ls(line);
  2212         std::string id;
  2213         while (ls >> id) {
  2214           typename MapReaders::iterator it = readers.find(id);
  2215           if (it != readers.end()) {
  2216             it->second->touch();
  2217             index.push_back(it->second);
  2218           } else {
  2219             index.push_back(&skipper);
  2220           }
  2221         }
  2222       }
  2223       for (typename MapReaders::iterator it = readers.begin();
  2224 	   it != readers.end(); ++it) {
  2225 	if (!it->second->touched()) {
  2226 	  ErrorMessage msg;
  2227 	  msg << "Map not found in file: " << it->first;
  2228 	  throw IoParameterError(msg.message());
  2229 	}
  2230       }
  2231       while (getline(is, line)) {	
  2232 	std::istringstream ls(line);
  2233 	Node node = labelReader->read(ls);
  2234 	for (int i = 0; i < int(index.size()); ++i) {
  2235 	  index[i]->read(ls, node);
  2236 	}
  2237       }
  2238     }
  2239 
  2240     virtual void missing() {
  2241       if (readers.empty()) return;
  2242       ErrorMessage msg;
  2243       msg << "NodeMap section not found in file: @nodemaps " << name;
  2244       throw IoParameterError(msg.message());
  2245     }
  2246 
  2247   private:
  2248 
  2249     typedef std::map<std::string, _reader_bits::MapReaderBase<Node>*> MapReaders;
  2250     MapReaders readers;
  2251    
  2252     const Graph& graph;   
  2253     std::string name;
  2254     _reader_bits::SkipReader<Node, DefaultSkipper> skipper;
  2255     std::auto_ptr<_reader_bits::LabelReaderBase<Node> > labelReader;
  2256 
  2257   };
  2258 
  2259   /// \ingroup section_io
  2260   /// \brief SectionReader for reading extra edge maps.
  2261   ///
  2262   /// The lemon format can store maps in the edgeset sections. This
  2263   /// class let you make distinict section to store maps.  The main
  2264   /// purpose of this class is a logical separation of some maps. The
  2265   /// other useful application could be to store paths in edge maps.
  2266   ///
  2267   /// The first line of the section contains the names of the maps
  2268   /// separated with white spaces. Each next line describes an item
  2269   /// in the itemset, and contains in the first column the label of
  2270   /// the item and then the mapped values for each map.
  2271   ///
  2272   /// \relates LemonReader
  2273   template <typename _Graph, typename _Traits = DefaultReaderTraits>
  2274   class EdgeMapReader : public LemonReader::SectionReader {
  2275     typedef LemonReader::SectionReader Parent;
  2276   public:
  2277 
  2278     typedef _Graph Graph;
  2279     typedef typename Graph::Edge Edge;
  2280     typedef _Traits Traits;
  2281     typedef typename Traits::Skipper DefaultSkipper;
  2282 
  2283     /// \brief Constructor.
  2284     ///
  2285     /// Constructor for EdgeMapReader. It creates the EdgeMapReader and
  2286     /// attach it into the given LemonReader. The reader will read
  2287     /// the section when the \c section_name and the \c _name are the same.
  2288     template <typename _LabelReader>
  2289     EdgeMapReader(LemonReader& _reader, 
  2290 		   const Graph& _graph, 
  2291 		   const _LabelReader& _labelReader,
  2292 		   const std::string& _name = std::string(),
  2293 		   const DefaultSkipper& _skipper = DefaultSkipper()) 
  2294       : Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {
  2295       labelReader.reset(new _reader_bits::
  2296 			LabelReader<Edge, _LabelReader>(_labelReader));
  2297     } 
  2298 
  2299 
  2300     /// \brief Destructor.
  2301     ///
  2302     /// Destructor for EdgeMapReader.
  2303     virtual ~EdgeMapReader() {
  2304       for (typename MapReaders::iterator it = readers.begin(); 
  2305 	   it != readers.end(); ++it) {
  2306 	delete it->second;
  2307       }
  2308     }
  2309 
  2310   private:
  2311     EdgeMapReader(const EdgeMapReader&);
  2312     void operator=(const EdgeMapReader&);
  2313   
  2314   public:
  2315 
  2316     /// \brief Add a new edge map reader command for the reader.
  2317     ///
  2318     /// Add a new edge map reader command for the reader.
  2319     template <typename Map>
  2320     EdgeMapReader& readEdgeMap(std::string label, Map& map) {
  2321       return _readMap<
  2322 	typename Traits::template Reader<typename Map::Value>, Map,
  2323 	typename _reader_bits::Arg<Map>::Type>(label, map);
  2324     }
  2325 
  2326     template <typename Map>
  2327     EdgeMapReader& readEdgeMap(std::string label, const Map& map) {
  2328       return _readMap<
  2329 	typename Traits::template Reader<typename Map::Value>, Map,
  2330 	typename _reader_bits::Arg<Map>::Type>(label, map);
  2331     }
  2332 
  2333     /// \brief Add a new edge map reader command for the reader.
  2334     ///
  2335     /// Add a new edge map reader command for the reader.
  2336     template <typename ItemReader, typename Map>
  2337     EdgeMapReader& readEdgeMap(std::string label, Map& map, 
  2338 			  const ItemReader& ir = ItemReader()) {
  2339       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
  2340 	(label, map, ir);
  2341     }
  2342 
  2343     template <typename ItemReader, typename Map>
  2344     EdgeMapReader& readEdgeMap(std::string label, const Map& map, 
  2345 			  const ItemReader& ir = ItemReader()) {
  2346       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
  2347 	(label, map, ir);
  2348     }
  2349 
  2350   private:
  2351 
  2352     template <typename ItemReader, typename Map, typename MapParameter>
  2353     EdgeMapReader& _readMap(std::string label, MapParameter map, 
  2354 				const ItemReader& ir = ItemReader()) {
  2355       checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
  2356       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
  2357       if (readers.find(label) != readers.end()) {
  2358 	ErrorMessage msg;
  2359 	msg << "Multiple read rule for map: " << label;
  2360 	throw IoParameterError(msg.message());
  2361       }      
  2362       readers.insert(
  2363 	make_pair(label, new _reader_bits::
  2364 		  MapReader<Edge, Map, ItemReader>(map, ir)));
  2365       return *this;
  2366     }
  2367 
  2368   public:
  2369 
  2370     /// \brief Add a new edge map skipper command for the reader.
  2371     ///
  2372     /// Add a new edge map skipper command for the reader.
  2373     template <typename ItemReader>
  2374     EdgeMapReader& skipEdgeMap(std::string label, 
  2375 			  const ItemReader& ir = ItemReader()) {
  2376       if (readers.find(label) != readers.end()) {
  2377 	ErrorMessage msg;
  2378 	msg << "Multiple read rule for map: " << label;
  2379 	throw IoParameterError(msg.message());
  2380       }
  2381       readers.insert(make_pair(label, new _reader_bits::
  2382 			       SkipReader<Edge, ItemReader>(ir)));
  2383       return *this;
  2384     }
  2385 
  2386   protected:
  2387 
  2388     /// \brief Gives back true when the SectionReader can process 
  2389     /// the section with the given header line.
  2390     ///
  2391     /// It gives back true when the header line starts with \c \@mapset,
  2392     /// and the header line's name and the mapset's name are the same.
  2393     virtual bool header(const std::string& line) {
  2394       std::istringstream ls(line);
  2395       std::string command;
  2396       std::string id;
  2397       ls >> command >> id;
  2398       return (command == "@edgemaps" || command == "@uedgemaps") && name == id;
  2399     }
  2400 
  2401     /// \brief Reader function of the section.
  2402     ///
  2403     /// It reads the content of the section.
  2404     virtual void read(std::istream& is) {
  2405       std::vector<_reader_bits::MapReaderBase<Edge>* > index;
  2406       std::string line;
  2407 
  2408       {
  2409         getline(is, line);
  2410         std::istringstream ls(line);
  2411         std::string id;
  2412         while (ls >> id) {
  2413           typename MapReaders::iterator it = readers.find(id);
  2414           if (it != readers.end()) {
  2415             it->second->touch();
  2416             index.push_back(it->second);
  2417           } else {
  2418             index.push_back(&skipper);
  2419           }
  2420         }
  2421       }
  2422       for (typename MapReaders::iterator it = readers.begin();
  2423 	   it != readers.end(); ++it) {
  2424 	if (!it->second->touched()) {
  2425 	  ErrorMessage msg;
  2426 	  msg << "Map not found in file: " << it->first;
  2427 	  throw IoParameterError(msg.message());
  2428 	}
  2429       }
  2430       while (getline(is, line)) {	
  2431 	std::istringstream ls(line);
  2432 	Edge edge = labelReader->read(ls);
  2433 	for (int i = 0; i < int(index.size()); ++i) {
  2434 	  index[i]->read(ls, edge);
  2435 	}
  2436       }
  2437     }
  2438 
  2439     virtual void missing() {
  2440       if (readers.empty()) return;
  2441       ErrorMessage msg;
  2442       msg << "EdgeMap section not found in file: @edgemaps " << name;
  2443       throw IoParameterError(msg.message());
  2444     }
  2445 
  2446   private:
  2447 
  2448     typedef std::map<std::string, _reader_bits::MapReaderBase<Edge>*> MapReaders;
  2449     MapReaders readers;
  2450    
  2451     const Graph& graph;   
  2452     std::string name;
  2453     _reader_bits::SkipReader<Edge, DefaultSkipper> skipper;
  2454     std::auto_ptr<_reader_bits::LabelReaderBase<Edge> > labelReader;
  2455 
  2456   };
  2457 
  2458   /// \ingroup section_io
  2459   /// \brief SectionReader for reading extra undirected edge maps.
  2460   ///
  2461   /// The lemon format can store maps in the uedgeset sections. This
  2462   /// class let you make distinict section to store maps.  The main
  2463   /// purpose of this class is a logical separation of some maps. The
  2464   /// other useful application could be to store paths in undirected
  2465   /// edge maps.
  2466   ///
  2467   /// The first line of the section contains the names of the maps
  2468   /// separated with white spaces. Each next line describes an item
  2469   /// in the itemset, and contains in the first column the label of
  2470   /// the item and then the mapped values for each map.
  2471   ///
  2472   /// \relates LemonReader
  2473   template <typename _Graph, typename _Traits = DefaultReaderTraits>
  2474   class UEdgeMapReader : public LemonReader::SectionReader {
  2475     typedef LemonReader::SectionReader Parent;
  2476   public:
  2477 
  2478     typedef _Graph Graph;
  2479     typedef typename Graph::Edge Edge;
  2480     typedef typename Graph::UEdge UEdge;
  2481     typedef _Traits Traits;
  2482     typedef typename Traits::Skipper DefaultSkipper;
  2483 
  2484     /// \brief Constructor.
  2485     ///
  2486     /// Constructor for UEdgeMapReader. It creates the UEdgeMapReader and
  2487     /// attach it into the given LemonReader. The reader will read
  2488     /// the section when the \c section_name and the \c _name are the same.
  2489     template <typename _LabelReader>
  2490     UEdgeMapReader(LemonReader& _reader, const Graph& _graph, 
  2491 		   const _LabelReader& _labelReader,
  2492 		   const std::string& _name = std::string(),
  2493 		   const DefaultSkipper& _skipper = DefaultSkipper()) 
  2494       : Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {
  2495       labelReader.reset(new _reader_bits::
  2496 			LabelReader<UEdge, _LabelReader>(_labelReader));
  2497     } 
  2498 
  2499 
  2500     /// \brief Destructor.
  2501     ///
  2502     /// Destructor for UEdgeMapReader.
  2503     virtual ~UEdgeMapReader() {
  2504       for (typename MapReaders::iterator it = readers.begin(); 
  2505 	   it != readers.end(); ++it) {
  2506 	delete it->second;
  2507       }
  2508     }
  2509 
  2510   private:
  2511     UEdgeMapReader(const UEdgeMapReader&);
  2512     void operator=(const UEdgeMapReader&);
  2513   
  2514   public:
  2515 
  2516     /// \brief Add a new undirected edge map reader command for the
  2517     /// reader.
  2518     ///
  2519     /// Add a new undirected edge map reader command for the reader.
  2520     template <typename Map>
  2521     UEdgeMapReader& readUEdgeMap(std::string label, Map& map) {
  2522       return _readMap<
  2523 	typename Traits::template Reader<typename Map::Value>, Map,
  2524 	typename _reader_bits::Arg<Map>::Type>(label, map);
  2525     }
  2526 
  2527     template <typename Map>
  2528     UEdgeMapReader& readUEdgeMap(std::string label, const Map& map) {
  2529       return _readMap<
  2530 	typename Traits::template Reader<typename Map::Value>, Map,
  2531 	typename _reader_bits::Arg<Map>::Type>(label, map);
  2532     }
  2533 
  2534     /// \brief Add a new undirected edge map reader command for the
  2535     /// reader.
  2536     ///
  2537     /// Add a new undirected edge map reader command for the reader.
  2538     template <typename ItemReader, typename Map>
  2539     UEdgeMapReader& readUEdgeMap(std::string label, Map& map, 
  2540 			  const ItemReader& ir = ItemReader()) {
  2541       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
  2542 	(label, map, ir);
  2543     }
  2544 
  2545     template <typename ItemReader, typename Map>
  2546     UEdgeMapReader& readUEdgeMap(std::string label, const Map& map, 
  2547 			  const ItemReader& ir = ItemReader()) {
  2548       return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
  2549 	(label, map, ir);
  2550     }
  2551 
  2552   private:
  2553 
  2554     template <typename ItemReader, typename Map, typename MapParameter>
  2555     UEdgeMapReader& _readMap(std::string label, MapParameter map, 
  2556 				const ItemReader& ir = ItemReader()) {
  2557       checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
  2558       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
  2559       if (readers.find(label) != readers.end()) {
  2560 	ErrorMessage msg;
  2561 	msg << "Multiple read rule for map: " << label;
  2562 	throw IoParameterError(msg.message());
  2563       }      
  2564       readers.insert(
  2565 	make_pair(label, new _reader_bits::
  2566 		  MapReader<UEdge, Map, ItemReader>(map, ir)));
  2567       return *this;
  2568     }
  2569 
  2570   public:
  2571 
  2572     /// \brief Add a new undirected edge map skipper command for the
  2573     /// reader.
  2574     ///
  2575     /// Add a new undirected edge map skipper command for the reader.
  2576     template <typename ItemReader>
  2577     UEdgeMapReader& skipUEdgeMap(std::string label, 
  2578 			  const ItemReader& ir = ItemReader()) {
  2579       if (readers.find(label) != readers.end()) {
  2580 	ErrorMessage msg;
  2581 	msg << "Multiple read rule for map: " << label;
  2582 	throw IoParameterError(msg.message());
  2583       }
  2584       readers.insert(make_pair(label, new _reader_bits::
  2585 			       SkipReader<Edge, ItemReader>(ir)));
  2586       return *this;
  2587     }
  2588 
  2589     /// \brief Add a new directed edge map reader command for the reader.
  2590     ///
  2591     /// Add a new directed edge map reader command for the reader.
  2592     template <typename Map>
  2593     UEdgeMapReader& readEdgeMap(std::string label, Map& map) {
  2594       return _readDirMap<
  2595 	typename Traits::template Reader<typename Map::Value>, Map,
  2596 	typename _reader_bits::Arg<Map>::Type>(label, map);
  2597     }
  2598 
  2599     template <typename Map>
  2600     UEdgeMapReader& readEdgeMap(std::string label, const Map& map) {
  2601       return _readDirMap<
  2602 	typename Traits::template Reader<typename Map::Value>, Map,
  2603 	typename _reader_bits::Arg<Map>::Type>(label, map);
  2604     }
  2605 
  2606     /// \brief Add a new directed edge map reader command for the reader.
  2607     ///
  2608     /// Add a new directed edge map reader command for the reader.
  2609     template <typename ItemReader, typename Map>
  2610     UEdgeMapReader& readEdgeMap(std::string label, Map& map, 
  2611 				    const ItemReader& ir = ItemReader()) {
  2612       return _readDirMap<ItemReader, Map, 
  2613         typename _reader_bits::Arg<Map>::Type>(label, map, ir);
  2614     }
  2615 
  2616     template <typename ItemReader, typename Map>
  2617     UEdgeMapReader& readEdgeMap(std::string label, const Map& map, 
  2618 				    const ItemReader& ir = ItemReader()) {
  2619       return _readDirMap<ItemReader, Map, 
  2620         typename _reader_bits::Arg<Map>::Type>(label, map, ir);
  2621     }
  2622 
  2623   private:
  2624 
  2625     template <typename ItemReader, typename Map, typename MapParameter>
  2626     UEdgeMapReader& _readDirMap(std::string label, MapParameter map,
  2627 				    const ItemReader& ir = ItemReader()) { 
  2628       checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
  2629       checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
  2630       readUEdgeMap("+" + label, 
  2631                    _reader_bits::forwardComposeMap(graph, map), ir);
  2632       readUEdgeMap("-" + label, 
  2633                    _reader_bits::backwardComposeMap(graph, map), ir);
  2634       return *this;      
  2635     }
  2636 
  2637   public:
  2638 
  2639     /// \brief Add a new directed edge map skipper command for the reader.
  2640     ///
  2641     /// Add a new directed edge map skipper command for the reader.
  2642     template <typename ItemReader>
  2643     UEdgeMapReader& skipEdgeMap(std::string label, 
  2644                                 const ItemReader& ir = ItemReader()) {
  2645       skipUEdgeMap("+" + label, ir);
  2646       skipUEdgeMap("-" + label, ir);
  2647       return *this;
  2648     }
  2649 
  2650   protected:
  2651 
  2652     /// \brief Gives back true when the SectionReader can process 
  2653     /// the section with the given header line.
  2654     ///
  2655     /// It gives back true when the header line starts with \c \@mapset,
  2656     /// and the header line's name and the mapset's name are the same.
  2657     virtual bool header(const std::string& line) {
  2658       std::istringstream ls(line);
  2659       std::string command;
  2660       std::string id;
  2661       ls >> command >> id;
  2662       return (command == "@edgemaps" || command == "@uedgemaps") && name == id;
  2663     }
  2664 
  2665     /// \brief Reader function of the section.
  2666     ///
  2667     /// It reads the content of the section.
  2668     virtual void read(std::istream& is) {
  2669       std::vector<_reader_bits::MapReaderBase<UEdge>* > index;
  2670       std::string line;
  2671 
  2672       {
  2673         getline(is, line);
  2674         std::istringstream ls(line);
  2675         std::string id;
  2676         while (ls >> id) {
  2677           typename MapReaders::iterator it = readers.find(id);
  2678           if (it != readers.end()) {
  2679             it->second->touch();
  2680             index.push_back(it->second);
  2681           } else {
  2682             index.push_back(&skipper);
  2683           }
  2684         }
  2685       }
  2686       for (typename MapReaders::iterator it = readers.begin();
  2687 	   it != readers.end(); ++it) {
  2688 	if (!it->second->touched()) {
  2689 	  ErrorMessage msg;
  2690 	  msg << "Map not found in file: " << it->first;
  2691 	  throw IoParameterError(msg.message());
  2692 	}
  2693       }
  2694       while (getline(is, line)) {	
  2695 	std::istringstream ls(line);
  2696 	UEdge uedge = labelReader->read(ls);
  2697 	for (int i = 0; i < int(index.size()); ++i) {
  2698 	  index[i]->read(ls, uedge);
  2699 	}
  2700       }
  2701     }
  2702 
  2703     virtual void missing() {
  2704       if (readers.empty()) return;
  2705       ErrorMessage msg;
  2706       msg << "UEdgeMap section not found in file: @uedgemaps " << name;
  2707       throw IoParameterError(msg.message());
  2708     }
  2709 
  2710   private:
  2711 
  2712     const Graph& graph;   
  2713     std::string name;
  2714 
  2715     typedef std::map<std::string, 
  2716 		     _reader_bits::MapReaderBase<UEdge>*> MapReaders;
  2717    
  2718     MapReaders readers;
  2719     _reader_bits::SkipReader<UEdge, DefaultSkipper> skipper;
  2720 
  2721     std::auto_ptr<_reader_bits::LabelReaderBase<UEdge> > labelReader;
  2722 
  2723   };
  2724 
  2725   /// \ingroup section_io
  2726   /// \brief SectionReader for retrieve what is in the file.
  2727   ///
  2728   /// SectionReader for retrieve what is in the file. If you want
  2729   /// to know which sections, maps and items are in the file
  2730   /// use the next code:
  2731   ///\code
  2732   /// LemonReader reader("input.lgf");
  2733   /// ContentReader content(reader);
  2734   /// reader.run();
  2735   ///\endcode
  2736   class ContentReader : public LemonReader::SectionReader {
  2737     typedef LemonReader::SectionReader Parent;
  2738   public:
  2739     /// \brief Constructor.
  2740     ///
  2741     /// Constructor for
  2742     ContentReader(LemonReader& _reader) : Parent(_reader) {}
  2743 
  2744     /// \brief Desctructor.
  2745     ///
  2746     /// Desctructor.
  2747     virtual ~ContentReader() {}
  2748 
  2749     /// \brief Gives back how many nodesets are in the file.
  2750     ///
  2751     /// Gives back how many nodesets are in the file.
  2752     int nodeSetNum() const {
  2753       return nodesets.size();
  2754     }
  2755 
  2756     /// \brief Gives back the name of nodeset on the indiced position.
  2757     ///
  2758     /// Gives back the name of nodeset on the indiced position.
  2759     std::string nodeSetName(int index) const {
  2760       return nodesets[index].name;
  2761     }
  2762 
  2763     /// \brief Gives back the map names of nodeset on the indiced position.
  2764     ///
  2765     /// Gives back the map names of nodeset on the indiced position.
  2766     const std::vector<std::string>& nodeSetMaps(int index) const {
  2767       return nodesets[index].items;
  2768     }
  2769 
  2770     /// \brief Gives back how many edgesets are in the file.
  2771     ///
  2772     /// Gives back how many edgesets are in the file.
  2773     int edgeSetNum() const {
  2774       return edgesets.size();
  2775     }
  2776 
  2777     /// \brief Gives back the name of edgeset on the indiced position.
  2778     ///
  2779     /// Gives back the name of edgeset on the indiced position.
  2780     std::string edgeSetName(int index) const {
  2781       return edgesets[index].name;
  2782     }
  2783 
  2784     /// \brief Gives back the map names of edgeset on the indiced position.
  2785     ///
  2786     /// Gives back the map names of edgeset on the indiced position.
  2787     const std::vector<std::string>& edgeSetMaps(int index) const {
  2788       return edgesets[index].items;
  2789     }
  2790 
  2791     /// \brief Gives back how many undirected edgesets are in the file.
  2792     ///
  2793     /// Gives back how many undirected edgesets are in the file.
  2794     int uEdgeSetNum() const {
  2795       return uedgesets.size();
  2796     }
  2797 
  2798     /// \brief Gives back the name of undirected edgeset on the indiced 
  2799     /// position.
  2800     ///
  2801     /// Gives back the name of undirected edgeset on the indiced position.
  2802     std::string uEdgeSetName(int index) const {
  2803       return uedgesets[index].name;
  2804     }
  2805 
  2806     /// \brief Gives back the map names of undirected edgeset on the indiced 
  2807     /// position.
  2808     ///
  2809     /// Gives back the map names of undirected edgeset on the indiced position.
  2810     const std::vector<std::string>& uEdgeSetMaps(int index) const {
  2811       return uedgesets[index].items;
  2812     }
  2813 
  2814     /// \brief Gives back how many labeled nodes section are in the file.
  2815     ///
  2816     /// Gives back how many labeled nodes section are in the file.
  2817     int nodesNum() const {
  2818       return nodes.size();
  2819     }
  2820 
  2821     /// \brief Gives back the name of labeled nodes section on the indiced 
  2822     /// position.
  2823     ///
  2824     /// Gives back the name of labeled nodes section on the indiced position.
  2825     std::string nodesName(int index) const {
  2826       return nodes[index].name;
  2827     }
  2828 
  2829     /// \brief Gives back the names of the labeled nodes in the indiced 
  2830     /// section.
  2831     ///
  2832     /// Gives back the names of the labeled nodes in the indiced section.
  2833     const std::vector<std::string>& nodesItems(int index) const {
  2834       return nodes[index].items;
  2835     }
  2836 
  2837     /// \brief Gives back how many labeled edges section are in the file.
  2838     ///
  2839     /// Gives back how many labeled edges section are in the file.
  2840     int edgesNum() const {
  2841       return edges.size();
  2842     }
  2843 
  2844     /// \brief Gives back the name of labeled edges section on the indiced 
  2845     /// position.
  2846     ///
  2847     /// Gives back the name of labeled edges section on the indiced position.
  2848     std::string edgesName(int index) const {
  2849       return edges[index].name;
  2850     }
  2851 
  2852     /// \brief Gives back the names of the labeled edges in the indiced 
  2853     /// section.
  2854     ///
  2855     /// Gives back the names of the labeled edges in the indiced section.
  2856     const std::vector<std::string>& edgesItems(int index) const {
  2857       return edges[index].items;
  2858     }
  2859  
  2860     /// \brief Gives back how many labeled undirected edges section are 
  2861     /// in the file.
  2862     ///
  2863     /// Gives back how many labeled undirected edges section are in the file.
  2864     int uEdgesNum() const {
  2865       return uedges.size();
  2866     }
  2867 
  2868     /// \brief Gives back the name of labeled undirected edges section 
  2869     /// on the indiced position.
  2870     ///
  2871     /// Gives back the name of labeled undirected edges section on the 
  2872     /// indiced position.
  2873     std::string uEdgesName(int index) const {
  2874       return uedges[index].name;
  2875     }
  2876 
  2877     /// \brief Gives back the names of the labeled undirected edges in 
  2878     /// the indiced section.
  2879     ///
  2880     /// Gives back the names of the labeled undirected edges in the 
  2881     /// indiced section.
  2882     const std::vector<std::string>& uEdgesItems(int index) const {
  2883       return uedges[index].items;
  2884     }
  2885 
  2886  
  2887     /// \brief Gives back how many attributes section are in the file.
  2888     ///
  2889     /// Gives back how many attributes section are in the file.
  2890     int attributesNum() const {
  2891       return attributes.size();
  2892     }
  2893 
  2894     /// \brief Gives back the name of attributes section on the indiced 
  2895     /// position.
  2896     ///
  2897     /// Gives back the name of attributes section on the indiced position.
  2898     std::string attributesName(int index) const {
  2899       return attributes[index].name;
  2900     }
  2901 
  2902     /// \brief Gives back the names of the attributes in the indiced section.
  2903     ///
  2904     /// Gives back the names of the attributes in the indiced section.
  2905     const std::vector<std::string>& attributesItems(int index) const {
  2906       return attributes[index].items;
  2907     }
  2908 
  2909     const std::vector<std::string>& otherSections() const {
  2910       return sections;
  2911     }
  2912 
  2913   protected:
  2914     
  2915     /// \brief Gives back true when the SectionReader can process 
  2916     /// the section with the given header line.
  2917     ///
  2918     /// It gives back true when the section is common section.
  2919     bool header(const std::string& line) {
  2920       std::istringstream ls(line);
  2921       std::string command, name;
  2922       ls >> command >> name;
  2923       if (command == "@nodeset") {
  2924 	current = command;
  2925 	nodesets.push_back(SectionInfo(name));
  2926       } else if (command == "@edgeset") {
  2927 	current = command;
  2928 	edgesets.push_back(SectionInfo(name));
  2929       } else if (command == "@uedgeset") {
  2930 	current = command;
  2931 	uedgesets.push_back(SectionInfo(name));
  2932       } else if (command == "@nodes") {
  2933 	current = command;
  2934 	nodes.push_back(SectionInfo(name));
  2935       } else if (command == "@edges") {
  2936 	current = command;
  2937 	edges.push_back(SectionInfo(name));
  2938       } else if (command == "@uedges") {
  2939 	current = command;
  2940 	uedges.push_back(SectionInfo(name));
  2941       } else if (command == "@attributes") {
  2942 	current = command;
  2943 	attributes.push_back(SectionInfo(name));
  2944       } else {
  2945 	sections.push_back(line);
  2946 	return false;
  2947       }
  2948       return true;
  2949     }
  2950 
  2951     /// \brief Retrieve the items from various sections.
  2952     ///
  2953     /// Retrieve the items from various sections.
  2954     void read(std::istream& is) {
  2955       if (current == "@nodeset") {
  2956 	readMapNames(is, nodesets.back().items);
  2957       } else if (current == "@edgeset") {
  2958 	readMapNames(is, edgesets.back().items);
  2959       } else if (current == "@uedgeset") {
  2960 	readMapNames(is, uedgesets.back().items);
  2961       } else if (current == "@nodes") {
  2962 	readItemNames(is, nodes.back().items);
  2963       } else if (current == "@edges") {
  2964 	readItemNames(is, edges.back().items);
  2965       } else if (current == "@uedges") {
  2966 	readItemNames(is, uedges.back().items);
  2967       } else if (current == "@attributes") {
  2968 	readItemNames(is, attributes.back().items);
  2969       }
  2970     }    
  2971 
  2972   private:
  2973 
  2974     void readMapNames(std::istream& is, std::vector<std::string>& maps) {
  2975       std::string line, name;
  2976       std::getline(is, line);
  2977       std::istringstream ls(line);
  2978       while (ls >> name) {
  2979 	maps.push_back(name);
  2980       }
  2981       while (getline(is, line));
  2982     }
  2983 
  2984     void readItemNames(std::istream& is, std::vector<std::string>& maps) {
  2985       std::string line, name;
  2986       while (std::getline(is, line)) {
  2987 	std::istringstream ls(line);
  2988 	ls >> name;
  2989 	maps.push_back(name);
  2990       }
  2991     }
  2992 
  2993     struct SectionInfo {
  2994       std::string name;
  2995       std::vector<std::string> items;
  2996 
  2997       SectionInfo(const std::string& _name) : name(_name) {}
  2998     };
  2999 
  3000     std::vector<SectionInfo> nodesets;
  3001     std::vector<SectionInfo> edgesets;
  3002     std::vector<SectionInfo> uedgesets;
  3003 
  3004     std::vector<SectionInfo> nodes;
  3005     std::vector<SectionInfo> edges;
  3006     std::vector<SectionInfo> uedges;
  3007 
  3008     std::vector<SectionInfo> attributes;
  3009 
  3010     std::vector<std::string> sections;
  3011 
  3012     std::string current;
  3013 
  3014   };
  3015 
  3016 }
  3017 #endif