Changeset 1845:f8bbfed86036 in lemon-0.x
- Timestamp:
- 12/03/05 19:17:29 (19 years ago)
- Branch:
- default
- Phase:
- public
- Convert:
- svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2404
- Files:
-
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
lemon/error.h
r1827 r1845 377 377 }; 378 378 379 class IOParameterError : public LogicError {379 class IOParameterError : public IOError { 380 380 protected: 381 381 ExceptionMember<std::string> _message; … … 386 386 387 387 IOParameterError(const IOParameterError &ile) : 388 LogicError(ile), _message(ile._message), _file(ile._file) {}388 IOError(ile), _message(ile._message), _file(ile._file) {} 389 389 390 390 ///\e -
lemon/lemon_reader.h
r1746 r1845 46 46 namespace _reader_bits { 47 47 48 template <typename T> 49 bool operator<(T, T) { 50 throw DataFormatError("Id is not comparable"); 51 } 52 53 template <typename T> 54 struct Less { 55 bool operator()(const T& p, const T& q) const { 56 return p < q; 57 } 58 }; 59 48 60 template <typename Item> 49 61 class ItemIdReader { … … 84 96 85 97 }; 86 87 template <typename T>88 bool operator<(T, T) {89 throw DataFormatError("Id is not comparable");90 }91 92 template <typename T>93 struct Less {94 bool operator()(const T& p, const T& q) const {95 return p < q;96 }97 };98 98 99 99 template <typename Map> … … 197 197 struct Arg<YMap<Map> > { 198 198 typedef const YMap<Map>& Type; 199 }; 200 201 202 template <typename _Item> 203 class MapReaderBase; 204 205 template <typename _Item> 206 class MapInverterBase : public MapReaderBase<_Item> { 207 public: 208 typedef _Item Item; 209 virtual void read(std::istream&, const Item&) = 0; 210 virtual Item read(std::istream&) const = 0; 211 212 virtual MapInverterBase<_Item>* getInverter() { 213 return this; 214 } 215 }; 216 217 template <typename _Item, typename _Map, typename _Reader> 218 class MapReaderInverter : public MapInverterBase<_Item> { 219 public: 220 typedef _Item Item; 221 typedef _Reader Reader; 222 typedef typename Reader::Value Value; 223 typedef _Map Map; 224 typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse; 225 226 typename _reader_bits::Ref<Map>::Type map; 227 Reader reader; 228 Inverse inverse; 229 230 MapReaderInverter(typename _reader_bits::Arg<Map>::Type _map, 231 const Reader& _reader) 232 : map(_map), reader(_reader) {} 233 234 virtual ~MapReaderInverter() {} 235 236 virtual void read(std::istream& is, const Item& item) { 237 Value value; 238 reader.read(is, value); 239 map.set(item, value); 240 typename Inverse::iterator it = inverse.find(value); 241 if (it == inverse.end()) { 242 inverse.insert(std::make_pair(value, item)); 243 } else { 244 throw DataFormatError("Multiple ID occurence"); 245 } 246 } 247 248 virtual Item read(std::istream& is) const { 249 Value value; 250 reader.read(is, value); 251 typename Inverse::const_iterator it = inverse.find(value); 252 if (it != inverse.end()) { 253 return it->second; 254 } else { 255 throw DataFormatError("Invalid ID error"); 256 } 257 } 258 }; 259 260 template <typename _Item, typename _Reader> 261 class SkipReaderInverter : public MapInverterBase<_Item> { 262 public: 263 typedef _Item Item; 264 typedef _Reader Reader; 265 typedef typename Reader::Value Value; 266 typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse; 267 268 Reader reader; 269 270 SkipReaderInverter(const Reader& _reader) 271 : reader(_reader) {} 272 273 virtual ~SkipReaderInverter() {} 274 275 virtual void read(std::istream& is, const Item& item) { 276 Value value; 277 reader.read(is, value); 278 typename Inverse::iterator it = inverse.find(value); 279 if (it == inverse.end()) { 280 inverse.insert(std::make_pair(value, item)); 281 } else { 282 throw DataFormatError("Multiple ID occurence error"); 283 } 284 } 285 286 virtual Item read(std::istream& is) const { 287 Value value; 288 reader.read(is, value); 289 typename Inverse::const_iterator it = inverse.find(value); 290 if (it != inverse.end()) { 291 return it->second; 292 } else { 293 throw DataFormatError("Invalid ID error"); 294 } 295 } 296 297 private: 298 Inverse inverse; 299 }; 300 301 template <typename _Item> 302 class MapReaderBase { 303 public: 304 typedef _Item Item; 305 306 MapReaderBase() { _touched = false; } 307 308 void touch() { _touched = true; } 309 bool touched() const { return _touched; } 310 311 virtual ~MapReaderBase() {} 312 313 virtual void read(std::istream& is, const Item& item) = 0; 314 virtual MapInverterBase<_Item>* getInverter() = 0; 315 316 private: 317 bool _touched; 318 319 }; 320 321 template <typename _Item, typename _Map, typename _Reader> 322 class MapReader : public MapReaderBase<_Item> { 323 public: 324 typedef _Map Map; 325 typedef _Reader Reader; 326 typedef typename Reader::Value Value; 327 typedef _Item Item; 328 329 typename _reader_bits::Ref<Map>::Type map; 330 Reader reader; 331 332 MapReader(typename _reader_bits::Arg<Map>::Type _map, 333 const Reader& _reader) 334 : map(_map), reader(_reader) {} 335 336 virtual ~MapReader() {} 337 338 virtual void read(std::istream& is, const Item& item) { 339 Value value; 340 reader.read(is, value); 341 map.set(item, value); 342 } 343 344 virtual MapInverterBase<_Item>* getInverter() { 345 return new MapReaderInverter<Item, Map, Reader>(map, reader); 346 } 347 }; 348 349 350 template <typename _Item, typename _Reader> 351 class SkipReader : public MapReaderBase<_Item> { 352 public: 353 typedef _Reader Reader; 354 typedef typename Reader::Value Value; 355 typedef _Item Item; 356 357 Reader reader; 358 SkipReader(const Reader& _reader) : reader(_reader) {} 359 360 virtual ~SkipReader() {} 361 362 virtual void read(std::istream& is, const Item&) { 363 Value value; 364 reader.read(is, value); 365 } 366 367 virtual MapInverterBase<Item>* getInverter() { 368 return new SkipReaderInverter<Item, Reader>(reader); 369 } 370 }; 371 372 template <typename _Item> 373 class IdReaderBase { 374 public: 375 typedef _Item Item; 376 virtual ~IdReaderBase() {} 377 virtual Item read(std::istream& is) const = 0; 378 virtual bool isIdReader() const = 0; 379 }; 380 381 template <typename _Item, typename _BoxedIdReader> 382 class IdReader : public IdReaderBase<_Item> { 383 public: 384 typedef _Item Item; 385 typedef _BoxedIdReader BoxedIdReader; 386 387 const BoxedIdReader& boxedIdReader; 388 389 IdReader(const BoxedIdReader& _boxedIdReader) 390 : boxedIdReader(_boxedIdReader) {} 391 392 virtual Item read(std::istream& is) const { 393 Item item; 394 boxedIdReader.readId(is, item); 395 return item; 396 } 397 398 virtual bool isIdReader() const { 399 return boxedIdReader.isIdReader(); 400 } 401 }; 402 403 template <typename _Item> 404 class ItemStore { 405 public: 406 407 typedef _Item Item; 408 409 ItemStore(Item& _item) : item(&_item) { 410 _touched = false; 411 } 412 413 void touch() { _touched = true; } 414 bool touched() const { return _touched; } 415 416 void read(const Item& _item) { 417 *item = _item; 418 } 419 420 private: 421 Item* item; 422 bool _touched; 423 }; 424 425 class ValueReaderBase { 426 public: 427 virtual void read(std::istream&) {}; 428 virtual ~ValueReaderBase() {} 429 }; 430 431 template <typename _Value, typename _Reader> 432 class ValueReader : public ValueReaderBase { 433 public: 434 typedef _Value Value; 435 typedef _Reader Reader; 436 437 ValueReader(Value& _value, const Reader& _reader) 438 : value(_value), reader(_reader) {} 439 440 virtual void read(std::istream& is) { 441 reader.read(is, value); 442 } 443 private: 444 Value& value; 445 Reader reader; 199 446 }; 200 447 … … 470 717 }; 471 718 472 /// \brief Helper class for implementing the common SectionReaders.473 ///474 /// Helper class for implementing the common SectionReaders.475 class CommonSectionReaderBase : public LemonReader::SectionReader {476 typedef LemonReader::SectionReader Parent;477 protected:478 479 /// \brief Constructor for CommonSectionReaderBase.480 ///481 /// Constructor for CommonSectionReaderBase. It attach this reader to482 /// the given LemonReader.483 CommonSectionReaderBase(LemonReader& _reader)484 : Parent(_reader) {}485 486 template <typename _Item>487 class ReaderBase;488 489 template <typename _Item>490 class InverterBase : public ReaderBase<_Item> {491 public:492 typedef _Item Item;493 virtual void read(std::istream&, const Item&) = 0;494 virtual Item read(std::istream&) const = 0;495 496 virtual InverterBase<_Item>* getInverter() {497 return this;498 }499 };500 501 template <typename _Item, typename _Map, typename _Reader>502 class MapReaderInverter : public InverterBase<_Item> {503 public:504 typedef _Item Item;505 typedef _Reader Reader;506 typedef typename Reader::Value Value;507 typedef _Map Map;508 typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;509 510 typename _reader_bits::Ref<Map>::Type map;511 Reader reader;512 Inverse inverse;513 514 MapReaderInverter(typename _reader_bits::Arg<Map>::Type _map,515 const Reader& _reader)516 : map(_map), reader(_reader) {}517 518 virtual ~MapReaderInverter() {}519 520 virtual void read(std::istream& is, const Item& item) {521 Value value;522 reader.read(is, value);523 map.set(item, value);524 typename Inverse::iterator it = inverse.find(value);525 if (it == inverse.end()) {526 inverse.insert(std::make_pair(value, item));527 } else {528 throw DataFormatError("Multiple ID occurence");529 }530 }531 532 virtual Item read(std::istream& is) const {533 Value value;534 reader.read(is, value);535 typename Inverse::const_iterator it = inverse.find(value);536 if (it != inverse.end()) {537 return it->second;538 } else {539 throw DataFormatError("Invalid ID error");540 }541 }542 };543 544 template <typename _Item, typename _Reader>545 class SkipReaderInverter : public InverterBase<_Item> {546 public:547 typedef _Item Item;548 typedef _Reader Reader;549 typedef typename Reader::Value Value;550 typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;551 552 Reader reader;553 554 SkipReaderInverter(const Reader& _reader)555 : reader(_reader) {}556 557 virtual ~SkipReaderInverter() {}558 559 virtual void read(std::istream& is, const Item& item) {560 Value value;561 reader.read(is, value);562 typename Inverse::iterator it = inverse.find(value);563 if (it == inverse.end()) {564 inverse.insert(std::make_pair(value, item));565 } else {566 throw DataFormatError("Multiple ID occurence error");567 }568 }569 570 virtual Item read(std::istream& is) const {571 Value value;572 reader.read(is, value);573 typename Inverse::const_iterator it = inverse.find(value);574 if (it != inverse.end()) {575 return it->second;576 } else {577 throw DataFormatError("Invalid ID error");578 }579 }580 581 private:582 Inverse inverse;583 };584 585 template <typename _Item>586 class ReaderBase {587 public:588 typedef _Item Item;589 590 virtual ~ReaderBase() {}591 592 virtual void read(std::istream& is, const Item& item) = 0;593 virtual InverterBase<_Item>* getInverter() = 0;594 };595 596 template <typename _Item, typename _Map, typename _Reader>597 class MapReader : public ReaderBase<_Item> {598 public:599 typedef _Map Map;600 typedef _Reader Reader;601 typedef typename Reader::Value Value;602 typedef _Item Item;603 604 typename _reader_bits::Ref<Map>::Type map;605 Reader reader;606 607 MapReader(typename _reader_bits::Arg<Map>::Type _map,608 const Reader& _reader)609 : map(_map), reader(_reader) {}610 611 virtual ~MapReader() {}612 613 virtual void read(std::istream& is, const Item& item) {614 Value value;615 reader.read(is, value);616 map.set(item, value);617 }618 619 virtual InverterBase<_Item>* getInverter() {620 return new MapReaderInverter<Item, Map, Reader>(map, reader);621 }622 };623 624 625 template <typename _Item, typename _Reader>626 class SkipReader : public ReaderBase<_Item> {627 public:628 typedef _Reader Reader;629 typedef typename Reader::Value Value;630 typedef _Item Item;631 632 Reader reader;633 SkipReader(const Reader& _reader) : reader(_reader) {}634 635 virtual ~SkipReader() {}636 637 virtual void read(std::istream& is, const Item&) {638 Value value;639 reader.read(is, value);640 }641 642 virtual InverterBase<Item>* getInverter() {643 return new SkipReaderInverter<Item, Reader>(reader);644 }645 };646 647 template <typename _Item>648 class IdReaderBase {649 public:650 typedef _Item Item;651 virtual ~IdReaderBase() {}652 virtual Item read(std::istream& is) const = 0;653 virtual bool isIdReader() const = 0;654 };655 656 template <typename _Item, typename _BoxedIdReader>657 class IdReader : public IdReaderBase<_Item> {658 public:659 typedef _Item Item;660 typedef _BoxedIdReader BoxedIdReader;661 662 const BoxedIdReader& boxedIdReader;663 664 IdReader(const BoxedIdReader& _boxedIdReader)665 : boxedIdReader(_boxedIdReader) {}666 667 virtual Item read(std::istream& is) const {668 Item item;669 boxedIdReader.readId(is, item);670 return item;671 }672 673 virtual bool isIdReader() const {674 return boxedIdReader.isIdReader();675 }676 };677 678 class ValueReaderBase {679 public:680 virtual void read(std::istream&) {};681 virtual ~ValueReaderBase() {}682 };683 684 template <typename _Value, typename _Reader>685 class ValueReader : public ValueReaderBase {686 public:687 typedef _Value Value;688 typedef _Reader Reader;689 690 ValueReader(Value& _value, const Reader& _reader)691 : value(_value), reader(_reader) {}692 693 virtual void read(std::istream& is) {694 reader.read(is, value);695 }696 private:697 Value& value;698 Reader reader;699 };700 701 };702 703 719 /// \ingroup io_group 704 720 /// \brief SectionReader for reading a graph's nodeset. … … 719 735 /// \relates LemonReader 720 736 template <typename _Graph, typename _Traits = DefaultReaderTraits> 721 class NodeSetReader : public CommonSectionReaderBase{722 typedef CommonSectionReaderBaseParent;737 class NodeSetReader : public LemonReader::SectionReader { 738 typedef LemonReader::SectionReader Parent; 723 739 public: 724 740 … … 802 818 msg << "Multiple read rule for node map: " << name; 803 819 throw IOParameterError(msg.message()); 804 } 820 } 805 821 readers.insert( 806 make_pair(name, new MapReader<Node, Map, Reader>(map, reader))); 822 make_pair(name, new _reader_bits:: 823 MapReader<Node, Map, Reader>(map, reader))); 807 824 return *this; 808 825 } … … 821 838 throw IOParameterError(msg.message()); 822 839 } 823 readers.insert(make_pair(name, new SkipReader<Node, Reader>(reader))); 840 readers.insert(make_pair(name, new _reader_bits:: 841 SkipReader<Node, Reader>(reader))); 824 842 return *this; 825 843 } … … 844 862 /// It reads the content of the section. 845 863 virtual void read(std::istream& is) { 846 std::vector< ReaderBase<Node>* > index;864 std::vector<_reader_bits::MapReaderBase<Node>* > index; 847 865 std::string line; 848 866 … … 852 870 typename MapReaders::iterator it = readers.find(id); 853 871 if (it != readers.end()) { 872 it->second->touch(); 854 873 index.push_back(it->second); 855 874 } else { … … 859 878 inverter.reset(index.back()->getInverter()); 860 879 index.back() = inverter.get(); 880 } 881 } 882 for (typename MapReaders::iterator it = readers.begin(); 883 it != readers.end(); ++it) { 884 if (!it->second->touched()) { 885 ErrorMessage msg; 886 msg << "Map not found in file: " << it->first; 887 throw IOParameterError(msg.message()); 861 888 } 862 889 } … … 890 917 private: 891 918 892 typedef std::map<std::string, ReaderBase<Node>*> MapReaders;919 typedef std::map<std::string, _reader_bits::MapReaderBase<Node>*> MapReaders; 893 920 MapReaders readers; 894 921 895 922 Graph& graph; 896 923 std::string id; 897 SkipReader<Node, DefaultSkipper> skipper;898 899 std::auto_ptr< InverterBase<Node> > inverter;924 _reader_bits::SkipReader<Node, DefaultSkipper> skipper; 925 926 std::auto_ptr<_reader_bits::MapInverterBase<Node> > inverter; 900 927 }; 901 928 … … 923 950 /// \relates LemonReader 924 951 template <typename _Graph, typename _Traits = DefaultReaderTraits> 925 class EdgeSetReader : public CommonSectionReaderBase{926 typedef CommonSectionReaderBaseParent;952 class EdgeSetReader : public LemonReader::SectionReader { 953 typedef LemonReader::SectionReader Parent; 927 954 public: 928 955 … … 949 976 : Parent(_reader), graph(_graph), id(_id), skipper(_skipper) { 950 977 checkConcept<_reader_bits::ItemIdReader<Node>, NodeIdReader>(); 951 nodeIdReader.reset(new IdReader<Node, NodeIdReader>(_nodeIdReader)); 978 nodeIdReader.reset(new _reader_bits:: 979 IdReader<Node, NodeIdReader>(_nodeIdReader)); 952 980 } 953 981 /// \brief Destructor. … … 1014 1042 } 1015 1043 readers.insert( 1016 make_pair(name, new MapReader<Edge, Map, Reader>(map, reader))); 1044 make_pair(name, new _reader_bits:: 1045 MapReader<Edge, Map, Reader>(map, reader))); 1017 1046 return *this; 1018 1047 } … … 1031 1060 throw IOParameterError(msg.message()); 1032 1061 } 1033 readers.insert(make_pair(name, new SkipReader<Edge, Reader>(reader))); 1062 readers.insert(make_pair(name, new _reader_bits:: 1063 SkipReader<Edge, Reader>(reader))); 1034 1064 return *this; 1035 1065 } … … 1057 1087 throw DataFormatError("Cannot find nodeset or ID map"); 1058 1088 } 1059 std::vector< ReaderBase<Edge>* > index;1089 std::vector<_reader_bits::MapReaderBase<Edge>* > index; 1060 1090 std::string line; 1061 1091 … … 1066 1096 if (it != readers.end()) { 1067 1097 index.push_back(it->second); 1098 it->second->touch(); 1068 1099 } else { 1069 1100 index.push_back(&skipper); … … 1072 1103 inverter.reset(index.back()->getInverter()); 1073 1104 index.back() = inverter.get(); 1105 } 1106 } 1107 for (typename MapReaders::iterator it = readers.begin(); 1108 it != readers.end(); ++it) { 1109 if (!it->second->touched()) { 1110 ErrorMessage msg; 1111 msg << "Map not found in file: " << it->first; 1112 throw IOParameterError(msg.message()); 1074 1113 } 1075 1114 } … … 1105 1144 private: 1106 1145 1107 typedef std::map<std::string, ReaderBase<Edge>*> MapReaders;1146 typedef std::map<std::string, _reader_bits::MapReaderBase<Edge>*> MapReaders; 1108 1147 MapReaders readers; 1109 1148 1110 1149 Graph& graph; 1111 1150 std::string id; 1112 SkipReader<Edge, DefaultSkipper> skipper;1113 1114 std::auto_ptr< InverterBase<Edge> > inverter;1115 std::auto_ptr< IdReaderBase<Node> > nodeIdReader;1151 _reader_bits::SkipReader<Edge, DefaultSkipper> skipper; 1152 1153 std::auto_ptr<_reader_bits::MapInverterBase<Edge> > inverter; 1154 std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader; 1116 1155 }; 1117 1156 … … 1144 1183 /// \relates LemonReader 1145 1184 template <typename _Graph, typename _Traits = DefaultReaderTraits> 1146 class UndirEdgeSetReader : public CommonSectionReaderBase{1147 typedef CommonSectionReaderBaseParent;1185 class UndirEdgeSetReader : public LemonReader::SectionReader { 1186 typedef LemonReader::SectionReader Parent; 1148 1187 public: 1149 1188 … … 1171 1210 : Parent(_reader), graph(_graph), id(_id), skipper(_skipper) { 1172 1211 checkConcept<_reader_bits::ItemIdReader<Node>, NodeIdReader>(); 1173 nodeIdReader.reset(new IdReader<Node, NodeIdReader>(_nodeIdReader)); 1212 nodeIdReader.reset(new _reader_bits:: 1213 IdReader<Node, NodeIdReader>(_nodeIdReader)); 1174 1214 } 1175 1215 /// \brief Destructor. … … 1236 1276 } 1237 1277 readers.insert( 1238 make_pair(name, new MapReader<UndirEdge, Map, Reader>(map, reader))); 1278 make_pair(name, new _reader_bits:: 1279 MapReader<UndirEdge, Map, Reader>(map, reader))); 1239 1280 return *this; 1240 1281 } … … 1253 1294 throw IOParameterError(msg.message()); 1254 1295 } 1255 readers.insert(make_pair(name, 1256 newSkipReader<UndirEdge, Reader>(reader)));1296 readers.insert(make_pair(name, new _reader_bits:: 1297 SkipReader<UndirEdge, Reader>(reader))); 1257 1298 return *this; 1258 1299 } … … 1341 1382 throw DataFormatError("Cannot find nodeset or ID map"); 1342 1383 } 1343 std::vector< ReaderBase<UndirEdge>* > index;1384 std::vector<_reader_bits::MapReaderBase<UndirEdge>* > index; 1344 1385 std::string line; 1345 1386 … … 1350 1391 if (it != readers.end()) { 1351 1392 index.push_back(it->second); 1393 it->second->touch(); 1352 1394 } else { 1353 1395 index.push_back(&skipper); … … 1356 1398 inverter.reset(index.back()->getInverter()); 1357 1399 index.back() = inverter.get(); 1400 } 1401 } 1402 for (typename MapReaders::iterator it = readers.begin(); 1403 it != readers.end(); ++it) { 1404 if (!it->second->touched()) { 1405 ErrorMessage msg; 1406 msg << "Map not found in file: " << it->first; 1407 throw IOParameterError(msg.message()); 1358 1408 } 1359 1409 } … … 1409 1459 private: 1410 1460 1411 typedef std::map<std::string, ReaderBase<UndirEdge>*> MapReaders; 1461 typedef std::map<std::string, 1462 _reader_bits::MapReaderBase<UndirEdge>*> MapReaders; 1412 1463 MapReaders readers; 1413 1464 1414 1465 Graph& graph; 1415 1466 std::string id; 1416 SkipReader<UndirEdge, DefaultSkipper> skipper;1417 1418 std::auto_ptr< InverterBase<UndirEdge> > inverter;1419 std::auto_ptr< IdReaderBase<Node> > nodeIdReader;1467 _reader_bits::SkipReader<UndirEdge, DefaultSkipper> skipper; 1468 1469 std::auto_ptr<_reader_bits::MapInverterBase<UndirEdge> > inverter; 1470 std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader; 1420 1471 }; 1421 1472 … … 1431 1482 /// \relates LemonReader 1432 1483 template <typename _Graph> 1433 class NodeReader : public CommonSectionReaderBase{1434 typedef CommonSectionReaderBaseParent;1484 class NodeReader : public LemonReader::SectionReader { 1485 typedef LemonReader::SectionReader Parent; 1435 1486 typedef _Graph Graph; 1436 1487 typedef typename Graph::Node Node; … … 1448 1499 : Parent(_reader), id(_id) { 1449 1500 checkConcept<_reader_bits::ItemIdReader<Node>, _IdReader>(); 1450 nodeIdReader.reset(new IdReader<Node, _IdReader>(_idReader)); 1501 nodeIdReader.reset(new _reader_bits:: 1502 IdReader<Node, _IdReader>(_idReader)); 1451 1503 } 1452 1504 … … 1471 1523 throw IOParameterError(msg.message()); 1472 1524 } 1473 readers.insert(make_pair(name, &item));1525 readers.insert(make_pair(name, _reader_bits::ItemStore<Node>(item))); 1474 1526 } 1475 1527 … … 1503 1555 typename NodeReaders::iterator it = readers.find(id); 1504 1556 if (it != readers.end()) { 1505 *(it->second) = nodeIdReader->read(ls); 1557 it->second.read(nodeIdReader->read(ls)); 1558 it->second.touch(); 1506 1559 } 1560 } 1561 for (typename NodeReaders::iterator it = readers.begin(); 1562 it != readers.end(); ++it) { 1563 if (!it->second.touched()) { 1564 ErrorMessage msg; 1565 msg << "Node not found in file: " << it->first; 1566 throw IOParameterError(msg.message()); 1567 } 1507 1568 } 1508 1569 } … … 1512 1573 std::string id; 1513 1574 1514 typedef std::map<std::string, Node*> NodeReaders;1575 typedef std::map<std::string, _reader_bits::ItemStore<Node> > NodeReaders; 1515 1576 NodeReaders readers; 1516 std::auto_ptr< IdReaderBase<Node> > nodeIdReader;1577 std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader; 1517 1578 }; 1518 1579 … … 1528 1589 /// \relates LemonReader 1529 1590 template <typename _Graph> 1530 class EdgeReader : public CommonSectionReaderBase{1531 typedef CommonSectionReaderBaseParent;1591 class EdgeReader : public LemonReader::SectionReader { 1592 typedef LemonReader::SectionReader Parent; 1532 1593 typedef _Graph Graph; 1533 1594 typedef typename Graph::Edge Edge; … … 1545 1606 : Parent(_reader), id(_id) { 1546 1607 checkConcept<_reader_bits::ItemIdReader<Edge>, _IdReader>(); 1547 edgeIdReader.reset(new IdReader<Edge, _IdReader>(_idReader)); 1608 edgeIdReader.reset(new _reader_bits:: 1609 IdReader<Edge, _IdReader>(_idReader)); 1548 1610 } 1549 1611 … … 1567 1629 throw IOParameterError(msg.message()); 1568 1630 } 1569 readers.insert(make_pair(name, &item));1631 readers.insert(make_pair(name, _reader_bits::ItemStore<Edge>(item))); 1570 1632 } 1571 1633 … … 1599 1661 typename EdgeReaders::iterator it = readers.find(id); 1600 1662 if (it != readers.end()) { 1601 *(it->second) = edgeIdReader->read(ls); 1663 it->second.read(edgeIdReader->read(ls)); 1664 it->second.touch(); 1602 1665 } 1666 } 1667 for (typename EdgeReaders::iterator it = readers.begin(); 1668 it != readers.end(); ++it) { 1669 if (!it->second.touched()) { 1670 ErrorMessage msg; 1671 msg << "Edge not found in file: " << it->first; 1672 throw IOParameterError(msg.message()); 1673 } 1603 1674 } 1604 1675 } … … 1608 1679 std::string id; 1609 1680 1610 typedef std::map<std::string, Edge*> EdgeReaders;1681 typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders; 1611 1682 EdgeReaders readers; 1612 std::auto_ptr< IdReaderBase<Edge> > edgeIdReader;1683 std::auto_ptr<_reader_bits::IdReaderBase<Edge> > edgeIdReader; 1613 1684 }; 1614 1685 … … 1624 1695 /// \relates LemonReader 1625 1696 template <typename _Graph> 1626 class UndirEdgeReader : public CommonSectionReaderBase{1627 typedef CommonSectionReaderBaseParent;1697 class UndirEdgeReader : public LemonReader::SectionReader { 1698 typedef LemonReader::SectionReader Parent; 1628 1699 typedef _Graph Graph; 1629 1700 typedef typename Graph::Edge Edge; … … 1644 1715 checkConcept<_reader_bits::ItemIdReader<UndirEdge>, _IdReader>(); 1645 1716 checkConcept<_reader_bits::ItemIdReader<Edge>, _IdReader>(); 1646 undirEdgeIdReader.reset(new IdReader<UndirEdge, _IdReader>(_idReader)); 1647 edgeIdReader.reset(new IdReader<Edge, _IdReader>(_idReader)); 1717 undirEdgeIdReader.reset(new _reader_bits:: 1718 IdReader<UndirEdge, _IdReader>(_idReader)); 1719 edgeIdReader.reset(new _reader_bits:: 1720 IdReader<Edge, _IdReader>(_idReader)); 1648 1721 } 1649 1722 … … 1667 1740 throw IOParameterError(msg.message()); 1668 1741 } 1669 undirEdgeReaders.insert(make_pair(name, &item)); 1742 undirEdgeReaders.insert(make_pair(name, _reader_bits:: 1743 ItemStore<UndirEdge>(item))); 1670 1744 } 1671 1745 … … 1679 1753 throw IOParameterError(msg.message()); 1680 1754 } 1681 edgeReaders.insert(make_pair(name, &item));1755 edgeReaders.insert(make_pair(name, _reader_bits::ItemStore<Edge>(item))); 1682 1756 } 1683 1757 … … 1715 1789 typename UndirEdgeReaders::iterator it = undirEdgeReaders.find(id); 1716 1790 if (it != undirEdgeReaders.end()) { 1717 *(it->second) = undirEdgeIdReader->read(ls); 1718 break; 1791 it->second.read(undirEdgeIdReader->read(ls)); 1792 it->second.touch(); 1793 continue; 1719 1794 } 1720 1795 } { 1721 1796 typename EdgeReaders::iterator it = edgeReaders.find(id); 1722 1797 if (it != edgeReaders.end()) { 1723 *(it->second) = edgeIdReader->read(ls); 1724 break; 1798 it->second.read(edgeIdReader->read(ls)); 1799 it->second.touch(); 1800 continue; 1725 1801 } 1802 } 1803 } 1804 for (typename EdgeReaders::iterator it = edgeReaders.begin(); 1805 it != edgeReaders.end(); ++it) { 1806 if (!it->second.touched()) { 1807 ErrorMessage msg; 1808 msg << "Edge not found in file: " << it->first; 1809 throw IOParameterError(msg.message()); 1810 } 1811 } 1812 for (typename UndirEdgeReaders::iterator it = undirEdgeReaders.begin(); 1813 it != undirEdgeReaders.end(); ++it) { 1814 if (!it->second.touched()) { 1815 ErrorMessage msg; 1816 msg << "UndirEdge not found in file: " << it->first; 1817 throw IOParameterError(msg.message()); 1726 1818 } 1727 1819 } … … 1732 1824 std::string id; 1733 1825 1734 typedef std::map<std::string, UndirEdge*> UndirEdgeReaders; 1826 typedef std::map<std::string, 1827 _reader_bits::ItemStore<UndirEdge> > UndirEdgeReaders; 1735 1828 UndirEdgeReaders undirEdgeReaders; 1736 std::auto_ptr< IdReaderBase<UndirEdge> > undirEdgeIdReader;1737 1738 typedef std::map<std::string, Edge*> EdgeReaders;1829 std::auto_ptr<_reader_bits::IdReaderBase<UndirEdge> > undirEdgeIdReader; 1830 1831 typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders; 1739 1832 EdgeReaders edgeReaders; 1740 std::auto_ptr< IdReaderBase<Edge> > edgeIdReader;1833 std::auto_ptr<_reader_bits::IdReaderBase<Edge> > edgeIdReader; 1741 1834 }; 1742 1835 … … 1753 1846 /// \relates LemonReader 1754 1847 template <typename _Traits = DefaultReaderTraits> 1755 class AttributeReader : public CommonSectionReaderBase{1756 typedef CommonSectionReaderBaseParent;1848 class AttributeReader : public LemonReader::SectionReader { 1849 typedef LemonReader::SectionReader Parent; 1757 1850 typedef _Traits Traits; 1758 1851 public: … … 1802 1895 throw IOParameterError(msg.message()); 1803 1896 } 1804 readers.insert(make_pair(name, new ValueReader<Value, Reader>1805 1897 readers.insert(make_pair(name, new _reader_bits:: 1898 ValueReader<Value, Reader>(value, reader))); 1806 1899 return *this; 1807 1900 } … … 1841 1934 std::string id; 1842 1935 1843 typedef std::map<std::string, ValueReaderBase*> Readers;1936 typedef std::map<std::string, _reader_bits::ValueReaderBase*> Readers; 1844 1937 Readers readers; 1845 1938 }; -
lemon/lemon_writer.h
r1705 r1845 165 165 }; 166 166 167 168 template <typename _Item> 169 class MapWriterBase { 170 public: 171 typedef _Item Item; 172 173 virtual ~MapWriterBase() {} 174 175 virtual void write(std::ostream& os, const Item& item) = 0; 176 }; 177 178 179 template <typename _Item, typename _Map, typename _Writer> 180 class MapWriter : public MapWriterBase<_Item> { 181 public: 182 typedef _Map Map; 183 typedef _Writer Writer; 184 typedef typename Writer::Value Value; 185 typedef _Item Item; 186 187 typename _writer_bits::Ref<Map>::Type map; 188 Writer writer; 189 190 MapWriter(const Map& _map, const Writer& _writer) 191 : map(_map), writer(_writer) {} 192 193 virtual ~MapWriter() {} 194 195 virtual void write(std::ostream& os, const Item& item) { 196 Value value = map[item]; 197 writer.write(os, value); 198 } 199 200 }; 201 202 203 class ValueWriterBase { 204 public: 205 virtual ~ValueWriterBase() {} 206 virtual void write(std::ostream&) = 0; 207 }; 208 209 template <typename _Value, typename _Writer> 210 class ValueWriter : public ValueWriterBase { 211 public: 212 typedef _Value Value; 213 typedef _Writer Writer; 214 215 ValueWriter(const Value& _value, const Writer& _writer) 216 : value(_value), writer(_writer) {} 217 218 virtual void write(std::ostream& os) { 219 writer.write(os, value); 220 } 221 private: 222 const Value& value; 223 Writer writer; 224 }; 225 226 227 template <typename _Item> 228 class IdWriterBase { 229 public: 230 typedef _Item Item; 231 virtual ~IdWriterBase() {} 232 virtual void write(std::ostream&, const Item&) const = 0; 233 virtual bool isIdWriter() const = 0; 234 }; 235 236 template <typename _Item, typename _BoxedIdWriter> 237 class IdWriter : public IdWriterBase<_Item> { 238 public: 239 typedef _Item Item; 240 typedef _BoxedIdWriter BoxedIdWriter; 241 242 const BoxedIdWriter& idWriter; 243 244 IdWriter(const BoxedIdWriter& _idWriter) 245 : idWriter(_idWriter) {} 246 247 virtual void write(std::ostream& os, const Item& item) const { 248 idWriter.writeId(os, item); 249 } 250 251 virtual bool isIdWriter() const { 252 return idWriter.isIdWriter(); 253 } 254 }; 255 167 256 } 168 257 … … 282 371 }; 283 372 284 /// \brief Helper class for implementing the common SectionWriters.285 ///286 /// Helper class for implementing the common SectionWriters.287 class CommonSectionWriterBase : public LemonWriter::SectionWriter {288 typedef LemonWriter::SectionWriter Parent;289 protected:290 291 /// \brief Constructor for CommonSectionWriterBase.292 ///293 /// Constructor for CommonSectionWriterBase. It attach this writer to294 /// the given LemonWriter.295 CommonSectionWriterBase(LemonWriter& _writer)296 : Parent(_writer) {}297 298 template <typename _Item>299 class WriterBase {300 public:301 typedef _Item Item;302 303 virtual ~WriterBase() {}304 305 virtual void write(std::ostream& os, const Item& item) = 0;306 };307 308 309 template <typename _Item, typename _Map, typename _Writer>310 class MapWriter : public WriterBase<_Item> {311 public:312 typedef _Map Map;313 typedef _Writer Writer;314 typedef typename Writer::Value Value;315 typedef _Item Item;316 317 typename _writer_bits::Ref<Map>::Type map;318 Writer writer;319 320 MapWriter(const Map& _map, const Writer& _writer)321 : map(_map), writer(_writer) {}322 323 virtual ~MapWriter() {}324 325 virtual void write(std::ostream& os, const Item& item) {326 Value value = map[item];327 writer.write(os, value);328 }329 330 };331 332 333 class ValueWriterBase {334 public:335 virtual ~ValueWriterBase() {}336 virtual void write(std::ostream&) = 0;337 };338 339 template <typename _Value, typename _Writer>340 class ValueWriter : public ValueWriterBase {341 public:342 typedef _Value Value;343 typedef _Writer Writer;344 345 ValueWriter(const Value& _value, const Writer& _writer)346 : value(_value), writer(_writer) {}347 348 virtual void write(std::ostream& os) {349 writer.write(os, value);350 }351 private:352 const Value& value;353 Writer writer;354 };355 356 357 template <typename _Item>358 class IdWriterBase {359 public:360 typedef _Item Item;361 virtual ~IdWriterBase() {}362 virtual void write(std::ostream&, const Item&) const = 0;363 virtual bool isIdWriter() const = 0;364 };365 366 template <typename _Item, typename _BoxedIdWriter>367 class IdWriter : public IdWriterBase<_Item> {368 public:369 typedef _Item Item;370 typedef _BoxedIdWriter BoxedIdWriter;371 372 const BoxedIdWriter& idWriter;373 374 IdWriter(const BoxedIdWriter& _idWriter)375 : idWriter(_idWriter) {}376 377 virtual void write(std::ostream& os, const Item& item) const {378 idWriter.writeId(os, item);379 }380 381 virtual bool isIdWriter() const {382 return idWriter.isIdWriter();383 }384 };385 };386 387 373 /// \ingroup io_group 388 374 /// \brief SectionWriter for writing a graph's nodeset. … … 404 390 /// \relates LemonWriter 405 391 template <typename _Graph, typename _Traits = DefaultWriterTraits> 406 class NodeSetWriter : public CommonSectionWriterBase{407 typedef CommonSectionWriterBaseParent;392 class NodeSetWriter : public LemonWriter::SectionWriter { 393 typedef LemonWriter::SectionWriter Parent; 408 394 public: 409 395 … … 458 444 checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>(); 459 445 writers.push_back( 460 make_pair(name, new MapWriter<Node, Map, Writer>(map, writer))); 446 make_pair(name, new _writer_bits:: 447 MapWriter<Node, Map, Writer>(map, writer))); 461 448 return *this; 462 449 } … … 528 515 private: 529 516 530 typedef std::vector<std::pair<std::string, WriterBase<Node>*> > MapWriters; 517 typedef std::vector<std::pair<std::string, _writer_bits:: 518 MapWriterBase<Node>*> > MapWriters; 531 519 MapWriters writers; 532 520 533 WriterBase<Node>* idMap;521 _writer_bits::MapWriterBase<Node>* idMap; 534 522 bool forceIdMap; 535 523 … … 563 551 /// \relates LemonWriter 564 552 template <typename _Graph, typename _Traits = DefaultWriterTraits> 565 class EdgeSetWriter : public CommonSectionWriterBase{566 typedef CommonSectionWriterBaseParent;553 class EdgeSetWriter : public LemonWriter::SectionWriter { 554 typedef LemonWriter::SectionWriter Parent; 567 555 public: 568 556 … … 587 575 graph(_graph), id(_id) { 588 576 checkConcept<_writer_bits::ItemIdWriter<Node>, NodeIdWriter>(); 589 nodeIdWriter.reset(new IdWriter<Node, NodeIdWriter>(_nodeIdWriter)); 577 nodeIdWriter.reset(new _writer_bits:: 578 IdWriter<Node, NodeIdWriter>(_nodeIdWriter)); 590 579 } 591 580 … … 624 613 checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>(); 625 614 writers.push_back( 626 make_pair(name, new MapWriter<Edge, Map, Writer>(map, writer))); 615 make_pair(name, new _writer_bits:: 616 MapWriter<Edge, Map, Writer>(map, writer))); 627 617 return *this; 628 618 } … … 702 692 private: 703 693 704 typedef std::vector<std::pair<std::string, WriterBase<Edge>*> > MapWriters; 694 typedef std::vector<std::pair<std::string, _writer_bits:: 695 MapWriterBase<Edge>*> > MapWriters; 705 696 MapWriters writers; 706 697 707 WriterBase<Edge>* idMap;698 _writer_bits::MapWriterBase<Edge>* idMap; 708 699 bool forceIdMap; 709 700 … … 711 702 std::string id; 712 703 713 std::auto_ptr< IdWriterBase<Node> > nodeIdWriter;704 std::auto_ptr<_writer_bits::IdWriterBase<Node> > nodeIdWriter; 714 705 }; 715 706 … … 744 735 /// \relates LemonWriter 745 736 template <typename _Graph, typename _Traits = DefaultWriterTraits> 746 class UndirEdgeSetWriter : public CommonSectionWriterBase{747 typedef CommonSectionWriterBaseParent;737 class UndirEdgeSetWriter : public LemonWriter::SectionWriter { 738 typedef LemonWriter::SectionWriter Parent; 748 739 public: 749 740 … … 769 760 graph(_graph), id(_id) { 770 761 checkConcept<_writer_bits::ItemIdWriter<Node>, NodeIdWriter>(); 771 nodeIdWriter.reset(new IdWriter<Node, NodeIdWriter>(_nodeIdWriter)); 762 nodeIdWriter.reset(new _writer_bits:: 763 IdWriter<Node, NodeIdWriter>(_nodeIdWriter)); 772 764 } 773 765 … … 806 798 checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>(); 807 799 writers.push_back( 808 make_pair(name, new MapWriter<UndirEdge, Map, Writer>(map, writer))); 800 make_pair(name, new _writer_bits:: 801 MapWriter<UndirEdge, Map, Writer>(map, writer))); 809 802 return *this; 810 803 } … … 929 922 private: 930 923 931 typedef std::vector<std::pair<std::string, 932 WriterBase<UndirEdge>*> > MapWriters;924 typedef std::vector<std::pair<std::string, _writer_bits:: 925 MapWriterBase<UndirEdge>*> > MapWriters; 933 926 MapWriters writers; 934 927 935 WriterBase<UndirEdge>* idMap;928 _writer_bits::MapWriterBase<UndirEdge>* idMap; 936 929 bool forceIdMap; 937 930 … … 939 932 std::string id; 940 933 941 std::auto_ptr< IdWriterBase<Node> > nodeIdWriter;934 std::auto_ptr<_writer_bits::IdWriterBase<Node> > nodeIdWriter; 942 935 }; 943 936 … … 953 946 /// \relates LemonWriter 954 947 template <typename _Graph> 955 class NodeWriter : public CommonSectionWriterBase{956 typedef CommonSectionWriterBaseParent;948 class NodeWriter : public LemonWriter::SectionWriter { 949 typedef LemonWriter::SectionWriter Parent; 957 950 typedef _Graph Graph; 958 951 typedef typename Graph::Node Node; … … 969 962 : Parent(_writer), id(_id) { 970 963 checkConcept<_writer_bits::ItemIdWriter<Node>, _IdWriter>(); 971 idWriter.reset(new IdWriter<Node, _IdWriter>(_idWriter));964 idWriter.reset(new _writer_bits::IdWriter<Node, _IdWriter>(_idWriter)); 972 965 } 973 966 … … 1021 1014 typedef std::vector<std::pair<std::string, const Node*> > NodeWriters; 1022 1015 NodeWriters writers; 1023 std::auto_ptr< IdWriterBase<Node> > idWriter;1016 std::auto_ptr<_writer_bits::IdWriterBase<Node> > idWriter; 1024 1017 }; 1025 1018 … … 1035 1028 /// \relates LemonWriter 1036 1029 template <typename _Graph> 1037 class EdgeWriter : public CommonSectionWriterBase{1038 typedef CommonSectionWriterBaseParent;1030 class EdgeWriter : public LemonWriter::SectionWriter { 1031 typedef LemonWriter::SectionWriter Parent; 1039 1032 typedef _Graph Graph; 1040 1033 typedef typename Graph::Edge Edge; … … 1051 1044 : Parent(_writer), id(_id) { 1052 1045 checkConcept<_writer_bits::ItemIdWriter<Edge>, _IdWriter>(); 1053 idWriter.reset(new IdWriter<Edge, _IdWriter>(_idWriter));1046 idWriter.reset(new _writer_bits::IdWriter<Edge, _IdWriter>(_idWriter)); 1054 1047 } 1055 1048 … … 1102 1095 EdgeWriters writers; 1103 1096 1104 std::auto_ptr< IdWriterBase<Edge> > idWriter;1097 std::auto_ptr<_writer_bits::IdWriterBase<Edge> > idWriter; 1105 1098 }; 1106 1099 … … 1116 1109 /// \relates LemonWriter 1117 1110 template <typename _Graph> 1118 class UndirEdgeWriter : public CommonSectionWriterBase{1119 typedef CommonSectionWriterBaseParent;1111 class UndirEdgeWriter : public LemonWriter::SectionWriter { 1112 typedef LemonWriter::SectionWriter Parent; 1120 1113 typedef _Graph Graph; 1121 1114 typedef typename Graph::Node Node; … … 1136 1129 checkConcept<_writer_bits::ItemIdWriter<Edge>, _IdWriter>(); 1137 1130 checkConcept<_writer_bits::ItemIdWriter<UndirEdge>, _IdWriter>(); 1138 undirEdgeIdWriter.reset(new IdWriter<UndirEdge, _IdWriter>(_idWriter)); 1139 edgeIdWriter.reset(new IdWriter<Edge, _IdWriter>(_idWriter)); 1131 undirEdgeIdWriter.reset(new _writer_bits:: 1132 IdWriter<UndirEdge, _IdWriter>(_idWriter)); 1133 edgeIdWriter.reset(new _writer_bits:: 1134 IdWriter<Edge, _IdWriter>(_idWriter)); 1140 1135 } 1141 1136 … … 1203 1198 const UndirEdge*> > UndirEdgeWriters; 1204 1199 UndirEdgeWriters undirEdgeWriters; 1205 std::auto_ptr< IdWriterBase<UndirEdge> > undirEdgeIdWriter;1200 std::auto_ptr<_writer_bits::IdWriterBase<UndirEdge> > undirEdgeIdWriter; 1206 1201 1207 1202 typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters; 1208 1203 EdgeWriters edgeWriters; 1209 std::auto_ptr< IdWriterBase<Edge> > edgeIdWriter;1204 std::auto_ptr<_writer_bits::IdWriterBase<Edge> > edgeIdWriter; 1210 1205 1211 1206 }; … … 1223 1218 /// \relates LemonWriter 1224 1219 template <typename _Traits = DefaultWriterTraits> 1225 class AttributeWriter : public CommonSectionWriterBase{1226 typedef CommonSectionWriterBaseParent;1220 class AttributeWriter : public LemonWriter::SectionWriter { 1221 typedef LemonWriter::SectionWriter Parent; 1227 1222 typedef _Traits Traits; 1228 1223 public: … … 1268 1263 const Writer& writer = Writer()) { 1269 1264 checkConcept<_writer_bits::ItemWriter<Value>, Writer>(); 1270 writers.push_back(make_pair(name, new ValueWriter<Value, Writer>1271 1265 writers.push_back(make_pair(name, new _writer_bits:: 1266 ValueWriter<Value, Writer>(value, writer))); 1272 1267 return *this; 1273 1268 } … … 1297 1292 std::string id; 1298 1293 1299 typedef std::vector<std::pair<std::string, ValueWriterBase*> > Writers; 1294 typedef std::vector<std::pair<std::string, 1295 _writer_bits::ValueWriterBase*> > Writers; 1300 1296 Writers writers; 1301 1297 }; -
test/heap_test.cc
r1744 r1845 57 57 check(input, "Input file '" << f_name << "' not found."); 58 58 GraphReader<Graph>(input, graph). 59 readEdgeMap(" length", length).59 readEdgeMap("capacity", length). 60 60 readNode("source", start). 61 61 run();
Note: See TracChangeset
for help on using the changeset viewer.