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

equal deleted inserted replaced

-:4c8869d50a9b
+:77f98de403ac
 namespace lemon {
 // Exceptions
-class IOException {
-public:
-virtual ~IOException() {}
-virtual string what() const = 0;
-};
-class DataFormatException : public IOException {
-std::string message;
-public:
-DataFormatException(const std::string& _message)
-: message(_message) {}
-std::string what() const {
-return "DataFormatException: " + message;
-}
-};
-template <typename _Exception>
-class StreamException : public _Exception {
-public:
-typedef _Exception Exception;
-StreamException(int _line, Exception _exception)
-: Exception(_exception), line_num(_line) {}
-virtual int line() const {
-return line_num;
-}
-virtual ~StreamException() {}
-virtual std::string what() const {
-ostringstream os;
-os << Exception::what() << " in line " << line();
-return os.str();
-}
-private:
-int line_num;
-};
 /// \brief Standard ReaderTraits for the GraphReader class.
 ///
 /// Standard ReaderTraits for the GraphReader class.
 /// It defines standard reading method for all type of value.
 /// \brief Reads a value from the given stream.
 ///
 /// Reads a value from the given stream.
 void read(std::istream& is, Value& value) {
 	if (!(is >> value))
-	  throw DataFormatException("Default Reader format exception");
+	  throw DataFormatError("Default reader format exception");
 }
 };
 /// The reader class for the not needed maps.
 typedef Reader<std::string> DefaultReader;
 void read(std::istream& is, std::string& value) {
 char c;
 value.clear();
 is >> ws;
 if (!is.get(c) || c != '\"')
-	throw DataFormatException("Quoted string format");
+	throw DataFormatError("Quoted string format error");
 while (is.get(c) && c != '\"') {
 	if (escaped && c == '\\') {
 	  value += readEscape(is);
 	} else {
 	  value += c;
 	}
 }
-if (!is) throw DataFormatException("Quoted string format");
+if (!is) throw DataFormatError("Quoted string format error");
 }
 private:
 static char readEscape(std::istream& is) {
 	return '\v';
 case 'x':
 	{
 	  int code;
 	  if (!is.get(c) || !isHex(c))
-	    throw DataFormatException("Escape format exception");
+	    throw DataFormatError("Escape format error");
 	  else if (code = valueHex(c), !is.get(c) || !isHex(c)) is.putback(c);
 	  else code = code * 16 + valueHex(c);
 	  return code;
 	}
 default:
 	{
 	  int code;
 	  if (!isOct(c))
-	    throw DataFormatException("Escape format exception");
+	    throw DataFormatError("Escape format error");
 	  else if (code = valueOct(c), !is.get(c) || !isOct(c))
 	    is.putback(c);
 	  else if (code = code * 8 + valueOct(c), !is.get(c) || !isOct(c))
 	    is.putback(c);
 	  else code = code * 8 + valueOct(c);
 typedef _ReaderTraits ReaderTraits;
 typedef typename ReaderTraits::DefaultReader DefaultReader;
 /// \brief Construct a new GraphReader.
 ///
-/// Construct a new GraphReader. It reads from the given map,
+/// Construct a new GraphReader. It reads into the given graph
-/// it constructs the given map and it use the given reader as the
+/// and it use the given reader as the default skipper.
-/// default skipper.
 GraphReader(std::istream& _is, Graph& _graph,
 		const DefaultReader& _reader = DefaultReader())
 : is(_is), graph(_graph), nodeSkipper(_reader), edgeSkipper(_reader) {}
 /// \brief Destruct the graph reader.
 /// Add a new node map reader command for the reader.
 template <typename Reader, typename Map>
 GraphReader& addNodeMap(std::string name, Map& map,
 			     const Reader& reader = Reader()) {
 if (node_map_readers.find(name) != node_map_readers.end()) {
-	throw Exception() << "Multiple read rule for node map: " << name;
+	ErrorMessage msg;
+	msg << "Multiple read rule for node map: " << name;
+	throw IOLogicError(msg.message());
 }
 node_map_readers.insert(
 make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));
 return *this;
 }
 /// Add a new node map skipper command for the reader.
 template <typename Reader>
 GraphReader& skipNodeMap(std::string name,
 			     const Reader& reader = Reader()) {
 if (node_map_readers.find(name) != node_map_readers.end()) {
-	throw Exception() << "Multiple read rule for node map: " << name;
+	ErrorMessage msg;
+	msg << "Multiple read rule for node map: " << name;
+	throw IOLogicError(msg.message());
 }
 node_map_readers.insert(
 make_pair(name, new SkipReader<Node, Reader>(reader)));
 return *this;
 }
 /// Add a new edge map reader command for the reader.
 template <typename Reader, typename Map>
 GraphReader& addEdgeMap(std::string name, Map& map,
 			     const Reader& reader = Reader()) {
 if (edge_map_readers.find(name) != edge_map_readers.end()) {
-	throw Exception() << "Multiple read rule for edge map: " << name;
+	ErrorMessage msg;
+	msg << "Multiple read rule for edge map: " << name;
+	throw IOLogicError(msg.message());
 }
 edge_map_readers.insert(
 make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));
 return *this;
 }
 /// Add a new edge map skipper command for the reader.
 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;
+	ErrorMessage msg;
+	msg << "Multiple read rule for edge map: " << name;
+	throw IOLogicError(msg.message());
 }
 edge_map_readers.insert(
 make_pair(name, new SkipReader<Edge, Reader>(reader)));
 return *this;
 }
 /// \brief Add a new labeled node reader for the reader.
 ///
 /// Add a new labeled node reader for the reader.
 GraphReader& addNode(std::string name, Node& node) {
 if (node_readers.find(name) != node_readers.end()) {
-	throw Exception() << "Multiple read rule for node";
+	ErrorMessage msg;
+	msg << "Multiple read rule for node: " << name;
+	throw IOLogicError(msg.message());
 }
 node_readers.insert(make_pair(name, &node));
 return *this;
 }
 /// \brief Add a new labeled edge reader for the reader.
 ///
 /// Add a new labeled edge reader for the reader.
 GraphReader& addEdge(std::string name, Edge& edge) {
 if (edge_readers.find(name) != edge_readers.end()) {
-	throw Exception() << "Multiple read rule for edge";
+	ErrorMessage msg;
+	msg << "Multiple read rule for edge: " << name;
+	throw IOLogicError(msg.message());
 }
 edge_readers.insert(make_pair(name, &edge));
 return *this;
 }
 	}
 	if (line.find("@edges") == 0) {
 	  line = readEdges(line_num, edgeInverter);
 	}
 	if (line.find("@end") != 0) {
-	  throw DataFormatException("Invalid control sequence: " + line);
+	  throw DataFormatError("Invalid control sequence error");
 	}
-} catch (DataFormatException e) {
+} catch (DataFormatError e) {
-	throw StreamException<DataFormatException>(line_num, e);
+	e.line(line_num);
+	throw e;
 }
 }
 private:
 	  }
 	}
 }
 if (index.size() == 0) {
-	throw DataFormatException("No node map found");
+	throw DataFormatError("Cannot find node id map");
 }
 nodeInverter = auto_ptr<InverterBase<Node> >(index[0]->getInverter());
 std::string line;
 while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
 	  }
 	}
 }
 if (index.size() == 0) {
-	throw DataFormatException("No edge map found");
+	throw DataFormatError("Cannot find edge id map");
 }
 edgeInverter = auto_ptr<InverterBase<Edge> >(index[0]->getInverter());
 std::string line;
 while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
 	int vi = line.find_first_not_of(" \t");
 	if (vi != (int)string::npos && line[vi] != '#') {
 	  return line.substr(vi);
 	}
 }
-throw DataFormatException("End of stream");
+throw DataFormatError("End of stream error");
 }
 // Inverters store and give back the Item from the id,
 // and may put the ids into a map.
 	map.set(item, value);
 	typename Inverse::iterator it = inverse.find(value);
 	if (it == inverse.end()) {
 	  inverse.insert(make_pair(value, item));
 	} else {
-	  throw DataFormatException("Multiple ID occurence");
+	  throw DataFormatError("Multiple ID occurence");
 	}
 }
 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;
 	} else {
-	  throw DataFormatException("Invalid ID");
+	  throw DataFormatError("Invalid ID error");
 	}
 }
 };
 template <typename _Item, typename _Reader>
 	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");
+	  throw DataFormatError("Multiple ID occurence error");
 	}
 }
 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;
 	} else {
-	  throw DataFormatException("Invalid ID");
+	  throw DataFormatError("Invalid ID error");
 	}
 }
 private:
 Inverse inverse;
 };
 SkipReader<Node, DefaultReader> nodeSkipper;
 SkipReader<Edge, DefaultReader> edgeSkipper;
 };
+/// Ready to use reader function.
+template<typename Graph, typename CapacityMap, typename CostMap>
+void readGraph(std::istream& is, Graph &g, CapacityMap& capacity,
+		  typename Graph::Node &s, typename Graph::Node &t,
+		  CostMap& cost) {
+GraphReader<Graph> reader(is, g);
+reader.addEdgeMap("capacity", capacity);
+reader.addEdgeMap("cost", cost);
+reader.addNode("source", s);
+reader.addNode("target", t);
+reader.run();
+}
+template<typename Graph, typename CapacityMap>
+void readGraph(std::istream& is, Graph &g, CapacityMap& capacity,
+		  typename Graph::Node &s, typename Graph::Node &t) {
+GraphReader<Graph> reader(is, g);
+reader.addEdgeMap("capacity", capacity);
+reader.addNode("source", s);
+reader.addNode("target", t);
+reader.run();
+}
+template<typename Graph, typename CapacityMap>
+void readGraph(std::istream& is, Graph &g, CapacityMap& capacity,
+		  typename Graph::Node &s) {
+GraphReader<Graph> reader(is, g);
+reader.addEdgeMap("capacity", capacity);
+reader.addNode("source", s);
+reader.run();
+}
+template<typename Graph, typename CapacityMap>
+void readGraph(std::istream& is, Graph &g, CapacityMap& capacity) {
+GraphReader<Graph> reader(is, g);
+reader.addEdgeMap("capacity", capacity);
+reader.run();
+}
+template<typename Graph>
+void readGraph(std::istream& is, Graph &g) {
+GraphReader<Graph> reader(is, g);
+reader.run();
+}
 }

changeset 1210	f02396423239
parent 1164	80bb73097736
child 1214	39993ada11c7