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

equal deleted inserted replaced

-:9c1cd501315a
+:1bc79fcb3372
 // Exceptions
 class IOException {
 public:
+virtual ~IOException() {}
 virtual string what() const = 0;
 };
 class DataFormatException : public IOException {
 std::string message;
 template <typename _Exception>
 class StreamException : public _Exception {
 public:
 typedef _Exception Exception;
 StreamException(int _line, Exception _exception)
-: line_num(_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();
 }
 int line_num;
 };
 // Readers and ReaderTraits
+/// \brief Standard ReaderTraits for the GraphReader class.
+///
+///
 struct DefaultReaderTraits {
 template <typename _Value>
 struct Reader {
 typedef _Value Value;
 void read(std::istream& is, std::string& value) {
 char c;
 value.clear();
 is >> ws;
-if (!is.get(c) || c != '\"') throw DataFormatException("Quoted string format");
+if (!is.get(c) || c != '\"')
+	throw DataFormatException("Quoted string format");
 while (is.get(c) && c != '\"') {
 	if (escaped && c == '\\') {
 	  value += readEscape(is);
 	} else {
 	  value += c;
 typedef typename Graph::Edge Edge;
 typedef _ReaderTraits ReaderTraits;
 typedef typename ReaderTraits::DefaultReader DefaultReader;
-GraphReader(std::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 NodeMapReaders::iterator it = node_map_readers.begin(); it != node_map_readers.end(); ++it) {
+for (typename NodeMapReaders::iterator it = node_map_readers.begin();
+	   it != node_map_readers.end(); ++it) {
 	delete it->second;
 }
-for (typename EdgeMapReaders::iterator it = edge_map_readers.begin(); it != edge_map_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) {
+GraphReader& addNodeMap(std::string name, Map& map) {
-return readNodeMap<typename ReaderTraits::template Reader<typename Map::Value>, Map>(name, map);
+return addNodeMap<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()) {
+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;
 }
-node_map_readers.insert(make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));
+node_map_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()) {
+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;
 }
-node_map_readers.insert(make_pair(name, new SkipReader<Node, Reader>(reader)));
+node_map_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) {
+GraphReader& addEdgeMap(std::string name, Map& map) {
-return readEdgeMap<typename ReaderTraits::template Reader<typename Map::Value>, Map>(name, map);
+return addEdgeMap<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()) {
+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;
 }
-edge_map_readers.insert(make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));
+edge_map_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()) {
+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)));
+edge_map_readers.insert(
+make_pair(name, new SkipReader<Edge, Reader>(reader)));
 return *this;
 }
 // Node rules
-GraphReader& readNode(std::string name, Node& node) {
+GraphReader& addNode(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));
+return *this;
 }
 // Edge rules
-GraphReader& readEdge(std::string name, Edge& edge) {
+GraphReader& addEdge(std::string name, Edge& edge) {
 if (edge_readers.find(name) != edge_readers.end()) {
 	throw Exception() << "Multiple read rule for edge";
 }
 edge_readers.insert(make_pair(name, &edge));
+return *this;
 }
 void read() {
 int line_num = 0;
 std::auto_ptr<InverterBase<Node> > nodeInverter;
 private:
 template <typename Item> class InverterBase;
-std::string readNodeSet(int& line_num, auto_ptr<InverterBase<Node> > & nodeInverter) {
+std::string readNodeSet(int& line_num,
+			    auto_ptr<InverterBase<Node> > & nodeInverter) {
 std::vector<ReaderBase<Node>* > index;
 {
 	std::string line = readNotEmptyLine(is, line_num);
 	std::string id;
 	std::istringstream ls(line);
 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 < index.size(); ++i) {
+	for (int i = 1; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, node);
 	}
 }
 return line;
 }
 std::string readEdgeSet(int& line_num,
-		     auto_ptr<InverterBase<Edge> > & edgeInverter, auto_ptr<InverterBase<Node> > & nodeInverter) {
+			    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);
 	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 < index.size(); ++i) {
+	for (int i = 1; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, edge);
 	}
 }
 return line;
 }
-std::string readNodes(int& line_num, auto_ptr<InverterBase<Node> >& nodeInverter) {
+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;
 	}
 }
 return line;
 }
-std::string readEdges(int& line_num, auto_ptr<InverterBase<Edge> >& edgeInverter) {
+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;
 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] != '#') {
+	if (vi != (int)string::npos && line[vi] != '#') {
 	  return line.substr(vi);
 	}
 }
 throw DataFormatException("End of stream");
 }
 Inverse inverse;
 MapReaderInverter(Map& _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);
 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()) {
 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;
 };
 Reader reader;
 MapReader(Map& _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);
 typedef _Item Item;
 Reader reader;
 SkipReader(const Reader& _reader) : reader(_reader) {}
+virtual ~SkipReader() {}
 virtual void read(std::istream& is, const Item& item) {
 	Value value;
 	reader.read(is, value);
 }

changeset 1130	47ef467ccf70
parent 1037	3eaff8d04171
child 1133	9fd485470fee