lemon-0.x: comparison src/work/deba/graph

equal deleted inserted replaced

-:b406e0812af4
+:9c1cd501315a
 #include <sstream>
 #include <map>
 #include <vector>
+#include <memory>
 #include <lemon/error.h>
 /// \todo fix exceptions
 std::string what() const {
 return "DataFormatException: " + message;
 }
 };
-class StreamException : public IOException {
+template <typename _Exception>
+class StreamException : public _Exception {
 public:
-virtual int line() = 0;
+typedef _Exception Exception;
+StreamException(int _line, Exception _exception)
+: line_num(_line), Exception(_exception) {}
+virtual int line() const {
+return line_num;
+}
+virtual std::string what() const {
+ostringstream os;
+os << Exception::what() << " in line " << line();
+return os.str();
+}
 private:
-IOException* exception;
 int line_num;
 };
 // Readers and ReaderTraits
 void read(std::istream& is, std::string& value) {
 char c;
 value.clear();
 is >> ws;
-if (!is.get(c) || c != '\"') throw DataFormatException("Quoted string format exception");
+if (!is.get(c) || c != '\"') throw DataFormatException("Quoted string format");
 while (is.get(c) && c != '\"') {
 	if (escaped && c == '\\') {
 	  value += readEscape(is);
 	} else {
 	  value += c;
 	}
 }
-if (!is) throw DataFormatException("Quoted string format exception");
+if (!is) throw DataFormatException("Quoted string format");
 }
 private:
 static char readEscape(std::istream& is) {
 // Graph reader
 template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits>
 class GraphReader {
 public:
 typedef _Graph Graph;
 typedef typename Graph::Node Node;
 typedef typename Graph::Edge Edge;
 typedef _ReaderTraits ReaderTraits;
 typedef typename ReaderTraits::DefaultReader DefaultReader;
-GraphReader(istream& _is, Graph& _graph, const DefaultReader& _reader = DefaultReader())
+GraphReader(std::istream& _is, Graph& _graph, const DefaultReader& _reader = DefaultReader())
 : is(_is), graph(_graph), nodeSkipper(_reader), edgeSkipper(_reader) {}
 ~GraphReader() {
-for (typename NodeReaders::iterator it = node_readers.begin(); it != node_readers.end(); ++it) {
+for (typename NodeMapReaders::iterator it = node_map_readers.begin(); it != node_map_readers.end(); ++it) {
 	delete it->second;
 }
-for (typename EdgeReaders::iterator it = edge_readers.begin(); it != edge_readers.end(); ++it) {
+for (typename EdgeMapReaders::iterator it = edge_map_readers.begin(); it != edge_map_readers.end(); ++it) {
 	delete it->second;
 }
 }
+// Node map rules
 template <typename Map>
 GraphReader& readNodeMap(std::string name, Map& map) {
 return readNodeMap<typename ReaderTraits::template Reader<typename Map::Value>, Map>(name, map);
 }
 template <typename Reader, typename Map>
 GraphReader& readNodeMap(std::string name, Map& map, const Reader& reader = Reader()) {
-if (node_readers.find(name) != node_readers.end()) {
+if (node_map_readers.find(name) != node_map_readers.end()) {
-	Exception e;
+	throw Exception() << "Multiple read rule for node map: " << name;
-	e << "Multiple read rule for node map: " << name;
+}
-	throw e;
+node_map_readers.insert(make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));
-}
-node_readers.insert(make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));
 return *this;
 }
 template <typename Reader>
 GraphReader& skipNodeMap(std::string name, const Reader& reader = Reader()) {
-if (node_readers.find(name) != node_readers.end()) {
+if (node_map_readers.find(name) != node_map_readers.end()) {
-	Exception e;
+	throw Exception() << "Multiple read rule for node map: " << name;
-	e << "Multiple read rule for node map: " << name;
+}
-	throw e;
+node_map_readers.insert(make_pair(name, new SkipReader<Node, Reader>(reader)));
-}
-node_readers.insert(make_pair(name, new SkipReader<Node, Reader>(reader)));
 return *this;
 }
+// Edge map rules
 template <typename Map>
 GraphReader& readEdgeMap(std::string name, Map& map) {
 return readEdgeMap<typename ReaderTraits::template Reader<typename Map::Value>, Map>(name, map);
 }
 template <typename Reader, typename Map>
 GraphReader& readEdgeMap(std::string name, Map& map, const Reader& reader = Reader()) {
-if (edge_readers.find(name) != edge_readers.end()) {
+if (edge_map_readers.find(name) != edge_map_readers.end()) {
-	Exception e;
+	throw Exception() << "Multiple read rule for edge map: " << name;
-	e << "Multiple read rule for edge map: " << name;
+}
-	throw e;
+edge_map_readers.insert(make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));
-}
-edge_readers.insert(make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));
 return *this;
 }
 template <typename Reader>
 GraphReader& skipEdgeMap(std::string name, const Reader& reader = Reader()) {
+if (edge_map_readers.find(name) != edge_map_readers.end()) {
+	throw Exception() << "Multiple read rule for edge map: " << name;
+}
+edge_map_readers.insert(make_pair(name, new SkipReader<Edge, Reader>(reader)));
+return *this;
+}
+// Node rules
+GraphReader& readNode(std::string name, Node& node) {
+if (node_readers.find(name) != node_readers.end()) {
+	throw Exception() << "Multiple read rule for node";
+}
+node_readers.insert(make_pair(name, &node));
+}
+// Edge rules
+GraphReader& readEdge(std::string name, Edge& edge) {
 if (edge_readers.find(name) != edge_readers.end()) {
-	Exception e;
+	throw Exception() << "Multiple read rule for edge";
-	e << "Multiple read rule for edge map: " << name;
+}
-	throw e;
+edge_readers.insert(make_pair(name, &edge));
-}
-edge_readers.insert(make_pair(name, new SkipReader<Edge, Reader>(reader)));
-return *this;
 }
 void read() {
 int line_num = 0;
-InverterBase<Node>* nodeInverter = 0;
+std::auto_ptr<InverterBase<Node> > nodeInverter;
-InverterBase<Edge>* edgeInverter = 0;
+std::auto_ptr<InverterBase<Edge> > edgeInverter;
-// \todo delete the inverters
+try {
-//      try {
+	std::string line = readNotEmptyLine(is, line_num);
-	{
+	if (line.find("@nodeset") == 0) {
-	  std::string line = readNotEmptyLine(is, line_num);
+	  line = readNodeSet(line_num, nodeInverter);
 	}
-	readNodeSet(line_num, nodeInverter);
+	if (line.find("@edgeset") == 0) {
-	readEdgeSet(line_num, edgeInverter, nodeInverter);
+	  line = readEdgeSet(line_num, edgeInverter, nodeInverter);
-	//      } catch (...){
+	}
-	if (nodeInverter != 0) delete nodeInverter;
+	if (line.find("@nodes") == 0) {
-	if (edgeInverter != 0) delete edgeInverter;
+	  line = readNodes(line_num, nodeInverter);
-	//      }
+	}
+	if (line.find("@edges") == 0) {
+	  line = readEdges(line_num, edgeInverter);
+	}
+	if (line.find("@end") != 0) {
+	  throw DataFormatException("Invalid control sequence: " + line);
+	}
+} catch (DataFormatException e) {
+	throw StreamException<DataFormatException>(line_num, e);
+}
 }
 private:
 template <typename Item> class InverterBase;
-//    template <typename Item> class InverterBase;
+std::string readNodeSet(int& line_num, auto_ptr<InverterBase<Node> > & nodeInverter) {
-void readNodeSet(int& line_num, InverterBase<Node>* & nodeInverter) {
+std::vector<ReaderBase<Node>* > index;
-int n = 0;
-std::vector<ReaderBase<Node>*> index;
 {
 	std::string line = readNotEmptyLine(is, line_num);
 	std::string id;
 	std::istringstream ls(line);
 	while (ls >> id) {
 	  if (id[0] == '#') break;
-	  typename NodeReaders::iterator it = node_readers.find(id);
+	  typename NodeMapReaders::iterator it = node_map_readers.find(id);
-	  if (it != node_readers.end()) {
+	  if (it != node_map_readers.end()) {
 	    index.push_back(it->second);
+	    node_map_readers.erase(it);
 	  } else {
 	    index.push_back(&nodeSkipper);
 	  }
-	  ++n;
+	}
-	}
+}
-}
+if (index.size() == 0) {
-nodeInverter = index[0]->getInverter();
+	throw DataFormatException("No node map found");
+}
+nodeInverter = auto_ptr<InverterBase<Node> >(index[0]->getInverter());
 std::string line;
 while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
 	Node node = graph.addNode();
 	std::istringstream ls(line);
 	nodeInverter->read(ls, node);
-	for (int i = 1; i < n; ++i) {
+	for (int i = 1; i < index.size(); ++i) {
 	  index[i]->read(ls, node);
 	}
 }
-}
+return line;
+}
-void readEdgeSet(int& line_num, InverterBase<Edge>* & edgeInverter, InverterBase<Node>* & nodeInverter) {
-int n = 0;
+std::string readEdgeSet(int& line_num,
+		     auto_ptr<InverterBase<Edge> > & edgeInverter, auto_ptr<InverterBase<Node> > & nodeInverter) {
 std::vector<ReaderBase<Edge>*> index;
 {
 	std::string line = readNotEmptyLine(is, line_num);
 	std::string id;
 	std::istringstream ls(line);
 	while (ls >> id) {
 	  if (id[0] == '#') break;
-	  typename EdgeReaders::iterator it = edge_readers.find(id);
+	  typename EdgeMapReaders::iterator it = edge_map_readers.find(id);
-	  if (it != edge_readers.end()) {
+	  if (it != edge_map_readers.end()) {
 	    index.push_back(it->second);
+	    edge_map_readers.erase(it);
 	  } else {
 	    index.push_back(&edgeSkipper);
 	  }
-	  ++n;
+	}
-	}
+}
-}
-edgeInverter = index[0]->getInverter();
+if (index.size() == 0) {
+	throw DataFormatException("No edge map found");
+}
+edgeInverter = auto_ptr<InverterBase<Edge> >(index[0]->getInverter());
 std::string line;
 while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
 	std::istringstream ls(line);
 	Node source = nodeInverter->read(ls);
 	Node target = nodeInverter->read(ls);
 	Edge edge = graph.addEdge(source, target);
 	edgeInverter->read(ls, edge);
-	for (int i = 1; i < n; ++i) {
+	for (int i = 1; i < index.size(); ++i) {
 	  index[i]->read(ls, edge);
 	}
 }
+return line;
+}
+std::string readNodes(int& line_num, auto_ptr<InverterBase<Node> >& nodeInverter) {
+std::string line;
+while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
+	std::istringstream ls(line);
+	std::string name;
+	ls >> name;
+	typename NodeReaders::iterator it = node_readers.find(name);
+	if (it != node_readers.end()) {
+	  *(it -> second) = nodeInverter->read(ls);
+	}
+}
+return line;
+}
+std::string readEdges(int& line_num, auto_ptr<InverterBase<Edge> >& edgeInverter) {
+std::string line;
+while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
+	std::istringstream ls(line);
+	std::string name;
+	ls >> name;
+	typename EdgeReaders::iterator it = edge_readers.find(name);
+	if (it != edge_readers.end()) {
+	  *(it -> second) = edgeInverter->read(ls);
+	}
+}
+return line;
 }
 std::string readNotEmptyLine(std::istream& is, int& line_num) {
 std::string line;
 while (++line_num, getline(is, line)) {
 	int vi = line.find_first_not_of(" \t");
 	if (vi != string::npos && line[vi] != '#') {
 	  return line.substr(vi);
 	}
 }
-throw Exception();
+throw DataFormatException("End of stream");
 }
+// Inverters store and give back the Item from the id,
+// and may put the ids into a map.
 template <typename _Item>
 class InverterBase {
 public:
 typedef _Item Item;
-virtual void read(istream&, const Item&) = 0;
+virtual void read(std::istream&, const Item&) = 0;
-virtual Item read(istream&) = 0;
+virtual Item read(std::istream&) = 0;
 };
 template <typename _Item, typename _Map, typename _Reader>
 class MapReaderInverter : public InverterBase<_Item> {
 public:
 Inverse inverse;
 MapReaderInverter(Map& _map, const Reader& _reader)
 	: map(_map), reader(_reader) {}
-virtual void read(istream& is, const Item& item) {
+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()) {
 	} else {
 	  throw DataFormatException("Multiple ID occurence");
 	}
 }
-virtual Item read(istream& is) {
+virtual Item read(std::istream& is) {
 	Value value;
 	reader.read(is, value);
 	typename Inverse::const_iterator it = inverse.find(value);
 	if (it != inverse.end()) {
 	  return it->second;
 Reader reader;
 SkipReaderInverter(const Reader& _reader)
 	: reader(_reader) {}
-virtual void read(istream& is, const Item& item) {
+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(make_pair(value, item));
 	} else {
 	  throw DataFormatException("Multiple ID occurence");
 	}
 }
-virtual Item read(istream& is) {
+virtual Item read(std::istream& is) {
 	Value value;
 	reader.read(is, value);
 	typename Inverse::const_iterator it = inverse.find(value);
 	if (it != inverse.end()) {
 	  return it->second;
 }
 private:
 Inverse inverse;
 };
+// Readers
 template <typename _Item>
 class ReaderBase {
 public:
 typedef _Item Item;
-virtual void read(istream& is, const Item& item) = 0;
+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> {
 MapReader(Map& _map, const Reader& _reader)
 	: map(_map), reader(_reader) {}
-virtual void read(istream& is, const Item& item) {
+virtual void read(std::istream& is, const Item& item) {
 	Value value;
 	reader.read(is, value);
 	map.set(item, value);
 }
 typedef _Item Item;
 Reader reader;
 SkipReader(const Reader& _reader) : reader(_reader) {}
-virtual void read(istream& is, const Item& item) {
+virtual void read(std::istream& is, const Item& item) {
 	Value value;
 	reader.read(is, value);
 }
 virtual InverterBase<Item>* getInverter() {
 	return new SkipReaderInverter<Item, Reader>(reader);
 }
 };
-typedef std::map<std::string, ReaderBase<Node>* > NodeReaders;
+typedef std::map<std::string, ReaderBase<Node>*> NodeMapReaders;
+NodeMapReaders node_map_readers;
+typedef std::map<std::string, ReaderBase<Edge>*> EdgeMapReaders;
+EdgeMapReaders edge_map_readers;
+typedef std::map<std::string, Node*> NodeReaders;
 NodeReaders node_readers;
-typedef std::map<std::string, ReaderBase<Edge>* > EdgeReaders;
+typedef std::map<std::string, Edge*> EdgeReaders;
 EdgeReaders edge_readers;
 std::istream& is;
 Graph& graph;

changeset 1065	340fe3cbb145
parent 1036	2f514b5c7122
child 1115	444f69240539