# HG changeset patch
# User deba
# Date 1133633849 0
# Node ID f8bbfed860369b3a9f6d0185fca9baf9a201931b
# Parent  eaa5f5b855f75adec3f5e65599d6249eeee6ae8b
Implementation redesign
Throws exception

diff -r eaa5f5b855f7 -r f8bbfed86036 lemon/error.h
--- a/lemon/error.h	Sat Dec 03 18:15:43 2005 +0000
+++ b/lemon/error.h	Sat Dec 03 18:17:29 2005 +0000
@@ -376,7 +376,7 @@
     virtual ~FileOpenError() throw() {}
   };
 
-  class IOParameterError : public LogicError {
+  class IOParameterError : public IOError {
   protected:
     ExceptionMember<std::string> _message;
     ExceptionMember<std::string> _file;
@@ -385,7 +385,7 @@
   public:
 
     IOParameterError(const IOParameterError &ile) : 
-      LogicError(ile), _message(ile._message), _file(ile._file) {}
+      IOError(ile), _message(ile._message), _file(ile._file) {}
 
     ///\e 
     explicit IOParameterError(const char *the_message)
diff -r eaa5f5b855f7 -r f8bbfed86036 lemon/lemon_reader.h
--- a/lemon/lemon_reader.h	Sat Dec 03 18:15:43 2005 +0000
+++ b/lemon/lemon_reader.h	Sat Dec 03 18:17:29 2005 +0000
@@ -45,6 +45,18 @@
 
   namespace _reader_bits {
 
+    template <typename T>
+    bool operator<(T, T) {
+      throw DataFormatError("Id is not comparable");
+    }
+
+    template <typename T>
+    struct Less {
+      bool operator()(const T& p, const T& q) const {
+	return p < q;
+      }
+    };
+
     template <typename Item>
     class ItemIdReader {
     public:
@@ -83,18 +95,6 @@
       };
 
     };
-  
-    template <typename T>
-    bool operator<(T, T) {
-      throw DataFormatError("Id is not comparable");
-    }
-
-    template <typename T>
-    struct Less {
-      bool operator()(const T& p, const T& q) const {
-	return p < q;
-      }
-    };
 
     template <typename Map>
     struct Ref { typedef Map& Type; };
@@ -198,6 +198,253 @@
       typedef const YMap<Map>& Type;
     };
 
+
+    template <typename _Item>
+    class MapReaderBase;
+    
+    template <typename _Item>
+    class MapInverterBase : public MapReaderBase<_Item> {
+    public:
+      typedef _Item Item;
+      virtual void read(std::istream&, const Item&) = 0;
+      virtual Item read(std::istream&) const = 0;
+
+      virtual MapInverterBase<_Item>* getInverter() {
+	return this;
+      }
+    };
+
+    template <typename _Item, typename _Map, typename _Reader>
+    class MapReaderInverter : public MapInverterBase<_Item> {
+    public:
+      typedef _Item Item;
+      typedef _Reader Reader;
+      typedef typename Reader::Value Value;
+      typedef _Map Map;
+      typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
+
+      typename _reader_bits::Ref<Map>::Type map;
+      Reader reader;
+      Inverse inverse;
+
+      MapReaderInverter(typename _reader_bits::Arg<Map>::Type _map,
+			const Reader& _reader) 
+	: map(_map), reader(_reader) {}
+
+      virtual ~MapReaderInverter() {}
+
+      virtual void read(std::istream& is, const Item& item) {
+	Value value;
+	reader.read(is, value);
+	map.set(item, value);
+	typename Inverse::iterator it = inverse.find(value);
+	if (it == inverse.end()) {
+	  inverse.insert(std::make_pair(value, item));
+	} else {
+	  throw DataFormatError("Multiple ID occurence");
+	}
+      }
+
+      virtual Item read(std::istream& is) const {
+	Value value;
+	reader.read(is, value);	
+	typename Inverse::const_iterator it = inverse.find(value);
+	if (it != inverse.end()) {
+	  return it->second;
+	} else {
+	  throw DataFormatError("Invalid ID error");
+	}
+      }      
+    };
+
+    template <typename _Item, typename _Reader>
+    class SkipReaderInverter : public MapInverterBase<_Item> {
+    public:
+      typedef _Item Item;
+      typedef _Reader Reader;
+      typedef typename Reader::Value Value;
+      typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
+
+      Reader reader;
+
+      SkipReaderInverter(const Reader& _reader) 
+	: reader(_reader) {}
+
+      virtual ~SkipReaderInverter() {}
+
+      virtual void read(std::istream& is, const Item& item) {
+	Value value;
+	reader.read(is, value);
+	typename Inverse::iterator it = inverse.find(value);
+	if (it == inverse.end()) {
+	  inverse.insert(std::make_pair(value, item));
+	} else {
+	  throw DataFormatError("Multiple ID occurence error");
+	}
+      }
+
+      virtual Item read(std::istream& is) const {
+	Value value;
+	reader.read(is, value);	
+	typename Inverse::const_iterator it = inverse.find(value);
+	if (it != inverse.end()) {
+	  return it->second;
+	} else {
+	  throw DataFormatError("Invalid ID error");
+	}
+      }
+
+    private:
+      Inverse inverse;
+    };
+
+    template <typename _Item>    
+    class MapReaderBase {
+    public:
+      typedef _Item Item;
+
+      MapReaderBase() { _touched = false; }
+      
+      void touch() { _touched = true; }
+      bool touched() const { return _touched; }
+
+      virtual ~MapReaderBase() {}
+
+      virtual void read(std::istream& is, const Item& item) = 0;
+      virtual MapInverterBase<_Item>* getInverter() = 0;
+
+    private:      
+      bool _touched;
+
+    };
+
+    template <typename _Item, typename _Map, typename _Reader>
+    class MapReader : public MapReaderBase<_Item> {
+    public:
+      typedef _Map Map;
+      typedef _Reader Reader;
+      typedef typename Reader::Value Value;
+      typedef _Item Item;
+      
+      typename _reader_bits::Ref<Map>::Type map;
+      Reader reader;
+
+      MapReader(typename _reader_bits::Arg<Map>::Type _map, 
+		const Reader& _reader) 
+	: map(_map), reader(_reader) {}
+
+      virtual ~MapReader() {}
+
+      virtual void read(std::istream& is, const Item& item) {
+	Value value;
+	reader.read(is, value);
+	map.set(item, value);
+      }
+
+      virtual MapInverterBase<_Item>* getInverter() {
+	return new MapReaderInverter<Item, Map, Reader>(map, reader);
+      }
+    };
+
+
+    template <typename _Item, typename _Reader>
+    class SkipReader : public MapReaderBase<_Item> {
+    public:
+      typedef _Reader Reader;
+      typedef typename Reader::Value Value;
+      typedef _Item Item;
+
+      Reader reader;
+      SkipReader(const Reader& _reader) : reader(_reader) {}
+
+      virtual ~SkipReader() {}
+
+      virtual void read(std::istream& is, const Item&) {
+	Value value;
+	reader.read(is, value);
+      }      
+
+      virtual MapInverterBase<Item>* getInverter() {
+	return new SkipReaderInverter<Item, Reader>(reader);
+      }
+    };
+
+    template <typename _Item>
+    class IdReaderBase {
+    public:
+      typedef _Item Item;
+      virtual ~IdReaderBase() {}
+      virtual Item read(std::istream& is) const = 0;
+      virtual bool isIdReader() const = 0;
+    };
+
+    template <typename _Item, typename _BoxedIdReader>
+    class IdReader : public IdReaderBase<_Item> {
+    public:
+      typedef _Item Item;
+      typedef _BoxedIdReader BoxedIdReader;
+      
+      const BoxedIdReader& boxedIdReader;
+
+      IdReader(const BoxedIdReader& _boxedIdReader) 
+	: boxedIdReader(_boxedIdReader) {}
+
+      virtual Item read(std::istream& is) const {
+	Item item;
+	boxedIdReader.readId(is, item);
+	return item;
+      }
+
+      virtual bool isIdReader() const {
+	return boxedIdReader.isIdReader();
+      }
+    };
+
+    template <typename _Item>
+    class ItemStore {
+    public:
+
+      typedef _Item Item;
+
+      ItemStore(Item& _item) : item(&_item) { 
+	_touched = false; 
+      }
+      
+      void touch() { _touched = true; }
+      bool touched() const { return _touched; }
+
+      void read(const Item& _item) {
+	*item = _item;
+      }
+      
+    private:
+      Item* item;
+      bool _touched;
+    };
+
+    class ValueReaderBase {
+    public:
+      virtual void read(std::istream&) {};
+      virtual ~ValueReaderBase() {}
+    };
+
+    template <typename _Value, typename _Reader>
+    class ValueReader : public ValueReaderBase {
+    public:
+      typedef _Value Value;
+      typedef _Reader Reader;
+
+      ValueReader(Value& _value, const Reader& _reader)
+ 	: value(_value), reader(_reader) {}
+
+      virtual void read(std::istream& is) {
+	reader.read(is, value);
+      }
+    private:
+      Value& value;
+      Reader reader;
+    };
+
   }
 
   /// \ingroup io_group
@@ -469,237 +716,6 @@
 
   };
 
-  /// \brief Helper class for implementing the common SectionReaders.
-  ///
-  /// Helper class for implementing the common SectionReaders.
-  class CommonSectionReaderBase : public LemonReader::SectionReader {
-    typedef LemonReader::SectionReader Parent;
-  protected:
-    
-    /// \brief Constructor for CommonSectionReaderBase.
-    ///
-    /// Constructor for CommonSectionReaderBase. It attach this reader to
-    /// the given LemonReader.
-    CommonSectionReaderBase(LemonReader& _reader) 
-      : Parent(_reader) {}
-
-    template <typename _Item>
-    class ReaderBase;
-    
-    template <typename _Item>
-    class InverterBase : public ReaderBase<_Item> {
-    public:
-      typedef _Item Item;
-      virtual void read(std::istream&, const Item&) = 0;
-      virtual Item read(std::istream&) const = 0;
-
-      virtual InverterBase<_Item>* getInverter() {
-	return this;
-      }
-    };
-
-    template <typename _Item, typename _Map, typename _Reader>
-    class MapReaderInverter : public InverterBase<_Item> {
-    public:
-      typedef _Item Item;
-      typedef _Reader Reader;
-      typedef typename Reader::Value Value;
-      typedef _Map Map;
-      typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
-
-      typename _reader_bits::Ref<Map>::Type map;
-      Reader reader;
-      Inverse inverse;
-
-      MapReaderInverter(typename _reader_bits::Arg<Map>::Type _map,
-			const Reader& _reader) 
-	: map(_map), reader(_reader) {}
-
-      virtual ~MapReaderInverter() {}
-
-      virtual void read(std::istream& is, const Item& item) {
-	Value value;
-	reader.read(is, value);
-	map.set(item, value);
-	typename Inverse::iterator it = inverse.find(value);
-	if (it == inverse.end()) {
-	  inverse.insert(std::make_pair(value, item));
-	} else {
-	  throw DataFormatError("Multiple ID occurence");
-	}
-      }
-
-      virtual Item read(std::istream& is) const {
-	Value value;
-	reader.read(is, value);	
-	typename Inverse::const_iterator it = inverse.find(value);
-	if (it != inverse.end()) {
-	  return it->second;
-	} else {
-	  throw DataFormatError("Invalid ID error");
-	}
-      }      
-    };
-
-    template <typename _Item, typename _Reader>
-    class SkipReaderInverter : public InverterBase<_Item> {
-    public:
-      typedef _Item Item;
-      typedef _Reader Reader;
-      typedef typename Reader::Value Value;
-      typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
-
-      Reader reader;
-
-      SkipReaderInverter(const Reader& _reader) 
-	: reader(_reader) {}
-
-      virtual ~SkipReaderInverter() {}
-
-      virtual void read(std::istream& is, const Item& item) {
-	Value value;
-	reader.read(is, value);
-	typename Inverse::iterator it = inverse.find(value);
-	if (it == inverse.end()) {
-	  inverse.insert(std::make_pair(value, item));
-	} else {
-	  throw DataFormatError("Multiple ID occurence error");
-	}
-      }
-
-      virtual Item read(std::istream& is) const {
-	Value value;
-	reader.read(is, value);	
-	typename Inverse::const_iterator it = inverse.find(value);
-	if (it != inverse.end()) {
-	  return it->second;
-	} else {
-	  throw DataFormatError("Invalid ID error");
-	}
-      }
-
-    private:
-      Inverse inverse;
-    };
-
-    template <typename _Item>    
-    class ReaderBase {
-    public:
-      typedef _Item Item;
-
-      virtual ~ReaderBase() {}
-
-      virtual void read(std::istream& is, const Item& item) = 0;
-      virtual InverterBase<_Item>* getInverter() = 0;
-    };
-
-    template <typename _Item, typename _Map, typename _Reader>
-    class MapReader : public ReaderBase<_Item> {
-    public:
-      typedef _Map Map;
-      typedef _Reader Reader;
-      typedef typename Reader::Value Value;
-      typedef _Item Item;
-      
-      typename _reader_bits::Ref<Map>::Type map;
-      Reader reader;
-
-      MapReader(typename _reader_bits::Arg<Map>::Type _map, 
-		const Reader& _reader) 
-	: map(_map), reader(_reader) {}
-
-      virtual ~MapReader() {}
-
-      virtual void read(std::istream& is, const Item& item) {
-	Value value;
-	reader.read(is, value);
-	map.set(item, value);
-      }
-
-      virtual InverterBase<_Item>* getInverter() {
-	return new MapReaderInverter<Item, Map, Reader>(map, reader);
-      }
-    };
-
-
-    template <typename _Item, typename _Reader>
-    class SkipReader : public ReaderBase<_Item> {
-    public:
-      typedef _Reader Reader;
-      typedef typename Reader::Value Value;
-      typedef _Item Item;
-
-      Reader reader;
-      SkipReader(const Reader& _reader) : reader(_reader) {}
-
-      virtual ~SkipReader() {}
-
-      virtual void read(std::istream& is, const Item&) {
-	Value value;
-	reader.read(is, value);
-      }      
-
-      virtual InverterBase<Item>* getInverter() {
-	return new SkipReaderInverter<Item, Reader>(reader);
-      }
-    };
-
-    template <typename _Item>
-    class IdReaderBase {
-    public:
-      typedef _Item Item;
-      virtual ~IdReaderBase() {}
-      virtual Item read(std::istream& is) const = 0;
-      virtual bool isIdReader() const = 0;
-    };
-
-    template <typename _Item, typename _BoxedIdReader>
-    class IdReader : public IdReaderBase<_Item> {
-    public:
-      typedef _Item Item;
-      typedef _BoxedIdReader BoxedIdReader;
-      
-      const BoxedIdReader& boxedIdReader;
-
-      IdReader(const BoxedIdReader& _boxedIdReader) 
-	: boxedIdReader(_boxedIdReader) {}
-
-      virtual Item read(std::istream& is) const {
-	Item item;
-	boxedIdReader.readId(is, item);
-	return item;
-      }
-
-      virtual bool isIdReader() const {
-	return boxedIdReader.isIdReader();
-      }
-    };
-
-    class ValueReaderBase {
-    public:
-      virtual void read(std::istream&) {};
-      virtual ~ValueReaderBase() {}
-    };
-
-    template <typename _Value, typename _Reader>
-    class ValueReader : public ValueReaderBase {
-    public:
-      typedef _Value Value;
-      typedef _Reader Reader;
-
-      ValueReader(Value& _value, const Reader& _reader)
- 	: value(_value), reader(_reader) {}
-
-      virtual void read(std::istream& is) {
-	reader.read(is, value);
-      }
-    private:
-      Value& value;
-      Reader reader;
-    };
-    
-  };
-
   /// \ingroup io_group
   /// \brief SectionReader for reading a graph's nodeset.
   ///
@@ -718,8 +734,8 @@
   ///
   /// \relates LemonReader
   template <typename _Graph, typename _Traits = DefaultReaderTraits>
-  class NodeSetReader : public CommonSectionReaderBase {
-    typedef CommonSectionReaderBase Parent;
+  class NodeSetReader : public LemonReader::SectionReader {
+    typedef LemonReader::SectionReader Parent;
   public:
 
     typedef _Graph Graph;
@@ -801,9 +817,10 @@
 	ErrorMessage msg;
 	msg << "Multiple read rule for node map: " << name;
 	throw IOParameterError(msg.message());
-      }
+      }      
       readers.insert(
-	make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));
+        make_pair(name, new _reader_bits::
+		  MapReader<Node, Map, Reader>(map, reader)));
       return *this;
     }
 
@@ -820,7 +837,8 @@
 	msg << "Multiple read rule for node map: " << name;
 	throw IOParameterError(msg.message());
       }
-      readers.insert(make_pair(name, new SkipReader<Node, Reader>(reader)));
+      readers.insert(make_pair(name, new _reader_bits::
+			       SkipReader<Node, Reader>(reader)));
       return *this;
     }
 
@@ -843,7 +861,7 @@
     ///
     /// It reads the content of the section.
     virtual void read(std::istream& is) {
-      std::vector<ReaderBase<Node>* > index;
+      std::vector<_reader_bits::MapReaderBase<Node>* > index;
       std::string line;
 
       getline(is, line);
@@ -851,6 +869,7 @@
       while (ls >> id) {
 	typename MapReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
+	  it->second->touch();
 	  index.push_back(it->second);
 	} else {
 	  index.push_back(&skipper);
@@ -860,6 +879,14 @@
 	  index.back() = inverter.get();
 	}
       }
+      for (typename MapReaders::iterator it = readers.begin();
+	   it != readers.end(); ++it) {
+	if (!it->second->touched()) {
+	  ErrorMessage msg;
+	  msg << "Map not found in file: " << it->first;
+	  throw IOParameterError(msg.message());
+	}
+      }
       while (getline(is, line)) {	
 	Node node = graph.addNode();
 	std::istringstream ls(line);
@@ -889,14 +916,14 @@
 
   private:
 
-    typedef std::map<std::string, ReaderBase<Node>*> MapReaders;
+    typedef std::map<std::string, _reader_bits::MapReaderBase<Node>*> MapReaders;
     MapReaders readers;
    
     Graph& graph;   
     std::string id;
-    SkipReader<Node, DefaultSkipper> skipper;
+    _reader_bits::SkipReader<Node, DefaultSkipper> skipper;
 
-    std::auto_ptr<InverterBase<Node> > inverter;
+    std::auto_ptr<_reader_bits::MapInverterBase<Node> > inverter;
   };
 
   /// \ingroup io_group
@@ -922,8 +949,8 @@
   ///
   /// \relates LemonReader
   template <typename _Graph, typename _Traits = DefaultReaderTraits>
-  class EdgeSetReader : public CommonSectionReaderBase {
-    typedef CommonSectionReaderBase Parent;
+  class EdgeSetReader : public LemonReader::SectionReader {
+    typedef LemonReader::SectionReader Parent;
   public:
 
     typedef _Graph Graph;
@@ -948,7 +975,8 @@
 		  const DefaultSkipper& _skipper = DefaultSkipper()) 
       : Parent(_reader), graph(_graph), id(_id), skipper(_skipper) {
       checkConcept<_reader_bits::ItemIdReader<Node>, NodeIdReader>();
-      nodeIdReader.reset(new IdReader<Node, NodeIdReader>(_nodeIdReader));
+      nodeIdReader.reset(new _reader_bits::
+			 IdReader<Node, NodeIdReader>(_nodeIdReader));
     }
     /// \brief Destructor.
     ///
@@ -1013,7 +1041,8 @@
 	throw IOParameterError(msg.message());
       }
       readers.insert(
-	make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));
+	make_pair(name, new _reader_bits::
+		  MapReader<Edge, Map, Reader>(map, reader)));
       return *this;
     }
 
@@ -1030,7 +1059,8 @@
 	msg << "Multiple read rule for edge map: " << name;
 	throw IOParameterError(msg.message());
       }
-      readers.insert(make_pair(name, new SkipReader<Edge, Reader>(reader)));
+      readers.insert(make_pair(name, new _reader_bits::
+			       SkipReader<Edge, Reader>(reader)));
       return *this;
     }
 
@@ -1056,7 +1086,7 @@
       if (!nodeIdReader->isIdReader()) {
 	throw DataFormatError("Cannot find nodeset or ID map");
       }
-      std::vector<ReaderBase<Edge>* > index;
+      std::vector<_reader_bits::MapReaderBase<Edge>* > index;
       std::string line;
 
       getline(is, line);
@@ -1065,6 +1095,7 @@
 	typename MapReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
 	  index.push_back(it->second);
+	  it->second->touch();
 	} else {
 	  index.push_back(&skipper);
 	}
@@ -1073,6 +1104,14 @@
 	  index.back() = inverter.get();
 	}
       }
+      for (typename MapReaders::iterator it = readers.begin();
+	   it != readers.end(); ++it) {
+	if (!it->second->touched()) {
+	  ErrorMessage msg;
+	  msg << "Map not found in file: " << it->first;
+	  throw IOParameterError(msg.message());
+	}
+      }
       while (getline(is, line)) {	
 	std::istringstream ls(line);
 	Node from = nodeIdReader->read(ls);
@@ -1104,15 +1143,15 @@
 
   private:
 
-    typedef std::map<std::string, ReaderBase<Edge>*> MapReaders;
+    typedef std::map<std::string, _reader_bits::MapReaderBase<Edge>*> MapReaders;
     MapReaders readers;
    
     Graph& graph;   
     std::string id;
-    SkipReader<Edge, DefaultSkipper> skipper;
+    _reader_bits::SkipReader<Edge, DefaultSkipper> skipper;
 
-    std::auto_ptr<InverterBase<Edge> > inverter;
-    std::auto_ptr<IdReaderBase<Node> > nodeIdReader;
+    std::auto_ptr<_reader_bits::MapInverterBase<Edge> > inverter;
+    std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader;
   };
 
   /// \ingroup io_group
@@ -1143,8 +1182,8 @@
   ///
   /// \relates LemonReader
   template <typename _Graph, typename _Traits = DefaultReaderTraits>
-  class UndirEdgeSetReader : public CommonSectionReaderBase {
-    typedef CommonSectionReaderBase Parent;
+  class UndirEdgeSetReader : public LemonReader::SectionReader {
+    typedef LemonReader::SectionReader Parent;
   public:
 
     typedef _Graph Graph;
@@ -1170,7 +1209,8 @@
 		       const DefaultSkipper& _skipper = DefaultSkipper()) 
       : Parent(_reader), graph(_graph), id(_id), skipper(_skipper) {
       checkConcept<_reader_bits::ItemIdReader<Node>, NodeIdReader>();
-      nodeIdReader.reset(new IdReader<Node, NodeIdReader>(_nodeIdReader));
+      nodeIdReader.reset(new _reader_bits::
+			 IdReader<Node, NodeIdReader>(_nodeIdReader));
     }
     /// \brief Destructor.
     ///
@@ -1235,7 +1275,8 @@
 	throw IOParameterError(msg.message());
       }
       readers.insert(
-	make_pair(name, new MapReader<UndirEdge, Map, Reader>(map, reader)));
+	make_pair(name, new _reader_bits::
+		  MapReader<UndirEdge, Map, Reader>(map, reader)));
       return *this;
     }
 
@@ -1252,8 +1293,8 @@
 	msg << "Multiple read rule for node map: " << name;
 	throw IOParameterError(msg.message());
       }
-      readers.insert(make_pair(name, 
-			       new SkipReader<UndirEdge, Reader>(reader)));
+      readers.insert(make_pair(name, new _reader_bits::
+			       SkipReader<UndirEdge, Reader>(reader)));
       return *this;
     }
 
@@ -1340,7 +1381,7 @@
       if (!nodeIdReader->isIdReader()) {
 	throw DataFormatError("Cannot find nodeset or ID map");
       }
-      std::vector<ReaderBase<UndirEdge>* > index;
+      std::vector<_reader_bits::MapReaderBase<UndirEdge>* > index;
       std::string line;
 
       getline(is, line);
@@ -1349,6 +1390,7 @@
 	typename MapReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
 	  index.push_back(it->second);
+	  it->second->touch();
 	} else {
 	  index.push_back(&skipper);
 	}
@@ -1357,6 +1399,14 @@
 	  index.back() = inverter.get();
 	}
       }
+      for (typename MapReaders::iterator it = readers.begin();
+	   it != readers.end(); ++it) {
+	if (!it->second->touched()) {
+	  ErrorMessage msg;
+	  msg << "Map not found in file: " << it->first;
+	  throw IOParameterError(msg.message());
+	}
+      }
       while (getline(is, line)) {	
 	std::istringstream ls(line);
 	Node from = nodeIdReader->read(ls);
@@ -1408,15 +1458,16 @@
 
   private:
 
-    typedef std::map<std::string, ReaderBase<UndirEdge>*> MapReaders;
+    typedef std::map<std::string, 
+		     _reader_bits::MapReaderBase<UndirEdge>*> MapReaders;
     MapReaders readers;
    
     Graph& graph;   
     std::string id;
-    SkipReader<UndirEdge, DefaultSkipper> skipper;
+    _reader_bits::SkipReader<UndirEdge, DefaultSkipper> skipper;
 
-    std::auto_ptr<InverterBase<UndirEdge> > inverter;
-    std::auto_ptr<IdReaderBase<Node> > nodeIdReader;
+    std::auto_ptr<_reader_bits::MapInverterBase<UndirEdge> > inverter;
+    std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader;
   };
 
   /// \ingroup io_group
@@ -1430,8 +1481,8 @@
   ///
   /// \relates LemonReader
   template <typename _Graph>
-  class NodeReader : public CommonSectionReaderBase {
-    typedef CommonSectionReaderBase Parent;
+  class NodeReader : public LemonReader::SectionReader {
+    typedef LemonReader::SectionReader Parent;
     typedef _Graph Graph;
     typedef typename Graph::Node Node;
   public:
@@ -1447,7 +1498,8 @@
 	       const std::string& _id = std::string()) 
       : Parent(_reader), id(_id) {
       checkConcept<_reader_bits::ItemIdReader<Node>, _IdReader>();
-      nodeIdReader.reset(new IdReader<Node, _IdReader>(_idReader));
+      nodeIdReader.reset(new _reader_bits::
+			 IdReader<Node, _IdReader>(_idReader));
     }
 
     /// \brief Destructor.
@@ -1470,7 +1522,7 @@
 	msg << "Multiple read rule for node: " << name;
 	throw IOParameterError(msg.message());
       }
-      readers.insert(make_pair(name, &item));
+      readers.insert(make_pair(name, _reader_bits::ItemStore<Node>(item)));
     }
 
   protected:
@@ -1502,18 +1554,27 @@
 	ls >> id;
 	typename NodeReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
-	  *(it->second) = nodeIdReader->read(ls); 
+	  it->second.read(nodeIdReader->read(ls));
+	  it->second.touch();
 	}	
       }
+      for (typename NodeReaders::iterator it = readers.begin();
+	   it != readers.end(); ++it) {
+	if (!it->second.touched()) {
+	  ErrorMessage msg;
+	  msg << "Node not found in file: " << it->first;
+	  throw IOParameterError(msg.message());
+	}
+      }
     }
     
   private:
 
     std::string id;
 
-    typedef std::map<std::string, Node*> NodeReaders;
+    typedef std::map<std::string, _reader_bits::ItemStore<Node> > NodeReaders;
     NodeReaders readers;
-    std::auto_ptr<IdReaderBase<Node> > nodeIdReader;
+    std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader;
   };
 
   /// \ingroup io_group
@@ -1527,8 +1588,8 @@
   ///
   /// \relates LemonReader
   template <typename _Graph>
-  class EdgeReader : public CommonSectionReaderBase {
-    typedef CommonSectionReaderBase Parent;
+  class EdgeReader : public LemonReader::SectionReader {
+    typedef LemonReader::SectionReader Parent;
     typedef _Graph Graph;
     typedef typename Graph::Edge Edge;
   public:
@@ -1544,7 +1605,8 @@
 	       const std::string& _id = std::string()) 
       : Parent(_reader), id(_id) {
       checkConcept<_reader_bits::ItemIdReader<Edge>, _IdReader>();
-      edgeIdReader.reset(new IdReader<Edge, _IdReader>(_idReader));
+      edgeIdReader.reset(new _reader_bits::
+			 IdReader<Edge, _IdReader>(_idReader));
     }
 
     /// \brief Destructor.
@@ -1566,7 +1628,7 @@
 	msg << "Multiple read rule for edge: " << name;
 	throw IOParameterError(msg.message());
       }
-      readers.insert(make_pair(name, &item));
+      readers.insert(make_pair(name, _reader_bits::ItemStore<Edge>(item)));
     }
 
   protected:
@@ -1598,18 +1660,27 @@
 	ls >> id;
 	typename EdgeReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
-	  *(it->second) = edgeIdReader->read(ls); 
+	  it->second.read(edgeIdReader->read(ls));
+	  it->second.touch();
 	}	
       }
+      for (typename EdgeReaders::iterator it = readers.begin();
+	   it != readers.end(); ++it) {
+	if (!it->second.touched()) {
+	  ErrorMessage msg;
+	  msg << "Edge not found in file: " << it->first;
+	  throw IOParameterError(msg.message());
+	}
+      }
     }
     
   private:
 
     std::string id;
 
-    typedef std::map<std::string, Edge*> EdgeReaders;
+    typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders;
     EdgeReaders readers;
-    std::auto_ptr<IdReaderBase<Edge> > edgeIdReader;
+    std::auto_ptr<_reader_bits::IdReaderBase<Edge> > edgeIdReader;
   };
 
   /// \ingroup io_group
@@ -1623,8 +1694,8 @@
   ///
   /// \relates LemonReader
   template <typename _Graph>
-  class UndirEdgeReader : public CommonSectionReaderBase {
-    typedef CommonSectionReaderBase Parent;
+  class UndirEdgeReader : public LemonReader::SectionReader {
+    typedef LemonReader::SectionReader Parent;
     typedef _Graph Graph;
     typedef typename Graph::Edge Edge;
     typedef typename Graph::UndirEdge UndirEdge;
@@ -1643,8 +1714,10 @@
       : Parent(_reader), id(_id) {
       checkConcept<_reader_bits::ItemIdReader<UndirEdge>, _IdReader>();
       checkConcept<_reader_bits::ItemIdReader<Edge>, _IdReader>();
-      undirEdgeIdReader.reset(new IdReader<UndirEdge, _IdReader>(_idReader));
-      edgeIdReader.reset(new IdReader<Edge, _IdReader>(_idReader));
+      undirEdgeIdReader.reset(new _reader_bits::
+			      IdReader<UndirEdge, _IdReader>(_idReader));
+      edgeIdReader.reset(new _reader_bits::
+			 IdReader<Edge, _IdReader>(_idReader));
     }
 
     /// \brief Destructor.
@@ -1666,7 +1739,8 @@
 	msg << "Multiple read rule for undirected edge: " << name;
 	throw IOParameterError(msg.message());
       }
-      undirEdgeReaders.insert(make_pair(name, &item));
+      undirEdgeReaders.insert(make_pair(name, _reader_bits::
+					ItemStore<UndirEdge>(item)));
     }
 
     /// \brief Add an edge reader command for the UndirEdgeReader.
@@ -1678,7 +1752,7 @@
 	msg << "Multiple read rule for edge: " << name;
 	throw IOParameterError(msg.message());
       }
-      edgeReaders.insert(make_pair(name, &item));
+      edgeReaders.insert(make_pair(name, _reader_bits::ItemStore<Edge>(item)));
     }
 
   protected:
@@ -1714,30 +1788,49 @@
 	{
 	  typename UndirEdgeReaders::iterator it = undirEdgeReaders.find(id);
 	  if (it != undirEdgeReaders.end()) {
-	    *(it->second) = undirEdgeIdReader->read(ls); 
-	    break;
+	    it->second.read(undirEdgeIdReader->read(ls));
+	    it->second.touch();
+	    continue;
 	  }	
 	} {
 	  typename EdgeReaders::iterator it = edgeReaders.find(id);
 	  if (it != edgeReaders.end()) {
-	    *(it->second) = edgeIdReader->read(ls); 
-	    break;
+	    it->second.read(edgeIdReader->read(ls));
+	    it->second.touch();
+	    continue;
 	  }	
 	}
       }
+      for (typename EdgeReaders::iterator it = edgeReaders.begin();
+	   it != edgeReaders.end(); ++it) {
+	if (!it->second.touched()) {
+	  ErrorMessage msg;
+	  msg << "Edge not found in file: " << it->first;
+	  throw IOParameterError(msg.message());
+	}
+      }
+      for (typename UndirEdgeReaders::iterator it = undirEdgeReaders.begin();
+	   it != undirEdgeReaders.end(); ++it) {
+	if (!it->second.touched()) {
+	  ErrorMessage msg;
+	  msg << "UndirEdge not found in file: " << it->first;
+	  throw IOParameterError(msg.message());
+	}
+      }
     }
     
   private:
 
     std::string id;
 
-    typedef std::map<std::string, UndirEdge*> UndirEdgeReaders;
+    typedef std::map<std::string, 
+		     _reader_bits::ItemStore<UndirEdge> > UndirEdgeReaders;
     UndirEdgeReaders undirEdgeReaders;
-    std::auto_ptr<IdReaderBase<UndirEdge> > undirEdgeIdReader;
+    std::auto_ptr<_reader_bits::IdReaderBase<UndirEdge> > undirEdgeIdReader;
 
-    typedef std::map<std::string, Edge*> EdgeReaders;
+    typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders;
     EdgeReaders edgeReaders;
-    std::auto_ptr<IdReaderBase<Edge> > edgeIdReader;
+    std::auto_ptr<_reader_bits::IdReaderBase<Edge> > edgeIdReader;
   };
 
   /// \ingroup io_group
@@ -1752,8 +1845,8 @@
   ///
   /// \relates LemonReader
   template <typename _Traits = DefaultReaderTraits>
-  class AttributeReader : public CommonSectionReaderBase {
-    typedef CommonSectionReaderBase Parent;
+  class AttributeReader : public LemonReader::SectionReader {
+    typedef LemonReader::SectionReader Parent;
     typedef _Traits Traits; 
   public:
     /// \brief Constructor.
@@ -1801,8 +1894,8 @@
 	msg << "Multiple read rule for attribute: " << name;
 	throw IOParameterError(msg.message());
       }
-      readers.insert(make_pair(name, new ValueReader<Value, Reader>
-      			       (value, reader)));
+      readers.insert(make_pair(name, new _reader_bits::
+			       ValueReader<Value, Reader>(value, reader)));
       return *this;
     }
 
@@ -1840,7 +1933,7 @@
   private:
     std::string id;
 
-    typedef std::map<std::string, ValueReaderBase*> Readers;
+    typedef std::map<std::string, _reader_bits::ValueReaderBase*> Readers;
     Readers readers;  
   };
 
diff -r eaa5f5b855f7 -r f8bbfed86036 lemon/lemon_writer.h
--- a/lemon/lemon_writer.h	Sat Dec 03 18:15:43 2005 +0000
+++ b/lemon/lemon_writer.h	Sat Dec 03 18:17:29 2005 +0000
@@ -164,6 +164,95 @@
       typedef ConstYMap<Map> Type;
     };
 
+
+    template <typename _Item>    
+    class MapWriterBase {
+    public:
+      typedef _Item Item;
+
+      virtual ~MapWriterBase() {}
+
+      virtual void write(std::ostream& os, const Item& item) = 0;
+    };
+
+
+    template <typename _Item, typename _Map, typename _Writer>
+    class MapWriter : public MapWriterBase<_Item> {
+    public:
+      typedef _Map Map;
+      typedef _Writer Writer;
+      typedef typename Writer::Value Value;
+      typedef _Item Item;
+      
+      typename _writer_bits::Ref<Map>::Type map;
+      Writer writer;
+
+      MapWriter(const Map& _map, const Writer& _writer) 
+	: map(_map), writer(_writer) {}
+
+      virtual ~MapWriter() {}
+
+      virtual void write(std::ostream& os, const Item& item) {
+	Value value = map[item];
+	writer.write(os, value);
+      }
+
+    };
+
+
+    class ValueWriterBase {
+    public:
+      virtual ~ValueWriterBase() {}
+      virtual void write(std::ostream&) = 0;
+    };
+
+    template <typename _Value, typename _Writer>
+    class ValueWriter : public ValueWriterBase {
+    public:
+      typedef _Value Value;
+      typedef _Writer Writer;
+
+      ValueWriter(const Value& _value, const Writer& _writer)
+ 	: value(_value), writer(_writer) {}
+
+      virtual void write(std::ostream& os) {
+	writer.write(os, value);
+      }
+    private:
+      const Value& value;
+      Writer writer;
+    };
+    
+
+    template <typename _Item>
+    class IdWriterBase {
+    public:
+      typedef _Item Item;
+      virtual ~IdWriterBase() {}
+      virtual void write(std::ostream&, const Item&) const = 0;
+      virtual bool isIdWriter() const = 0;
+    };
+
+    template <typename _Item, typename _BoxedIdWriter>
+    class IdWriter : public IdWriterBase<_Item> {
+    public:
+      typedef _Item Item;
+      typedef _BoxedIdWriter BoxedIdWriter;
+
+      const BoxedIdWriter& idWriter;
+
+      IdWriter(const BoxedIdWriter& _idWriter) 
+	: idWriter(_idWriter) {}
+
+      virtual void write(std::ostream& os, const Item& item) const {
+	idWriter.writeId(os, item);
+      }
+
+      virtual bool isIdWriter() const {
+	return idWriter.isIdWriter();
+      }
+    };
+
   }
 
   /// \ingroup io_group
@@ -281,109 +370,6 @@
 
   };
 
-  /// \brief Helper class for implementing the common SectionWriters.
-  ///
-  /// Helper class for implementing the common SectionWriters.
-  class CommonSectionWriterBase : public LemonWriter::SectionWriter {
-    typedef LemonWriter::SectionWriter Parent;
-  protected:
-    
-    /// \brief Constructor for CommonSectionWriterBase.
-    ///
-    /// Constructor for CommonSectionWriterBase. It attach this writer to
-    /// the given LemonWriter.
-    CommonSectionWriterBase(LemonWriter& _writer) 
-      : Parent(_writer) {}
-
-    template <typename _Item>    
-    class WriterBase {
-    public:
-      typedef _Item Item;
-
-      virtual ~WriterBase() {}
-
-      virtual void write(std::ostream& os, const Item& item) = 0;
-    };
-
-
-    template <typename _Item, typename _Map, typename _Writer>
-    class MapWriter : public WriterBase<_Item> {
-    public:
-      typedef _Map Map;
-      typedef _Writer Writer;
-      typedef typename Writer::Value Value;
-      typedef _Item Item;
-      
-      typename _writer_bits::Ref<Map>::Type map;
-      Writer writer;
-
-      MapWriter(const Map& _map, const Writer& _writer) 
-	: map(_map), writer(_writer) {}
-
-      virtual ~MapWriter() {}
-
-      virtual void write(std::ostream& os, const Item& item) {
-	Value value = map[item];
-	writer.write(os, value);
-      }
-
-    };
-
-
-    class ValueWriterBase {
-    public:
-      virtual ~ValueWriterBase() {}
-      virtual void write(std::ostream&) = 0;
-    };
-
-    template <typename _Value, typename _Writer>
-    class ValueWriter : public ValueWriterBase {
-    public:
-      typedef _Value Value;
-      typedef _Writer Writer;
-
-      ValueWriter(const Value& _value, const Writer& _writer)
- 	: value(_value), writer(_writer) {}
-
-      virtual void write(std::ostream& os) {
-	writer.write(os, value);
-      }
-    private:
-      const Value& value;
-      Writer writer;
-    };
-    
-
-    template <typename _Item>
-    class IdWriterBase {
-    public:
-      typedef _Item Item;
-      virtual ~IdWriterBase() {}
-      virtual void write(std::ostream&, const Item&) const = 0;
-      virtual bool isIdWriter() const = 0;
-    };
-
-    template <typename _Item, typename _BoxedIdWriter>
-    class IdWriter : public IdWriterBase<_Item> {
-    public:
-      typedef _Item Item;
-      typedef _BoxedIdWriter BoxedIdWriter;
-
-      const BoxedIdWriter& idWriter;
-
-      IdWriter(const BoxedIdWriter& _idWriter) 
-	: idWriter(_idWriter) {}
-
-      virtual void write(std::ostream& os, const Item& item) const {
-	idWriter.writeId(os, item);
-      }
-
-      virtual bool isIdWriter() const {
-	return idWriter.isIdWriter();
-      }
-    };
-  };
-
   /// \ingroup io_group
   /// \brief SectionWriter for writing a graph's nodeset.
   ///
@@ -403,8 +389,8 @@
   ///
   /// \relates LemonWriter
   template <typename _Graph, typename _Traits = DefaultWriterTraits>
-  class NodeSetWriter : public CommonSectionWriterBase {
-    typedef CommonSectionWriterBase Parent;
+  class NodeSetWriter : public LemonWriter::SectionWriter {
+    typedef LemonWriter::SectionWriter Parent;
   public:
 
     typedef _Graph Graph;
@@ -457,7 +443,8 @@
       checkConcept<concept::ReadMap<Node, typename Map::Value>, Map>();
       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
       writers.push_back(
-	make_pair(name, new MapWriter<Node, Map, Writer>(map, writer)));
+	make_pair(name, new _writer_bits::
+		  MapWriter<Node, Map, Writer>(map, writer)));
       return *this;
     }
 
@@ -527,10 +514,11 @@
 
   private:
 
-    typedef std::vector<std::pair<std::string, WriterBase<Node>*> > MapWriters;
+    typedef std::vector<std::pair<std::string, _writer_bits::
+				  MapWriterBase<Node>*> > MapWriters;
     MapWriters writers;
 
-    WriterBase<Node>* idMap;
+    _writer_bits::MapWriterBase<Node>* idMap;
     bool forceIdMap;
    
     const Graph& graph;   
@@ -562,8 +550,8 @@
   ///
   /// \relates LemonWriter
   template <typename _Graph, typename _Traits = DefaultWriterTraits>
-  class EdgeSetWriter : public CommonSectionWriterBase {
-    typedef CommonSectionWriterBase Parent;
+  class EdgeSetWriter : public LemonWriter::SectionWriter {
+    typedef LemonWriter::SectionWriter Parent;
   public:
 
     typedef _Graph Graph;
@@ -586,7 +574,8 @@
       : Parent(_writer), idMap(0), forceIdMap(_forceIdMap),
 	graph(_graph), id(_id) {
       checkConcept<_writer_bits::ItemIdWriter<Node>, NodeIdWriter>();
-      nodeIdWriter.reset(new IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
+      nodeIdWriter.reset(new _writer_bits::
+			 IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
     } 
 
     /// \brief Destructor.
@@ -623,7 +612,8 @@
       checkConcept<concept::ReadMap<Edge, typename Map::Value>, Map>();
       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
       writers.push_back(
-	make_pair(name, new MapWriter<Edge, Map, Writer>(map, writer)));
+	make_pair(name, new _writer_bits::
+		  MapWriter<Edge, Map, Writer>(map, writer)));
       return *this;
     }
 
@@ -701,16 +691,17 @@
 
   private:
 
-    typedef std::vector<std::pair<std::string, WriterBase<Edge>*> > MapWriters;
+    typedef std::vector<std::pair<std::string, _writer_bits::
+				  MapWriterBase<Edge>*> > MapWriters;
     MapWriters writers;
 
-    WriterBase<Edge>* idMap;
+    _writer_bits::MapWriterBase<Edge>* idMap;
     bool forceIdMap;
    
     const Graph& graph;   
     std::string id;
 
-    std::auto_ptr<IdWriterBase<Node> > nodeIdWriter;
+    std::auto_ptr<_writer_bits::IdWriterBase<Node> > nodeIdWriter;
   };
 
   /// \ingroup io_group
@@ -743,8 +734,8 @@
   ///
   /// \relates LemonWriter
   template <typename _Graph, typename _Traits = DefaultWriterTraits>
-  class UndirEdgeSetWriter : public CommonSectionWriterBase {
-    typedef CommonSectionWriterBase Parent;
+  class UndirEdgeSetWriter : public LemonWriter::SectionWriter {
+    typedef LemonWriter::SectionWriter Parent;
   public:
 
     typedef _Graph Graph;
@@ -768,7 +759,8 @@
       : Parent(_writer), idMap(0), forceIdMap(_forceIdMap),
 	graph(_graph), id(_id) {
       checkConcept<_writer_bits::ItemIdWriter<Node>, NodeIdWriter>();
-      nodeIdWriter.reset(new IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
+      nodeIdWriter.reset(new _writer_bits::
+			 IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
     } 
 
     /// \brief Destructor.
@@ -805,7 +797,8 @@
       checkConcept<concept::ReadMap<UndirEdge, typename Map::Value>, Map>();
       checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
       writers.push_back(
-	make_pair(name, new MapWriter<UndirEdge, Map, Writer>(map, writer)));
+	make_pair(name, new _writer_bits::
+		  MapWriter<UndirEdge, Map, Writer>(map, writer)));
       return *this;
     }
 
@@ -928,17 +921,17 @@
 
   private:
 
-    typedef std::vector<std::pair<std::string, 
-				  WriterBase<UndirEdge>*> > MapWriters;
+    typedef std::vector<std::pair<std::string, _writer_bits::
+				  MapWriterBase<UndirEdge>*> > MapWriters;
     MapWriters writers;
 
-    WriterBase<UndirEdge>* idMap;
+    _writer_bits::MapWriterBase<UndirEdge>* idMap;
     bool forceIdMap;
    
     const Graph& graph;   
     std::string id;
 
-    std::auto_ptr<IdWriterBase<Node> > nodeIdWriter;
+    std::auto_ptr<_writer_bits::IdWriterBase<Node> > nodeIdWriter;
   };
 
   /// \ingroup io_group
@@ -952,8 +945,8 @@
   ///
   /// \relates LemonWriter
   template <typename _Graph>
-  class NodeWriter : public CommonSectionWriterBase {
-    typedef CommonSectionWriterBase Parent;
+  class NodeWriter : public LemonWriter::SectionWriter {
+    typedef LemonWriter::SectionWriter Parent;
     typedef _Graph Graph;
     typedef typename Graph::Node Node;
   public:
@@ -968,7 +961,7 @@
 	       const std::string& _id = std::string()) 
       : Parent(_writer), id(_id) {
       checkConcept<_writer_bits::ItemIdWriter<Node>, _IdWriter>();
-      idWriter.reset(new IdWriter<Node, _IdWriter>(_idWriter));
+      idWriter.reset(new _writer_bits::IdWriter<Node, _IdWriter>(_idWriter));
     }
 
 
@@ -1020,7 +1013,7 @@
 
     typedef std::vector<std::pair<std::string, const Node*> > NodeWriters;
     NodeWriters writers;
-    std::auto_ptr<IdWriterBase<Node> > idWriter;
+    std::auto_ptr<_writer_bits::IdWriterBase<Node> > idWriter;
   };
 
   /// \ingroup io_group
@@ -1034,8 +1027,8 @@
   ///
   /// \relates LemonWriter
   template <typename _Graph>
-  class EdgeWriter : public CommonSectionWriterBase {
-    typedef CommonSectionWriterBase Parent;
+  class EdgeWriter : public LemonWriter::SectionWriter {
+    typedef LemonWriter::SectionWriter Parent;
     typedef _Graph Graph;
     typedef typename Graph::Edge Edge;
   public:
@@ -1050,7 +1043,7 @@
 	       const std::string& _id = std::string()) 
       : Parent(_writer), id(_id) {
       checkConcept<_writer_bits::ItemIdWriter<Edge>, _IdWriter>();
-      idWriter.reset(new IdWriter<Edge, _IdWriter>(_idWriter));
+      idWriter.reset(new _writer_bits::IdWriter<Edge, _IdWriter>(_idWriter));
     }
 
     /// \brief Destructor.
@@ -1101,7 +1094,7 @@
     typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters;
     EdgeWriters writers;
 
-    std::auto_ptr<IdWriterBase<Edge> > idWriter;
+    std::auto_ptr<_writer_bits::IdWriterBase<Edge> > idWriter;
   };
 
   /// \ingroup io_group
@@ -1115,8 +1108,8 @@
   ///
   /// \relates LemonWriter
   template <typename _Graph>
-  class UndirEdgeWriter : public CommonSectionWriterBase {
-    typedef CommonSectionWriterBase Parent;
+  class UndirEdgeWriter : public LemonWriter::SectionWriter {
+    typedef LemonWriter::SectionWriter Parent;
     typedef _Graph Graph;
     typedef typename Graph::Node Node;
     typedef typename Graph::Edge Edge;
@@ -1135,8 +1128,10 @@
       : Parent(_writer), id(_id) {
       checkConcept<_writer_bits::ItemIdWriter<Edge>, _IdWriter>();
       checkConcept<_writer_bits::ItemIdWriter<UndirEdge>, _IdWriter>();
-      undirEdgeIdWriter.reset(new IdWriter<UndirEdge, _IdWriter>(_idWriter));
-      edgeIdWriter.reset(new IdWriter<Edge, _IdWriter>(_idWriter));
+      undirEdgeIdWriter.reset(new _writer_bits::
+			      IdWriter<UndirEdge, _IdWriter>(_idWriter));
+      edgeIdWriter.reset(new _writer_bits::
+			 IdWriter<Edge, _IdWriter>(_idWriter));
     }
 
     /// \brief Destructor.
@@ -1202,11 +1197,11 @@
     typedef std::vector<std::pair<std::string, 
 				  const UndirEdge*> > UndirEdgeWriters;
     UndirEdgeWriters undirEdgeWriters;
-    std::auto_ptr<IdWriterBase<UndirEdge> > undirEdgeIdWriter;
+    std::auto_ptr<_writer_bits::IdWriterBase<UndirEdge> > undirEdgeIdWriter;
 
     typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters;
     EdgeWriters edgeWriters;
-    std::auto_ptr<IdWriterBase<Edge> > edgeIdWriter;
+    std::auto_ptr<_writer_bits::IdWriterBase<Edge> > edgeIdWriter;
 
   };
 
@@ -1222,8 +1217,8 @@
   ///
   /// \relates LemonWriter
   template <typename _Traits = DefaultWriterTraits>
-  class AttributeWriter : public CommonSectionWriterBase {
-    typedef CommonSectionWriterBase Parent;
+  class AttributeWriter : public LemonWriter::SectionWriter {
+    typedef LemonWriter::SectionWriter Parent;
     typedef _Traits Traits; 
   public:
     /// \brief Constructor.
@@ -1267,8 +1262,8 @@
 				    const Value& value,
 				    const Writer& writer = Writer()) {
       checkConcept<_writer_bits::ItemWriter<Value>, Writer>();
-      writers.push_back(make_pair(name, new ValueWriter<Value, Writer>
-      			       (value, writer)));
+      writers.push_back(make_pair(name, new _writer_bits::
+				  ValueWriter<Value, Writer>(value, writer)));
       return *this;
     }
 
@@ -1296,7 +1291,8 @@
   private:
     std::string id;
 
-    typedef std::vector<std::pair<std::string, ValueWriterBase*> > Writers;
+    typedef std::vector<std::pair<std::string, 
+				  _writer_bits::ValueWriterBase*> > Writers;
     Writers writers;  
   };
 
diff -r eaa5f5b855f7 -r f8bbfed86036 test/heap_test.cc
--- a/test/heap_test.cc	Sat Dec 03 18:15:43 2005 +0000
+++ b/test/heap_test.cc	Sat Dec 03 18:17:29 2005 +0000
@@ -56,7 +56,7 @@
   std::ifstream input(f_name.c_str());
   check(input, "Input file '" << f_name << "' not found.");
   GraphReader<Graph>(input, graph).
-    readEdgeMap("length", length).
+    readEdgeMap("capacity", length).
     readNode("source", start).
     run();