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

equal deleted inserted replaced

-:5809fb77b2b3
+:6db305e87559
 IdReader(const BoxedIdReader& _boxedIdReader)
 	: boxedIdReader(_boxedIdReader) {}
 virtual Item read(std::istream& is) const {
-	return boxedIdReader.readId(is);
+	return boxedIdReader.readId(is, Item());
 }
 };
 class ValueReaderBase {
 public:
 typedef CommonSectionReaderBase Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
-typedef typename Graph::Node Item;
+typedef typename Graph::Node Node;
 typedef typename Traits::Skipper DefaultSkipper;
 /// \brief Constructor.
 ///
 /// Constructor for NodeSetReader. It creates the NodeSetReader and
 ///
 /// Add a new node map reader command for the reader.
 template <typename Reader, typename Map>
 NodeSetReader& readNodeMap(std::string name, Map& map,
 			       const Reader& reader = Reader()) {
-return _readMap<
+return _readMap<Reader, Map, typename SmartParameter<Map>::Type>
-	typename Traits::template Reader<typename Map::Value>, Map,
+	(name, map, reader);
-	typename SmartParameter<Map>::Type>(name, map, reader);
 }
 template <typename Reader, typename Map>
 NodeSetReader& readNodeMap(std::string name, const Map& map,
 			       const Reader& reader = Reader()) {
-return _readMap<
+return _readMap<Reader, Map, typename SmartParameter<Map>::Type>
-	typename Traits::template Reader<typename Map::Value>, Map,
+	(name, map, reader);
-	typename SmartParameter<Map>::Type>(name, map, reader);
 }
 private:
 template <typename Reader, typename Map, typename MapParameter>
 	ErrorMessage msg;
 	msg << "Multiple read rule for node map: " << name;
 	throw IOParameterError(msg.message());
 }
 readers.insert(
-	make_pair(name, new MapReader<Item, Map, Reader>(map, reader)));
+	make_pair(name, new 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<Item, Reader>(reader)));
+readers.insert(make_pair(name, new 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<Item>* > index;
+std::vector<ReaderBase<Node>* > index;
 std::string line;
 getline(is, line);
 std::istringstream ls(line);
 while (ls >> id) {
 	  inverter.reset(index.back()->getInverter());
 	  index.back() = inverter.get();
 	}
 }
 while (getline(is, line)) {
-	typename Graph::Node node = graph.addNode();
+	Node node = graph.addNode();
 	std::istringstream ls(line);
 	for (int i = 0; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, node);
 	}
 }
 /// \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.
-Item readId(std::istream& is) const {
+Node readId(std::istream& is, Node = Node()) const {
 return inverter->read(is);
 }
 private:
-typedef std::map<std::string, ReaderBase<Item>*> MapReaders;
+typedef std::map<std::string, ReaderBase<Node>*> MapReaders;
 MapReaders readers;
 typename SmartReference<Graph>::Type graph;
 std::string id;
-SkipReader<Item, DefaultSkipper> skipper;
+SkipReader<Node, DefaultSkipper> skipper;
-std::auto_ptr<InverterBase<Item> > inverter;
+std::auto_ptr<InverterBase<Node> > inverter;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading a graph's edgeset.
 ///
 typedef CommonSectionReaderBase Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
-typedef typename Graph::Edge Item;
+typedef typename Graph::Node Node;
+typedef typename Graph::Edge Edge;
 typedef typename Traits::Skipper DefaultSkipper;
 /// \brief Constructor.
 ///
 /// Constructor for EdgeSetReader. It creates the EdgeSetReader and
 		  typename SmartParameter<Graph>::Type _graph,
 		  const NodeIdReader& _nodeIdReader,
 		  const std::string& _id = std::string(),
 		  const DefaultSkipper& _skipper = DefaultSkipper())
 : Parent(_reader), graph(_graph), id(_id), skipper(_skipper),
-	nodeIdReader(new IdReader<typename Graph::Node, NodeIdReader>
+	nodeIdReader(new IdReader<Node, NodeIdReader>(_nodeIdReader)) {}
-		     (_nodeIdReader)) {}
 /// \brief Destructor.
 ///
 /// Destructor for EdgeSetReader.
 virtual ~EdgeSetReader() {
 ///
 /// Add a new edge map reader command for the reader.
 template <typename Reader, typename Map>
 EdgeSetReader& readEdgeMap(std::string name, Map& map,
 			   const Reader& reader = Reader()) {
-return _readMap<
+return _readMap<Reader, Map,
-	typename Traits::template Reader<typename Map::Value>, Map,
 	typename SmartParameter<Map>::Type>(name, map, reader);
 }
 template <typename Reader, typename Map>
 EdgeSetReader& readEdgeMap(std::string name, const Map& map,
 			       const Reader& reader = Reader()) {
-return _readMap<
+return _readMap<Reader, Map,
-	typename Traits::template Reader<typename Map::Value>, Map,
 	typename SmartParameter<Map>::Type>(name, map, reader);
 }
 private:
 	ErrorMessage msg;
 	msg << "Multiple read rule for edge map: " << name;
 	throw IOParameterError(msg.message());
 }
 readers.insert(
-	make_pair(name, new MapReader<Item, Map, Reader>(map, reader)));
+	make_pair(name, new 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<Item, Reader>(reader)));
+readers.insert(make_pair(name, new SkipReader<Edge, 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<Item>* > index;
+std::vector<ReaderBase<Edge>* > index;
 std::string line;
 getline(is, line);
 std::istringstream ls(line);
 while (ls >> id) {
 	  index.back() = inverter.get();
 	}
 }
 while (getline(is, line)) {
 	std::istringstream ls(line);
-	typename Graph::Node from = nodeIdReader->read(ls);
+	Node from = nodeIdReader->read(ls);
-	typename Graph::Node to = nodeIdReader->read(ls);
+	Node to = nodeIdReader->read(ls);
-	typename Graph::Edge edge = graph.addEdge(from, to);
+	Edge edge = graph.addEdge(from, to);
 	for (int i = 0; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, edge);
 	}
 }
 }
 /// \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.
-Item readId(std::istream& is) const {
+Edge readId(std::istream& is, Edge = Edge()) const {
 return inverter->read(is);
 }
 private:
-typedef std::map<std::string, ReaderBase<Item>*> MapReaders;
+typedef std::map<std::string, ReaderBase<Edge>*> MapReaders;
 MapReaders readers;
 typename SmartReference<Graph>::Type graph;
 std::string id;
-SkipReader<Item, DefaultSkipper> skipper;
+SkipReader<Edge, DefaultSkipper> skipper;
-std::auto_ptr<InverterBase<Item> > inverter;
+std::auto_ptr<InverterBase<Edge> > inverter;
-std::auto_ptr<IdReaderBase<typename Graph::Node> > nodeIdReader;
+std::auto_ptr<IdReaderBase<Node> > nodeIdReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading a undirected graph's edgeset.
 ///
 typedef CommonSectionReaderBase Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
-typedef typename Graph::UndirEdge Item;
+typedef typename Graph::Node Node;
+typedef typename Graph::Edge Edge;
+typedef typename Graph::UndirEdge UndirEdge;
 typedef typename Traits::Skipper DefaultSkipper;
 /// \brief Constructor.
 ///
 /// Constructor for UndirEdgeSetReader. It creates the UndirEdgeSetReader
 		       typename SmartParameter<Graph>::Type _graph,
 		       const NodeIdReader& _nodeIdReader,
 		       const std::string& _id = std::string(),
 		       const DefaultSkipper& _skipper = DefaultSkipper())
 : Parent(_reader), graph(_graph), id(_id), skipper(_skipper),
-	nodeIdReader(new IdReader<typename Graph::Node, NodeIdReader>
+	nodeIdReader(new IdReader<Node, NodeIdReader>(_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<Item, Map, Reader>(map, reader)));
+	make_pair(name, new 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, new SkipReader<Item, Reader>(reader)));
+readers.insert(make_pair(name,
+			       new SkipReader<UndirEdge, Reader>(reader)));
 return *this;
 }
 /// \brief Add a new directed edge map reader command for the reader.
 ///
 /// \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::vector<ReaderBase<UndirEdge>* > index;
 std::string line;
 getline(is, line);
 std::istringstream ls(line);
 while (ls >> id) {
 	  index.back() = inverter.get();
 	}
 }
 while (getline(is, line)) {
 	std::istringstream ls(line);
-	typename Graph::Node from = nodeIdReader->read(ls);
+	Node from = nodeIdReader->read(ls);
-	typename Graph::Node to = nodeIdReader->read(ls);
+	Node to = nodeIdReader->read(ls);
-	typename Graph::UndirEdge edge = graph.addEdge(from, to);
+	UndirEdge edge = graph.addEdge(from, to);
 	for (int i = 0; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, edge);
 	}
 }
 }
 /// \brief Gives back the undirected edge by its id.
 ///
 /// It reads an id from the stream and gives back which undirected edge
 /// belongs to it. It is possible only if there was read an "id" named map.
-Item readId(std::istream& is) const {
+UndirEdge readId(std::istream& is, UndirEdge = UndirEdge()) const {
 return inverter->read(is);
 }
-private:
+/// \brief Gives back the directed edge by its id.
+///
-typedef std::map<std::string, ReaderBase<Item>*> MapReaders;
+/// It reads an id from the stream and gives back which directed edge
+/// belongs to it. The directed edge id is the \c '+' or \c '-' character
+/// and the undirected edge id. It is possible only if there was read
+/// an "id" named map.
+Edge readId(std::istream& is, Edge = Edge()) const {
+char c;
+is >> c;
+UndirEdge undirEdge = inverter->read(is);
+if (c == '+') {
+	return graph.edgeWithSource(undirEdge, graph.source(undirEdge));
+} else if (c == '-') {
+	return graph.edgeWithSource(undirEdge, graph.target(undirEdge));
+} else {
+	throw DataFormatError("Wrong id format for edge "
+			      "in undirected edgeset");
+}
+}
+private:
+typedef std::map<std::string, ReaderBase<UndirEdge>*> MapReaders;
 MapReaders readers;
 typename SmartReference<Graph>::Type graph;
 std::string id;
-SkipReader<Item, DefaultSkipper> skipper;
+SkipReader<UndirEdge, DefaultSkipper> skipper;
-std::auto_ptr<InverterBase<Item> > inverter;
+std::auto_ptr<InverterBase<UndirEdge> > inverter;
-std::auto_ptr<IdReaderBase<typename Graph::Node> > nodeIdReader;
+std::auto_ptr<IdReaderBase<Node> > nodeIdReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading labeled nodes.
 ///
 /// \relates LemonReader
 template <typename _Graph>
 class NodeReader : public CommonSectionReaderBase {
 typedef CommonSectionReaderBase Parent;
 typedef _Graph Graph;
-typedef typename Graph::Node Item;
+typedef typename Graph::Node Node;
 public:
 /// \brief Constructor.
 ///
 /// Constructor for NodeReader. It creates the NodeReader and
 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) {
+void readNode(const std::string& name, Node& item) {
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 	msg << "Multiple read rule for node: " << name;
 	throw IOParameterError(msg.message());
 }
 std::string line;
 while (getline(is, line)) {
 	std::istringstream ls(line);
 	std::string id;
 	ls >> id;
-	typename ItemReaders::iterator it = readers.find(id);
+	typename NodeReaders::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;
+typedef std::map<std::string, Node*> NodeReaders;
-ItemReaders readers;
+NodeReaders readers;
-std::auto_ptr<IdReaderBase<Item> > idReader;
+std::auto_ptr<IdReaderBase<Node> > idReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading labeled edges.
 ///
 /// \relates LemonReader
 template <typename _Graph>
 class EdgeReader : public CommonSectionReaderBase {
 typedef CommonSectionReaderBase Parent;
 typedef _Graph Graph;
-typedef typename Graph::Edge Item;
+typedef typename Graph::Edge Edge;
 public:
 /// \brief Constructor.
 ///
 /// Constructor for EdgeReader. It creates the EdgeReader and
 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) {
+void readEdge(const std::string& name, Edge& item) {
 if (readers.find(name) != readers.end()) {
 	ErrorMessage msg;
 	msg << "Multiple read rule for edge: " << name;
 	throw IOParameterError(msg.message());
 }
 std::string line;
 while (getline(is, line)) {
 	std::istringstream ls(line);
 	std::string id;
 	ls >> id;
-	typename ItemReaders::iterator it = readers.find(id);
+	typename EdgeReaders::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;
+typedef std::map<std::string, Edge*> EdgeReaders;
-ItemReaders readers;
+EdgeReaders readers;
-std::auto_ptr<IdReaderBase<Item> > idReader;
+std::auto_ptr<IdReaderBase<Edge> > idReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading labeled undirected edges.
 ///
 /// \relates LemonReader
 template <typename _Graph>
 class UndirEdgeReader : public CommonSectionReaderBase {
 typedef CommonSectionReaderBase Parent;
 typedef _Graph Graph;
-typedef typename Graph::UndirEdge Item;
+typedef typename Graph::Edge Edge;
+typedef typename Graph::UndirEdge UndirEdge;
 public:
 /// \brief Constructor.
 ///
 /// Constructor for UndirEdgeReader. It creates the UndirEdgeReader and
 /// the same.
 template <typename _IdReader>
 UndirEdgeReader(LemonReader& _reader, const _IdReader& _idReader,
 	       const std::string& _id = std::string())
 : Parent(_reader), id(_id),
-	idReader(new IdReader<typename Graph::UndirEdge, _IdReader>(_idReader))
+	undirEdgeIdReader(new IdReader<UndirEdge, _IdReader>(_idReader)),
+	edgeIdReader(new IdReader<Edge, _IdReader>(_idReader))
 {}
 /// \brief Destructor.
 ///
 /// Destructor for UndirEdgeReader.
 public:
 /// \brief Add an undirected edge reader command for the UndirEdgeReader.
 ///
 /// Add an undirected edge reader command for the UndirEdgeReader.
-void readUndirEdge(const std::string& name, Item& item) {
+void readUndirEdge(const std::string& name, UndirEdge& item) {
-if (readers.find(name) != readers.end()) {
+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));
+}
+/// \brief Add an edge reader command for the UndirEdgeReader.
+///
+/// Add an edge reader command for the UndirEdgeReader.
+void readEdge(const std::string& name, Edge& item) {
+if (edgeReaders.find(name) != edgeReaders.end()) {
 	ErrorMessage msg;
 	msg << "Multiple read rule for edge: " << name;
 	throw IOParameterError(msg.message());
 }
-readers.insert(make_pair(name, &item));
+edgeReaders.insert(make_pair(name, &item));
 }
 protected:
 /// \brief Gives back true when the SectionReader can process
 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;
+return command == "@undiredges" && name == id;
 }
 /// \brief Reader function of the section.
 ///
 /// It reads the content of the section.
 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()) {
+	  typename UndirEdgeReaders::iterator it = undirEdgeReaders.find(id);
-	  *(it->second) = idReader->read(ls);
+	  if (it != undirEdgeReaders.end()) {
-	}
+	    *(it->second) = undirEdgeIdReader->read(ls);
+	    break;
+	  }
+	} {
+	  typename EdgeReaders::iterator it = edgeReaders.find(id);
+	  if (it != edgeReaders.end()) {
+	    *(it->second) = edgeIdReader->read(ls);
+	    break;
+	  }
+	}
 }
 }
 private:
 std::string id;
-typedef std::map<std::string, Item*> ItemReaders;
+typedef std::map<std::string, UndirEdge*> UndirEdgeReaders;
-ItemReaders readers;
+UndirEdgeReaders undirEdgeReaders;
-std::auto_ptr<IdReaderBase<Item> > idReader;
+std::auto_ptr<IdReaderBase<UndirEdge> > undirEdgeIdReader;
+typedef std::map<std::string, Edge*> EdgeReaders;
+EdgeReaders edgeReaders;
+std::auto_ptr<IdReaderBase<Edge> > edgeIdReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for attributes.
 ///

changeset 1429	4283998fb2be
parent 1427	14c75970840e