lemon-0.x: comparison lemon/lemon

equal deleted inserted replaced

-:a7e529c07088
+:a3b5f521c9f6
 namespace lemon {
 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:
 bool isIdReader() { return true; }
 	_ItemReader& reader;
 	std::istream& is;
 };
 };
-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; };
 template <typename Map>
 struct Arg { typedef Map& Type; };
 typedef YMap<Map> Type;
 };
 template <typename Map>
 struct Arg<YMap<Map> > {
 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
 typedef std::vector<SectionReader*> SectionReaders;
 SectionReaders readers;
 };
-/// \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.
 ///
 /// The lemon format can store multiple graph nodesets with several maps.
 /// The nodeset section's header line is \c \@nodeset \c nodeset_id, but the
 /// \c readId() member will read a value from the given stream it will
 /// give back that node which is mapped to this value.
 ///
 /// \relates LemonReader
 template <typename _Graph, typename _Traits = DefaultReaderTraits>
-class NodeSetReader : public CommonSectionReaderBase {
+class NodeSetReader : public LemonReader::SectionReader {
-typedef CommonSectionReaderBase Parent;
+typedef LemonReader::SectionReader Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
 typedef typename Graph::Node Node;
 checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
 if (readers.find(name) != readers.end()) {
 	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;
 }
 public:
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 	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;
 }
 protected:
 /// \brief Reader function of the section.
 ///
 /// 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);
 std::istringstream ls(line);
 while (ls >> id) {
 	typename MapReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
+	  it->second->touch();
 	  index.push_back(it->second);
 	} else {
 	  index.push_back(&skipper);
 	}
 	if (id == "id" && inverter.get() == 0) {
 	  inverter.reset(index.back()->getInverter());
 	  index.back() = inverter.get();
+	}
+}
+for (typename MapReaders::iterator it = readers.begin();
+	   it != readers.end(); ++it) {
+	if (!it->second->touched()) {
+	  ErrorMessage msg;
+	  msg << "Map not found in file: " << it->first;
+	  throw IOParameterError(msg.message());
 	}
 }
 while (getline(is, line)) {
 	Node node = graph.addNode();
 	std::istringstream ls(line);
 node = inverter->read(is);
 }
 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
 /// \brief SectionReader for reading a graph's edgeset.
 ///
 /// have to be connected. If a NodeSetReader reads an "id" named map,
 /// it will be able to resolve the nodes by ids.
 ///
 /// \relates LemonReader
 template <typename _Graph, typename _Traits = DefaultReaderTraits>
-class EdgeSetReader : public CommonSectionReaderBase {
+class EdgeSetReader : public LemonReader::SectionReader {
-typedef CommonSectionReaderBase Parent;
+typedef LemonReader::SectionReader Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
 typedef typename Graph::Node Node;
 		  const NodeIdReader& _nodeIdReader,
 		  const std::string& _id = std::string(),
 		  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.
 ///
 /// Destructor for EdgeSetReader.
 virtual ~EdgeSetReader() {
 	ErrorMessage msg;
 	msg << "Multiple read rule for edge map: " << name;
 	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;
 }
 public:
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 	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;
 }
 protected:
 /// It reads the content of the section.
 virtual void read(std::istream& is) {
 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);
 std::istringstream ls(line);
 while (ls >> id) {
 	typename MapReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
 	  index.push_back(it->second);
+	  it->second->touch();
 	} else {
 	  index.push_back(&skipper);
 	}
 	if (id == "id" && inverter.get() == 0) {
 	  inverter.reset(index.back()->getInverter());
 	  index.back() = inverter.get();
+	}
+}
+for (typename MapReaders::iterator it = readers.begin();
+	   it != readers.end(); ++it) {
+	if (!it->second->touched()) {
+	  ErrorMessage msg;
+	  msg << "Map not found in file: " << it->first;
+	  throw IOParameterError(msg.message());
 	}
 }
 while (getline(is, line)) {
 	std::istringstream ls(line);
 	Node from = nodeIdReader->read(ls);
 edge = inverter->read(is);
 }
 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<_reader_bits::MapInverterBase<Edge> > inverter;
-std::auto_ptr<IdReaderBase<Node> > nodeIdReader;
+std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading a undirected graph's edgeset.
 ///
 /// nodes have to be connected. If a NodeSetReader reads an "id" named map,
 /// it will be able to resolve the nodes by ids.
 ///
 /// \relates LemonReader
 template <typename _Graph, typename _Traits = DefaultReaderTraits>
-class UndirEdgeSetReader : public CommonSectionReaderBase {
+class UndirEdgeSetReader : public LemonReader::SectionReader {
-typedef CommonSectionReaderBase Parent;
+typedef LemonReader::SectionReader Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
 typedef typename Graph::Node Node;
 		       const NodeIdReader& _nodeIdReader,
 		       const std::string& _id = std::string(),
 		       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.
 ///
 /// Destructor for UndirEdgeSetReader.
 virtual ~UndirEdgeSetReader() {
 	ErrorMessage msg;
 	msg << "Multiple read rule for edge map: " << name;
 	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;
 }
 public:
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 	msg << "Multiple read rule for node map: " << name;
 	throw IOParameterError(msg.message());
 }
-readers.insert(make_pair(name,
+readers.insert(make_pair(name, new _reader_bits::
-			       new SkipReader<UndirEdge, Reader>(reader)));
+			       SkipReader<UndirEdge, Reader>(reader)));
 return *this;
 }
 /// \brief Add a new directed edge map reader command for the reader.
 ///
 /// It reads the content of the section.
 virtual void read(std::istream& is) {
 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);
 std::istringstream ls(line);
 while (ls >> id) {
 	typename MapReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
 	  index.push_back(it->second);
+	  it->second->touch();
 	} else {
 	  index.push_back(&skipper);
 	}
 	if (id == "id" && inverter.get() == 0) {
 	  inverter.reset(index.back()->getInverter());
 	  index.back() = inverter.get();
+	}
+}
+for (typename MapReaders::iterator it = readers.begin();
+	   it != readers.end(); ++it) {
+	if (!it->second->touched()) {
+	  ErrorMessage msg;
+	  msg << "Map not found in file: " << it->first;
+	  throw IOParameterError(msg.message());
 	}
 }
 while (getline(is, line)) {
 	std::istringstream ls(line);
 	Node from = nodeIdReader->read(ls);
 }
 }
 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<_reader_bits::MapInverterBase<UndirEdge> > inverter;
-std::auto_ptr<IdReaderBase<Node> > nodeIdReader;
+std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading labeled nodes.
 ///
 /// Each line in the section contains the name of the node
 /// and then the node id.
 ///
 /// \relates LemonReader
 template <typename _Graph>
-class NodeReader : public CommonSectionReaderBase {
+class NodeReader : public LemonReader::SectionReader {
-typedef CommonSectionReaderBase Parent;
+typedef LemonReader::SectionReader Parent;
 typedef _Graph Graph;
 typedef typename Graph::Node Node;
 public:
 /// \brief Constructor.
 template <typename _IdReader>
 NodeReader(LemonReader& _reader, const _IdReader& _idReader,
 	       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.
 ///
 /// Destructor for NodeReader.
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 	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:
 /// \brief Gives back true when the SectionReader can process
 	std::istringstream ls(line);
 	std::string id;
 	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
 /// \brief SectionReader for reading labeled edges.
 ///
 /// Each line in the section contains the name of the edge
 /// and then the edge id.
 ///
 /// \relates LemonReader
 template <typename _Graph>
-class EdgeReader : public CommonSectionReaderBase {
+class EdgeReader : public LemonReader::SectionReader {
-typedef CommonSectionReaderBase Parent;
+typedef LemonReader::SectionReader Parent;
 typedef _Graph Graph;
 typedef typename Graph::Edge Edge;
 public:
 /// \brief Constructor.
 template <typename _IdReader>
 EdgeReader(LemonReader& _reader, const _IdReader& _idReader,
 	       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.
 ///
 /// Destructor for EdgeReader.
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 	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:
 /// \brief Gives back true when the SectionReader can process
 	std::istringstream ls(line);
 	std::string id;
 	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
 /// \brief SectionReader for reading labeled undirected edges.
 ///
 /// Each line in the section contains the name of the undirected edge
 /// and then the undirected edge id.
 ///
 /// \relates LemonReader
 template <typename _Graph>
-class UndirEdgeReader : public CommonSectionReaderBase {
+class UndirEdgeReader : public LemonReader::SectionReader {
-typedef CommonSectionReaderBase Parent;
+typedef LemonReader::SectionReader Parent;
 typedef _Graph Graph;
 typedef typename Graph::Edge Edge;
 typedef typename Graph::UndirEdge UndirEdge;
 public:
 UndirEdgeReader(LemonReader& _reader, const _IdReader& _idReader,
 	       const std::string& _id = std::string())
 : Parent(_reader), id(_id) {
 checkConcept<_reader_bits::ItemIdReader<UndirEdge>, _IdReader>();
 checkConcept<_reader_bits::ItemIdReader<Edge>, _IdReader>();
-undirEdgeIdReader.reset(new IdReader<UndirEdge, _IdReader>(_idReader));
+undirEdgeIdReader.reset(new _reader_bits::
-edgeIdReader.reset(new IdReader<Edge, _IdReader>(_idReader));
+			      IdReader<UndirEdge, _IdReader>(_idReader));
+edgeIdReader.reset(new _reader_bits::
+			 IdReader<Edge, _IdReader>(_idReader));
 }
 /// \brief Destructor.
 ///
 /// Destructor for UndirEdgeReader.
 if (undirEdgeReaders.find(name) != undirEdgeReaders.end()) {
 	ErrorMessage msg;
 	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.
 ///
 /// Add an edge reader command for the UndirEdgeReader.
 if (edgeReaders.find(name) != edgeReaders.end()) {
 	ErrorMessage msg;
 	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:
 /// \brief Gives back true when the SectionReader can process
 	std::string id;
 	ls >> id;
 	{
 	  typename UndirEdgeReaders::iterator it = undirEdgeReaders.find(id);
 	  if (it != undirEdgeReaders.end()) {
-	    *(it->second) = undirEdgeIdReader->read(ls);
+	    it->second.read(undirEdgeIdReader->read(ls));
-	    break;
+	    it->second.touch();
+	    continue;
 	  }
 	} {
 	  typename EdgeReaders::iterator it = edgeReaders.find(id);
 	  if (it != edgeReaders.end()) {
-	    *(it->second) = edgeIdReader->read(ls);
+	    it->second.read(edgeIdReader->read(ls));
-	    break;
+	    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
 /// \brief SectionReader for attributes.
 ///
 /// The attributeset section contains several lines. Each of them starts
 /// with an attribute and then a the value for the id.
 ///
 /// \relates LemonReader
 template <typename _Traits = DefaultReaderTraits>
-class AttributeReader : public CommonSectionReaderBase {
+class AttributeReader : public LemonReader::SectionReader {
-typedef CommonSectionReaderBase Parent;
+typedef LemonReader::SectionReader Parent;
 typedef _Traits Traits;
 public:
 /// \brief Constructor.
 ///
 /// Constructor for AttributeReader. It creates the AttributeReader and
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 	msg << "Multiple read rule for attribute: " << name;
 	throw IOParameterError(msg.message());
 }
-readers.insert(make_pair(name, new ValueReader<Value, Reader>
+readers.insert(make_pair(name, new _reader_bits::
-			       (value, reader)));
+			       ValueReader<Value, Reader>(value, reader)));
 return *this;
 }
 protected:
 }
 private:
 std::string id;
-typedef std::map<std::string, ValueReaderBase*> Readers;
+typedef std::map<std::string, _reader_bits::ValueReaderBase*> Readers;
 Readers readers;
 };
 /// \ingroup io_group
 /// \brief SectionReader for retrieve what is in the file.

changeset 1845	f8bbfed86036
parent 1746	874e4bc21435
child 1846	6b4e38acef1c