lemon-0.x: comparison src/lemon/lemon

equal deleted inserted replaced

-:c2499068d11d
+:eebb67bff1d6
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <lemon/error.h>
-#include "item_reader.h"
+#include <lemon/bits/item_reader.h>
 namespace lemon {
-/// \addtogroup io_group
+/// \ingroup io_group
-/// @{
 /// \brief Lemon Format reader class.
 ///
+/// The Lemon Format contains several sections. We do not want to
+/// determine what sections are in a lemon file we give only a framework
+/// to read a section oriented format.
+///
+/// In the Lemon Format each section starts with a line contains a \c \@
+/// character on the first not white space position. This line is the
+/// header line of the section. Each next lines belong to this section
+/// while it does not starts with \c \@ character. This line can start a
+/// new section or if it can close the file with the \c \@end line.
+/// The file format ignore the empty lines and it may contain comments
+/// started with a \c # character to the end of the line.
+///
+/// The framework provides an abstract LemonReader::SectionReader class
+/// what defines the interface of a SectionReader. The SectionReader
+/// has the \c header() member function what get a header line string and
+/// decides if it want to process the next section. Several SectionReaders
+/// can be attached to an LemonReader and the first attached what can
+/// process the section will be used. Its \c read() member will called
+/// with a stream contains the section. From this stream the empty lines
+/// and comments are filtered out.
+///
+/// \relates GraphReader
+/// \relates NodeSetReader
+/// \relates EdgeSetReader
+/// \relates NodesReader
+/// \relates EdgesReader
+/// \relates AttributeReader
 class LemonReader {
 private:
 class FilterStreamBuf : public std::streambuf {
 public:
 }
 };
 public:
+/// \brief Abstract base class for reading a section.
+///
+/// This class has an \c header() member function what get a
+/// header line string and decides if it want to process the next
+/// section. Several SectionReaders can be attached to an LemonReader
+/// and the first attached what can process the section will be used.
+/// Its \c read() member will called with a stream contains the section.
+/// From this stream the empty lines and comments are filtered out.
 class SectionReader {
-public:
+friend class LemonReader;
-/// \e
+protected:
+/// \brief Constructor for SectionReader.
+///
+/// Constructor for SectionReader. It attach this reader to
+/// the given LemonReader.
+SectionReader(LemonReader& reader) {
+	reader.attach(*this);
+}
+/// \brief Gives back true when the SectionReader can process
+/// the section with the given header line.
+///
+/// It gives back true when the SectionReader can process
+/// the section with the given header line.
 virtual bool header(const std::string& line) = 0;
-/// \e
+/// \brief Reader function of the section.
+///
+/// It reads the content of the section.
 virtual void read(std::istream& is) = 0;
 };
-/// \e
+/// \brief Constructor for LemonReader.
+///
+/// Constructor for LemonReader which reads from the given stream.
 LemonReader(std::istream& _is)
 : is(&_is), own_is(false) {}
+/// \brief Constructor for LemonReader.
+///
+/// Constructor for LemonReader which reads from the given file.
 LemonReader(const std::string& filename)
 : is(0), own_is(true) {
 is = new std::ifstream(filename.c_str());
 }
+/// \brief Desctructor for LemonReader.
+///
+/// Desctructor for LemonReader.
 ~LemonReader() {
 if (own_is) {
 	delete is;
 }
 }
 private:
 LemonReader(const LemonReader&);
 void operator=(const LemonReader&);
-public:
-/// \e
 void attach(SectionReader& reader) {
 readers.push_back(&reader);
 }
-/// \e
+public:
-void detach(SectionReader& reader) {
+/// \brief Executes the LemonReader.
-std::vector<SectionReader*>::iterator it =
+///
-	std::find(readers.begin(), readers.end(), &reader);
+/// It executes the LemonReader.
-if (it != readers.end()) {
-	readers.erase(it);
-}
-}
-/// \e
 void run() {
 int line_num = 0;
 std::string line;
 try {
 	while ((++line_num, getline(*is, line)) && line.find("@end") != 0) {
 typedef std::vector<SectionReader*> SectionReaders;
 SectionReaders readers;
 };
+/// \brief Helper class for implementing the common SectionReaders.
-/// \e
+///
+/// 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> {
 	return new SkipReaderInverter<Item, Reader>(reader);
 }
 };
 template <typename _Item>
-class ResolverReaderBase {
+class IdReaderBase {
 public:
 typedef _Item Item;
-virtual Item resolve(std::istream& is) const = 0;
+virtual Item read(std::istream& is) const = 0;
 };
-template <typename _Item, typename _Resolver>
+template <typename _Item, typename _BoxedIdReader>
-class ResolverReader : public ResolverReaderBase<_Item> {
+class IdReader : public IdReaderBase<_Item> {
 public:
 typedef _Item Item;
-typedef _Resolver Resolver;
+typedef _BoxedIdReader BoxedIdReader;
-const Resolver& resolver;
+const BoxedIdReader& boxedIdReader;
-ResolverReader(const Resolver& _resolver)
+IdReader(const BoxedIdReader& _boxedIdReader)
-	: resolver(_resolver) {}
+	: boxedIdReader(_boxedIdReader) {}
-virtual Item resolve(std::istream& is) const {
+virtual Item read(std::istream& is) const {
-	return resolver.resolve(is);
+	return boxedIdReader.readId(is);
 }
 };
 class ValueReaderBase {
 public:
 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 nodeset_id may be empty.
+///
+/// The first line of the section contains the names of the maps separated
+/// with white spaces. Each next lines describes a node in the nodeset, and
+/// contains the mapped values for each map.
+///
+/// If the nodeset contains an \c "id" named map then it will be regarded
+/// as id map. This map should contain only unique values and when 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 {
 typedef CommonSectionReaderBase Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
 typedef typename Graph::Node Item;
 typedef typename Traits::Skipper DefaultSkipper;
+/// \brief Constructor.
+///
+/// Constructor for NodeSetReader. It creates the NodeSetReader and
+/// attach it into the given LemonReader. The nodeset reader will
+/// add the readed nodes to the given Graph. The reader will read
+/// the section when the \c section_id and the \c _id are the same.
 NodeSetReader(LemonReader& _reader, Graph& _graph,
 		  const std::string& _id = std::string(),
-		  const DefaultSkipper& _defreader = DefaultSkipper())
+		  const DefaultSkipper& _skipper = DefaultSkipper())
-: graph(_graph), id(_id), skipper(_defreader) {
+: Parent(_reader), graph(_graph), id(_id), skipper(_skipper) {}
-_reader.attach(*this);
-}
+/// \brief Destructor.
+///
+/// Destructor for NodeSetReader.
 virtual ~NodeSetReader() {
 for (typename MapReaders::iterator it = readers.begin();
 	   it != readers.end(); ++it) {
 	delete it->second;
 }
 }
 readers.insert(make_pair(name, new SkipReader<Item, Reader>(reader)));
 return *this;
 }
-/// \e
+protected:
+/// \brief Gives back true when the SectionReader can process
+/// the section with the given header line.
+///
+/// It gives back true when the header line starts with \c @nodeset,
+/// and the header line's id and the nodeset's id are the same.
 virtual bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
 std::string name;
 ls >> command >> name;
 return command == "@nodeset" && name == id;
 }
-/// \e
+/// \brief Reader function of the section.
+///
+/// It reads the content of the section.
 virtual void read(std::istream& is) {
 std::vector<ReaderBase<Item>* > index;
 std::string line;
 getline(is, line);
 	  index[i]->read(ls, node);
 	}
 }
 }
-bool isResolver() const {
+public:
+/// \brief Returns true if the nodeset can give back the node by its id.
+///
+/// Returns true if the nodeset can give back the node by its id.
+/// It is possible only if an "id" named map was read.
+bool isIdReader() const {
 return inverter.get() != 0;
 }
-typename Graph::Node resolve(std::istream& is) const {
+/// \brief Gives back the node by its id.
+///
+/// It reads an id from the stream and gives back which node belongs to
+/// it. It is possible only if there was read an "id" named map.
+typename Graph::Node readId(std::istream& is) const {
 return inverter->read(is);
 }
 private:
 SkipReader<Item, DefaultSkipper> skipper;
 std::auto_ptr<InverterBase<Item> > inverter;
 };
+/// \ingroup io_group
+/// \brief SectionReader for reading a graph's edgeset.
-/// \e
+///
+/// The lemon format can store multiple graph edgesets with several maps.
+/// The edgeset section's header line is \c \@edgeset \c edgeset_id, but the
+/// \c edgeset_id may be empty.
+///
+/// The first line of the section contains the names of the maps separated
+/// with white spaces. Each next lines describes a node in the nodeset. The
+/// line contains the two nodes' id and the mapped values for each map.
+///
+/// If the edgeset contains an \c "id" named map then it will be regarded
+/// as id map. This map should contain only unique values and when the
+/// \c readId() member will read a value from the given stream it will
+/// give back that edge which is mapped to this value.
+///
+/// The edgeset reader needs a node id reader to identify which 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 EdgeSetReader : public CommonSectionReaderBase {
 typedef CommonSectionReaderBase Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
 typedef typename Graph::Edge Item;
 typedef typename Traits::Skipper DefaultSkipper;
-template <typename Resolver>
+/// \brief Constructor.
+///
+/// Constructor for EdgeSetReader. It creates the EdgeSetReader and
+/// attach it into the given LemonReader. The edgeset reader will
+/// add the readed edges to the given Graph. It will use the given
+/// node id reader to read the source and target nodes of the edges.
+/// The reader will read the section only if the \c _id and the
+/// \c edgset_id are the same.
+template <typename NodeIdReader>
 EdgeSetReader(LemonReader& _reader, Graph& _graph,
-		  const Resolver& _nodeResolver,
+		  const NodeIdReader& _nodeIdReader,
 		  const std::string& _id = std::string(),
-		  const DefaultSkipper& _defreader = DefaultSkipper())
+		  const DefaultSkipper& _skipper = DefaultSkipper())
-: graph(_graph), id(_id), skipper(_defreader),
+: Parent(_reader), graph(_graph), id(_id), skipper(_skipper),
-nodeResolver(new ResolverReader<typename Graph::Node, Resolver>
+	nodeIdReader(new IdReader<typename Graph::Node, NodeIdReader>
-		   (_nodeResolver)) {
+		     (_nodeIdReader)) {}
-_reader.attach(*this);
-}
+/// \brief Destructor.
+///
+/// Destructor for EdgeSetReader.
 virtual ~EdgeSetReader() {
 for (typename MapReaders::iterator it = readers.begin();
 	   it != readers.end(); ++it) {
 	delete it->second;
 }
 EdgeSetReader(const EdgeSetReader&);
 void operator=(const EdgeSetReader&);
 public:
-/// \brief Add a new node map reader command for the reader.
+/// \brief Add a new edge map reader command for the reader.
 ///
-/// Add a new node map reader command for the reader.
+/// Add a new edge map reader command for the reader.
 template <typename Map>
 EdgeSetReader& readMap(std::string name, Map& map) {
 return readMap<typename Traits::
 	template Reader<typename Map::Value>, Map>(name, map);
 }
-/// \brief Add a new node map reader command for the reader.
+/// \brief Add a new edge map reader command for the reader.
 ///
-/// Add a new node map reader command for the reader.
+/// Add a new edge map reader command for the reader.
 template <typename Reader, typename Map>
 EdgeSetReader& readMap(std::string name, Map& map,
 			     const Reader& reader = Reader()) {
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 readers.insert(
 	make_pair(name, new MapReader<Item, Map, Reader>(map, reader)));
 return *this;
 }
-/// \brief Add a new node map skipper command for the reader.
+/// \brief Add a new edge map skipper command for the reader.
 ///
-/// Add a new node map skipper command for the reader.
+/// Add a new edge map skipper command for the reader.
 template <typename Reader>
 EdgeSetReader& skipMap(std::string name,
 			   const Reader& reader = Reader()) {
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 }
 readers.insert(make_pair(name, new SkipReader<Item, Reader>(reader)));
 return *this;
 }
-/// \e
+protected:
+/// \brief Gives back true when the SectionReader can process
+/// the section with the given header line.
+///
+/// It gives back true when the header line starts with \c @edgeset,
+/// and the header line's id and the edgeset's id are the same.
 virtual bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
 std::string name;
 ls >> command >> name;
 return command == "@edgeset" && name == id;
 }
-/// \e
+/// \brief Reader function of the section.
+///
+/// It reads the content of the section.
 virtual void read(std::istream& is) {
 std::vector<ReaderBase<Item>* > index;
 std::string line;
 getline(is, line);
 	  index.back() = inverter.get();
 	}
 }
 while (getline(is, line)) {
 	std::istringstream ls(line);
-	typename Graph::Node from = nodeResolver->resolve(ls);
+	typename Graph::Node from = nodeIdReader->read(ls);
-	typename Graph::Node to = nodeResolver->resolve(ls);
+	typename Graph::Node to = nodeIdReader->read(ls);
 	typename Graph::Edge edge = graph.addEdge(from, to);
 	for (int i = 0; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, edge);
 	}
 }
 }
-bool isResolver() const {
+public:
+/// \brief Returns true if the edgeset can give back the edge by its id.
+///
+/// Returns true if the edgeset can give back the edge by its id.
+/// It is possible only if an "id" named map was read.
+bool isIdReader() const {
 return inverter.get() != 0;
 }
-typename Graph::Edge resolve(std::istream& is) {
+/// \brief Gives back the edge by its id.
+///
+/// It reads an id from the stream and gives back which edge belongs to
+/// it. It is possible only if there was read an "id" named map.
+typename Graph::Edge readId(std::istream& is) const {
 return inverter->read(is);
 }
 private:
 Graph& graph;
 std::string id;
 SkipReader<Item, DefaultSkipper> skipper;
 std::auto_ptr<InverterBase<Item> > inverter;
-std::auto_ptr<ResolverReaderBase<typename Graph::Node> > nodeResolver;
+std::auto_ptr<IdReaderBase<typename Graph::Node> > nodeIdReader;
 };
+/// \ingroup io_group
-/// \e
+/// \brief SectionReader for reading labeled nodes.
+///
+/// The nodes section's header line is \c \@nodes \c nodes_id, but the
+/// \c nodes_id may be empty.
+///
+/// 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 {
+typedef CommonSectionReaderBase Parent;
+typedef _Graph Graph;
+typedef typename Graph::Node Item;
+public:
+/// \brief Constructor.
+///
+/// Constructor for NodeReader. It creates the NodeReader and
+/// attach it into the given LemonReader. It will use the given
+/// node id reader to give back the nodes. The reader will read the
+/// section only if the \c _id and the \c nodes_id are the same.
+template <typename _IdReader>
+NodeReader(LemonReader& _reader, const _IdReader& _idReader,
+	       const std::string& _id = std::string())
+: Parent(_reader), id(_id),
+	idReader(new IdReader<typename Graph::Node, _IdReader>(_idReader)) {}
+/// \brief Destructor.
+///
+/// Destructor for NodeReader.
+virtual ~NodeReader() {}
+private:
+NodeReader(const NodeReader&);
+void operator=(const NodeReader&);
+public:
+/// \brief Add a node reader command for the NodeReader.
+///
+/// Add a node reader command for the NodeReader.
+void readNode(const std::string& name, Item& item) {
+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));
+}
+protected:
+/// \brief Gives back true when the SectionReader can process
+/// the section with the given header line.
+///
+/// It gives back true when the header line start with \c @nodes,
+/// and the header line's id and the reader's id are the same.
+virtual bool header(const std::string& line) {
+std::istringstream ls(line);
+std::string command;
+std::string name;
+ls >> command >> name;
+return command == "@nodes" && name == id;
+}
+/// \brief Reader function of the section.
+///
+/// It reads the content of the section.
+virtual void read(std::istream& is) {
+std::string line;
+while (getline(is, line)) {
+	std::istringstream ls(line);
+	std::string id;
+	ls >> id;
+	typename ItemReaders::iterator it = readers.find(id);
+	if (it != readers.end()) {
+	  *(it->second) = idReader->read(ls);
+	}
+}
+}
+private:
+std::string id;
+typedef std::map<std::string, Item*> ItemReaders;
+ItemReaders readers;
+std::auto_ptr<IdReaderBase<Item> > idReader;
+};
+/// \ingroup io_group
+/// \brief SectionReader for reading labeled edges.
+///
+/// The edges section's header line is \c \@edges \c edges_id, but the
+/// \c edges_id may be empty.
+///
+/// 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 {
+typedef CommonSectionReaderBase Parent;
+typedef _Graph Graph;
+typedef typename Graph::Edge Item;
+public:
+/// \brief Constructor.
+///
+/// Constructor for EdgeReader. It creates the EdgeReader and
+/// attach it into the given LemonReader. It will use the given
+/// edge id reader to give back the edges. The reader will read the
+/// section only if the \c _id and the \c nodes_id are the same.
+template <typename _IdReader>
+EdgeReader(LemonReader& _reader, const _IdReader& _idReader,
+	       const std::string& _id = std::string())
+: Parent(_reader), id(_id),
+	idReader(new IdReader<typename Graph::Edge, _IdReader>(_idReader)) {}
+/// \brief Destructor.
+///
+/// Destructor for EdgeReader.
+virtual ~EdgeReader() {}
+private:
+EdgeReader(const EdgeReader&);
+void operator=(const EdgeReader&);
+public:
+/// \brief Add an edge reader command for the EdgeReader.
+///
+/// Add an edge reader command for the EdgeReader.
+void readEdge(const std::string& name, Item& item) {
+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));
+}
+protected:
+/// \brief Gives back true when the SectionReader can process
+/// the section with the given header line.
+///
+/// It gives back true when the header line start with \c @edges,
+/// and the header line's id and the reader's id are the same.
+virtual bool header(const std::string& line) {
+std::istringstream ls(line);
+std::string command;
+std::string name;
+ls >> command >> name;
+return command == "@edges" && name == id;
+}
+/// \brief Reader function of the section.
+///
+/// It reads the content of the section.
+virtual void read(std::istream& is) {
+std::string line;
+while (getline(is, line)) {
+	std::istringstream ls(line);
+	std::string id;
+	ls >> id;
+	typename ItemReaders::iterator it = readers.find(id);
+	if (it != readers.end()) {
+	  *(it->second) = idReader->read(ls);
+	}
+}
+}
+private:
+std::string id;
+typedef std::map<std::string, Item*> ItemReaders;
+ItemReaders readers;
+std::auto_ptr<IdReaderBase<Item> > idReader;
+};
+/// \ingroup io_group
+/// \brief SectionReader for attributes.
+///
+/// The lemon format can store multiple attribute set. Each set has
+/// the header line \c \@attributes \c attributeset_id, but the
+/// attributeset_id may be empty.
+///
+/// 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 {
 typedef CommonSectionReaderBase Parent;
 typedef _Traits Traits;
 public:
-/// \e
+/// \brief Constructor.
+///
+/// Constructor for AttributeReader. It creates the AttributeReader and
+/// attach it into the given LemonReader. The reader process a section
+/// only if the \c section_id and the \c _id are the same.
 AttributeReader(LemonReader& _reader,
-		    const std::string& _id = std::string()) : id(_id) {
+		    const std::string& _id = std::string())
-_reader.attach(*this);
+: Parent(_reader), id(_id) {}
-}
+/// \brief Destructor.
-/// \e
+///
+/// Destructor for AttributeReader.
 virtual ~AttributeReader() {
 for (typename Readers::iterator it = readers.begin();
 	   it != readers.end(); ++it) {
 	delete it->second;
 }
 private:
 AttributeReader(const AttributeReader&);
 void operator=(AttributeReader&);
 public:
-/// \e
+/// \brief Add an attribute reader command for the reader.
+///
+/// Add an attribute reader command for the reader.
 template <typename Value>
 AttributeReader& readAttribute(const std::string& id, Value& value) {
 return readAttribute<typename Traits::template Reader<Value> >
 	(id, value);
 }
-/// \e
+/// \brief Add an attribute reader command for the reader.
+///
+/// Add an attribute reader command for the reader.
 template <typename Reader, typename Value>
 AttributeReader& readAttribute(const std::string& name, Value& value,
 				   const Reader& reader = Reader()) {
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 readers.insert(make_pair(name, new ValueReader<Value, Reader>
 			       (value, reader)));
 return *this;
 }
-/// \e
+protected:
+/// \brief Gives back true when the SectionReader can process
+/// the section with the given header line.
+///
+/// It gives back true when the header line start with \c @attributes,
+/// and the header line's id and the attributeset's id are the same.
 bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
 std::string name;
 ls >> command >> name;
 return command == "@attributes" && name == id;
 }
-/// \e
+/// \brief Reader function of the section.
+///
+/// It reads the content of the section.
 void read(std::istream& is) {
 std::string line;
 while (getline(is, line)) {
 	std::istringstream ls(line);
 	std::string id;
 private:
 std::string id;
 typedef std::map<std::string, ValueReaderBase*> Readers;
 Readers readers;
 };
-template <typename _Graph>
-class NodeReader : public CommonSectionReaderBase {
-typedef CommonSectionReaderBase Parent;
-typedef _Graph Graph;
-typedef typename Graph::Node Item;
-public:
-template <typename Resolver>
-NodeReader(LemonReader& _reader, const Resolver& _resolver,
-	       const std::string& _id = std::string())
-: id(_id), resolver(new ResolverReader<typename Graph::Node, Resolver>
-		     (_resolver)) {
-_reader.attach(*this);
-}
-virtual ~NodeReader() {}
-private:
-NodeReader(const NodeReader&);
-void operator=(const NodeReader&);
-public:
-void readNode(const std::string& name, Item& item) {
-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));
-}
-virtual bool header(const std::string& line) {
-std::istringstream ls(line);
-std::string command;
-std::string name;
-ls >> command >> name;
-return command == "@nodes" && name == id;
-}
-virtual void read(std::istream& is) {
-std::string line;
-while (getline(is, line)) {
-	std::istringstream ls(line);
-	std::string id;
-	ls >> id;
-	typename ItemReaders::iterator it = readers.find(id);
-	if (it != readers.end()) {
-	  *(it->second) = resolver->resolve(ls);
-	}
-}
-}
-private:
-std::string id;
-typedef std::map<std::string, Item*> ItemReaders;
-ItemReaders readers;
-std::auto_ptr<ResolverReaderBase<Item> > resolver;
-};
-template <typename _Graph>
-class EdgeReader : public CommonSectionReaderBase {
-typedef CommonSectionReaderBase Parent;
-typedef _Graph Graph;
-typedef typename Graph::Edge Item;
-public:
-template <typename Resolver>
-EdgeReader(LemonReader& _reader, const Resolver& _resolver,
-	       const std::string& _id = std::string())
-: id(_id), resolver(new ResolverReader<typename Graph::Node, Resolver>
-		     (_resolver)) {
-_reader.attach(*this);
-}
-virtual ~EdgeReader() {}
-private:
-EdgeReader(const EdgeReader&);
-void operator=(const EdgeReader&);
-public:
-void readEdge(const std::string& name, Item& item) {
-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));
-}
-virtual bool header(const std::string& line) {
-std::istringstream ls(line);
-std::string command;
-std::string name;
-ls >> command >> name;
-return command == "@nodes" && name == id;
-}
-virtual void read(std::istream& is) {
-std::string line;
-while (getline(is, line)) {
-	std::istringstream ls(line);
-	std::string id;
-	ls >> id;
-	typename ItemReaders::iterator it = readers.find(id);
-	if (it != readers.end()) {
-	  *(it->second) = resolver->resolve(ls);
-	}
-}
-}
-private:
-std::string id;
-typedef std::map<std::string, Item*> ItemReaders;
-ItemReaders readers;
-std::auto_ptr<ResolverReaderBase<Item> > resolver;
-};
-/// \e
-class PrintReader : public LemonReader::SectionReader {
-typedef LemonReader::SectionReader Parent;
-public:
-/// \e
-PrintReader(LemonReader& reader) {
-reader.attach(*this);
-}
-/// \e
-bool header(const std::string& line) {
-std::cout << "Asked header: " << line << std::endl;
-return true;
-}
-/// \e
-void read(std::istream& is) {
-std::string line;
-while (std::getline(is, line)) {
-	std::cout << line << std::endl;
-}
-}
-};
-/// @}
 }
 #endif

changeset 1411	5d161e08bda8
parent 1408	892c29484414
child 1421	7a21e1414c38