543 |
543 |
544 IdReader(const BoxedIdReader& _boxedIdReader) |
544 IdReader(const BoxedIdReader& _boxedIdReader) |
545 : boxedIdReader(_boxedIdReader) {} |
545 : boxedIdReader(_boxedIdReader) {} |
546 |
546 |
547 virtual Item read(std::istream& is) const { |
547 virtual Item read(std::istream& is) const { |
548 return boxedIdReader.readId(is); |
548 return boxedIdReader.readId(is, Item()); |
549 } |
549 } |
550 }; |
550 }; |
551 |
551 |
552 class ValueReaderBase { |
552 class ValueReaderBase { |
553 public: |
553 public: |
595 typedef CommonSectionReaderBase Parent; |
595 typedef CommonSectionReaderBase Parent; |
596 public: |
596 public: |
597 |
597 |
598 typedef _Graph Graph; |
598 typedef _Graph Graph; |
599 typedef _Traits Traits; |
599 typedef _Traits Traits; |
600 typedef typename Graph::Node Item; |
600 typedef typename Graph::Node Node; |
601 typedef typename Traits::Skipper DefaultSkipper; |
601 typedef typename Traits::Skipper DefaultSkipper; |
602 |
602 |
603 /// \brief Constructor. |
603 /// \brief Constructor. |
604 /// |
604 /// |
605 /// Constructor for NodeSetReader. It creates the NodeSetReader and |
605 /// Constructor for NodeSetReader. It creates the NodeSetReader and |
650 /// |
650 /// |
651 /// Add a new node map reader command for the reader. |
651 /// Add a new node map reader command for the reader. |
652 template <typename Reader, typename Map> |
652 template <typename Reader, typename Map> |
653 NodeSetReader& readNodeMap(std::string name, Map& map, |
653 NodeSetReader& readNodeMap(std::string name, Map& map, |
654 const Reader& reader = Reader()) { |
654 const Reader& reader = Reader()) { |
655 return _readMap< |
655 return _readMap<Reader, Map, typename SmartParameter<Map>::Type> |
656 typename Traits::template Reader<typename Map::Value>, Map, |
656 (name, map, reader); |
657 typename SmartParameter<Map>::Type>(name, map, reader); |
|
658 } |
657 } |
659 |
658 |
660 template <typename Reader, typename Map> |
659 template <typename Reader, typename Map> |
661 NodeSetReader& readNodeMap(std::string name, const Map& map, |
660 NodeSetReader& readNodeMap(std::string name, const Map& map, |
662 const Reader& reader = Reader()) { |
661 const Reader& reader = Reader()) { |
663 return _readMap< |
662 return _readMap<Reader, Map, typename SmartParameter<Map>::Type> |
664 typename Traits::template Reader<typename Map::Value>, Map, |
663 (name, map, reader); |
665 typename SmartParameter<Map>::Type>(name, map, reader); |
|
666 } |
664 } |
667 |
665 |
668 private: |
666 private: |
669 |
667 |
670 template <typename Reader, typename Map, typename MapParameter> |
668 template <typename Reader, typename Map, typename MapParameter> |
674 ErrorMessage msg; |
672 ErrorMessage msg; |
675 msg << "Multiple read rule for node map: " << name; |
673 msg << "Multiple read rule for node map: " << name; |
676 throw IOParameterError(msg.message()); |
674 throw IOParameterError(msg.message()); |
677 } |
675 } |
678 readers.insert( |
676 readers.insert( |
679 make_pair(name, new MapReader<Item, Map, Reader>(map, reader))); |
677 make_pair(name, new MapReader<Node, Map, Reader>(map, reader))); |
680 return *this; |
678 return *this; |
681 } |
679 } |
682 |
680 |
683 public: |
681 public: |
684 |
682 |
691 if (readers.find(name) != readers.end()) { |
689 if (readers.find(name) != readers.end()) { |
692 ErrorMessage msg; |
690 ErrorMessage msg; |
693 msg << "Multiple read rule for node map: " << name; |
691 msg << "Multiple read rule for node map: " << name; |
694 throw IOParameterError(msg.message()); |
692 throw IOParameterError(msg.message()); |
695 } |
693 } |
696 readers.insert(make_pair(name, new SkipReader<Item, Reader>(reader))); |
694 readers.insert(make_pair(name, new SkipReader<Node, Reader>(reader))); |
697 return *this; |
695 return *this; |
698 } |
696 } |
699 |
697 |
700 protected: |
698 protected: |
701 |
699 |
714 |
712 |
715 /// \brief Reader function of the section. |
713 /// \brief Reader function of the section. |
716 /// |
714 /// |
717 /// It reads the content of the section. |
715 /// It reads the content of the section. |
718 virtual void read(std::istream& is) { |
716 virtual void read(std::istream& is) { |
719 std::vector<ReaderBase<Item>* > index; |
717 std::vector<ReaderBase<Node>* > index; |
720 std::string line; |
718 std::string line; |
721 |
719 |
722 getline(is, line); |
720 getline(is, line); |
723 std::istringstream ls(line); |
721 std::istringstream ls(line); |
724 while (ls >> id) { |
722 while (ls >> id) { |
732 inverter.reset(index.back()->getInverter()); |
730 inverter.reset(index.back()->getInverter()); |
733 index.back() = inverter.get(); |
731 index.back() = inverter.get(); |
734 } |
732 } |
735 } |
733 } |
736 while (getline(is, line)) { |
734 while (getline(is, line)) { |
737 typename Graph::Node node = graph.addNode(); |
735 Node node = graph.addNode(); |
738 std::istringstream ls(line); |
736 std::istringstream ls(line); |
739 for (int i = 0; i < (int)index.size(); ++i) { |
737 for (int i = 0; i < (int)index.size(); ++i) { |
740 index[i]->read(ls, node); |
738 index[i]->read(ls, node); |
741 } |
739 } |
742 } |
740 } |
754 |
752 |
755 /// \brief Gives back the node by its id. |
753 /// \brief Gives back the node by its id. |
756 /// |
754 /// |
757 /// It reads an id from the stream and gives back which node belongs to |
755 /// It reads an id from the stream and gives back which node belongs to |
758 /// it. It is possible only if there was read an "id" named map. |
756 /// it. It is possible only if there was read an "id" named map. |
759 Item readId(std::istream& is) const { |
757 Node readId(std::istream& is, Node = Node()) const { |
760 return inverter->read(is); |
758 return inverter->read(is); |
761 } |
759 } |
762 |
760 |
763 private: |
761 private: |
764 |
762 |
765 typedef std::map<std::string, ReaderBase<Item>*> MapReaders; |
763 typedef std::map<std::string, ReaderBase<Node>*> MapReaders; |
766 MapReaders readers; |
764 MapReaders readers; |
767 |
765 |
768 typename SmartReference<Graph>::Type graph; |
766 typename SmartReference<Graph>::Type graph; |
769 std::string id; |
767 std::string id; |
770 SkipReader<Item, DefaultSkipper> skipper; |
768 SkipReader<Node, DefaultSkipper> skipper; |
771 |
769 |
772 std::auto_ptr<InverterBase<Item> > inverter; |
770 std::auto_ptr<InverterBase<Node> > inverter; |
773 }; |
771 }; |
774 |
772 |
775 /// \ingroup io_group |
773 /// \ingroup io_group |
776 /// \brief SectionReader for reading a graph's edgeset. |
774 /// \brief SectionReader for reading a graph's edgeset. |
777 /// |
775 /// |
799 typedef CommonSectionReaderBase Parent; |
797 typedef CommonSectionReaderBase Parent; |
800 public: |
798 public: |
801 |
799 |
802 typedef _Graph Graph; |
800 typedef _Graph Graph; |
803 typedef _Traits Traits; |
801 typedef _Traits Traits; |
804 typedef typename Graph::Edge Item; |
802 typedef typename Graph::Node Node; |
|
803 typedef typename Graph::Edge Edge; |
805 typedef typename Traits::Skipper DefaultSkipper; |
804 typedef typename Traits::Skipper DefaultSkipper; |
806 |
805 |
807 /// \brief Constructor. |
806 /// \brief Constructor. |
808 /// |
807 /// |
809 /// Constructor for EdgeSetReader. It creates the EdgeSetReader and |
808 /// Constructor for EdgeSetReader. It creates the EdgeSetReader and |
817 typename SmartParameter<Graph>::Type _graph, |
816 typename SmartParameter<Graph>::Type _graph, |
818 const NodeIdReader& _nodeIdReader, |
817 const NodeIdReader& _nodeIdReader, |
819 const std::string& _id = std::string(), |
818 const std::string& _id = std::string(), |
820 const DefaultSkipper& _skipper = DefaultSkipper()) |
819 const DefaultSkipper& _skipper = DefaultSkipper()) |
821 : Parent(_reader), graph(_graph), id(_id), skipper(_skipper), |
820 : Parent(_reader), graph(_graph), id(_id), skipper(_skipper), |
822 nodeIdReader(new IdReader<typename Graph::Node, NodeIdReader> |
821 nodeIdReader(new IdReader<Node, NodeIdReader>(_nodeIdReader)) {} |
823 (_nodeIdReader)) {} |
|
824 |
822 |
825 /// \brief Destructor. |
823 /// \brief Destructor. |
826 /// |
824 /// |
827 /// Destructor for EdgeSetReader. |
825 /// Destructor for EdgeSetReader. |
828 virtual ~EdgeSetReader() { |
826 virtual ~EdgeSetReader() { |
859 /// |
857 /// |
860 /// Add a new edge map reader command for the reader. |
858 /// Add a new edge map reader command for the reader. |
861 template <typename Reader, typename Map> |
859 template <typename Reader, typename Map> |
862 EdgeSetReader& readEdgeMap(std::string name, Map& map, |
860 EdgeSetReader& readEdgeMap(std::string name, Map& map, |
863 const Reader& reader = Reader()) { |
861 const Reader& reader = Reader()) { |
864 return _readMap< |
862 return _readMap<Reader, Map, |
865 typename Traits::template Reader<typename Map::Value>, Map, |
|
866 typename SmartParameter<Map>::Type>(name, map, reader); |
863 typename SmartParameter<Map>::Type>(name, map, reader); |
867 } |
864 } |
868 |
865 |
869 template <typename Reader, typename Map> |
866 template <typename Reader, typename Map> |
870 EdgeSetReader& readEdgeMap(std::string name, const Map& map, |
867 EdgeSetReader& readEdgeMap(std::string name, const Map& map, |
871 const Reader& reader = Reader()) { |
868 const Reader& reader = Reader()) { |
872 return _readMap< |
869 return _readMap<Reader, Map, |
873 typename Traits::template Reader<typename Map::Value>, Map, |
|
874 typename SmartParameter<Map>::Type>(name, map, reader); |
870 typename SmartParameter<Map>::Type>(name, map, reader); |
875 } |
871 } |
876 |
872 |
877 private: |
873 private: |
878 |
874 |
883 ErrorMessage msg; |
879 ErrorMessage msg; |
884 msg << "Multiple read rule for edge map: " << name; |
880 msg << "Multiple read rule for edge map: " << name; |
885 throw IOParameterError(msg.message()); |
881 throw IOParameterError(msg.message()); |
886 } |
882 } |
887 readers.insert( |
883 readers.insert( |
888 make_pair(name, new MapReader<Item, Map, Reader>(map, reader))); |
884 make_pair(name, new MapReader<Edge, Map, Reader>(map, reader))); |
889 return *this; |
885 return *this; |
890 } |
886 } |
891 |
887 |
892 public: |
888 public: |
893 |
889 |
900 if (readers.find(name) != readers.end()) { |
896 if (readers.find(name) != readers.end()) { |
901 ErrorMessage msg; |
897 ErrorMessage msg; |
902 msg << "Multiple read rule for edge map: " << name; |
898 msg << "Multiple read rule for edge map: " << name; |
903 throw IOParameterError(msg.message()); |
899 throw IOParameterError(msg.message()); |
904 } |
900 } |
905 readers.insert(make_pair(name, new SkipReader<Item, Reader>(reader))); |
901 readers.insert(make_pair(name, new SkipReader<Edge, Reader>(reader))); |
906 return *this; |
902 return *this; |
907 } |
903 } |
908 |
904 |
909 protected: |
905 protected: |
910 |
906 |
923 |
919 |
924 /// \brief Reader function of the section. |
920 /// \brief Reader function of the section. |
925 /// |
921 /// |
926 /// It reads the content of the section. |
922 /// It reads the content of the section. |
927 virtual void read(std::istream& is) { |
923 virtual void read(std::istream& is) { |
928 std::vector<ReaderBase<Item>* > index; |
924 std::vector<ReaderBase<Edge>* > index; |
929 std::string line; |
925 std::string line; |
930 |
926 |
931 getline(is, line); |
927 getline(is, line); |
932 std::istringstream ls(line); |
928 std::istringstream ls(line); |
933 while (ls >> id) { |
929 while (ls >> id) { |
942 index.back() = inverter.get(); |
938 index.back() = inverter.get(); |
943 } |
939 } |
944 } |
940 } |
945 while (getline(is, line)) { |
941 while (getline(is, line)) { |
946 std::istringstream ls(line); |
942 std::istringstream ls(line); |
947 typename Graph::Node from = nodeIdReader->read(ls); |
943 Node from = nodeIdReader->read(ls); |
948 typename Graph::Node to = nodeIdReader->read(ls); |
944 Node to = nodeIdReader->read(ls); |
949 typename Graph::Edge edge = graph.addEdge(from, to); |
945 Edge edge = graph.addEdge(from, to); |
950 for (int i = 0; i < (int)index.size(); ++i) { |
946 for (int i = 0; i < (int)index.size(); ++i) { |
951 index[i]->read(ls, edge); |
947 index[i]->read(ls, edge); |
952 } |
948 } |
953 } |
949 } |
954 } |
950 } |
965 |
961 |
966 /// \brief Gives back the edge by its id. |
962 /// \brief Gives back the edge by its id. |
967 /// |
963 /// |
968 /// It reads an id from the stream and gives back which edge belongs to |
964 /// It reads an id from the stream and gives back which edge belongs to |
969 /// it. It is possible only if there was read an "id" named map. |
965 /// it. It is possible only if there was read an "id" named map. |
970 Item readId(std::istream& is) const { |
966 Edge readId(std::istream& is, Edge = Edge()) const { |
971 return inverter->read(is); |
967 return inverter->read(is); |
972 } |
968 } |
973 |
969 |
974 private: |
970 private: |
975 |
971 |
976 typedef std::map<std::string, ReaderBase<Item>*> MapReaders; |
972 typedef std::map<std::string, ReaderBase<Edge>*> MapReaders; |
977 MapReaders readers; |
973 MapReaders readers; |
978 |
974 |
979 typename SmartReference<Graph>::Type graph; |
975 typename SmartReference<Graph>::Type graph; |
980 std::string id; |
976 std::string id; |
981 SkipReader<Item, DefaultSkipper> skipper; |
977 SkipReader<Edge, DefaultSkipper> skipper; |
982 |
978 |
983 std::auto_ptr<InverterBase<Item> > inverter; |
979 std::auto_ptr<InverterBase<Edge> > inverter; |
984 std::auto_ptr<IdReaderBase<typename Graph::Node> > nodeIdReader; |
980 std::auto_ptr<IdReaderBase<Node> > nodeIdReader; |
985 }; |
981 }; |
986 |
982 |
987 /// \ingroup io_group |
983 /// \ingroup io_group |
988 /// \brief SectionReader for reading a undirected graph's edgeset. |
984 /// \brief SectionReader for reading a undirected graph's edgeset. |
989 /// |
985 /// |
1016 typedef CommonSectionReaderBase Parent; |
1012 typedef CommonSectionReaderBase Parent; |
1017 public: |
1013 public: |
1018 |
1014 |
1019 typedef _Graph Graph; |
1015 typedef _Graph Graph; |
1020 typedef _Traits Traits; |
1016 typedef _Traits Traits; |
1021 typedef typename Graph::UndirEdge Item; |
1017 typedef typename Graph::Node Node; |
|
1018 typedef typename Graph::Edge Edge; |
|
1019 typedef typename Graph::UndirEdge UndirEdge; |
1022 typedef typename Traits::Skipper DefaultSkipper; |
1020 typedef typename Traits::Skipper DefaultSkipper; |
1023 |
1021 |
1024 /// \brief Constructor. |
1022 /// \brief Constructor. |
1025 /// |
1023 /// |
1026 /// Constructor for UndirEdgeSetReader. It creates the UndirEdgeSetReader |
1024 /// Constructor for UndirEdgeSetReader. It creates the UndirEdgeSetReader |
1034 typename SmartParameter<Graph>::Type _graph, |
1032 typename SmartParameter<Graph>::Type _graph, |
1035 const NodeIdReader& _nodeIdReader, |
1033 const NodeIdReader& _nodeIdReader, |
1036 const std::string& _id = std::string(), |
1034 const std::string& _id = std::string(), |
1037 const DefaultSkipper& _skipper = DefaultSkipper()) |
1035 const DefaultSkipper& _skipper = DefaultSkipper()) |
1038 : Parent(_reader), graph(_graph), id(_id), skipper(_skipper), |
1036 : Parent(_reader), graph(_graph), id(_id), skipper(_skipper), |
1039 nodeIdReader(new IdReader<typename Graph::Node, NodeIdReader> |
1037 nodeIdReader(new IdReader<Node, NodeIdReader>(_nodeIdReader)) {} |
1040 (_nodeIdReader)) {} |
|
1041 |
1038 |
1042 /// \brief Destructor. |
1039 /// \brief Destructor. |
1043 /// |
1040 /// |
1044 /// Destructor for UndirEdgeSetReader. |
1041 /// Destructor for UndirEdgeSetReader. |
1045 virtual ~UndirEdgeSetReader() { |
1042 virtual ~UndirEdgeSetReader() { |
1115 if (readers.find(name) != readers.end()) { |
1112 if (readers.find(name) != readers.end()) { |
1116 ErrorMessage msg; |
1113 ErrorMessage msg; |
1117 msg << "Multiple read rule for node map: " << name; |
1114 msg << "Multiple read rule for node map: " << name; |
1118 throw IOParameterError(msg.message()); |
1115 throw IOParameterError(msg.message()); |
1119 } |
1116 } |
1120 readers.insert(make_pair(name, new SkipReader<Item, Reader>(reader))); |
1117 readers.insert(make_pair(name, |
|
1118 new SkipReader<UndirEdge, Reader>(reader))); |
1121 return *this; |
1119 return *this; |
1122 } |
1120 } |
1123 |
1121 |
1124 /// \brief Add a new directed edge map reader command for the reader. |
1122 /// \brief Add a new directed edge map reader command for the reader. |
1125 /// |
1123 /// |
1197 |
1195 |
1198 /// \brief Reader function of the section. |
1196 /// \brief Reader function of the section. |
1199 /// |
1197 /// |
1200 /// It reads the content of the section. |
1198 /// It reads the content of the section. |
1201 virtual void read(std::istream& is) { |
1199 virtual void read(std::istream& is) { |
1202 std::vector<ReaderBase<Item>* > index; |
1200 std::vector<ReaderBase<UndirEdge>* > index; |
1203 std::string line; |
1201 std::string line; |
1204 |
1202 |
1205 getline(is, line); |
1203 getline(is, line); |
1206 std::istringstream ls(line); |
1204 std::istringstream ls(line); |
1207 while (ls >> id) { |
1205 while (ls >> id) { |
1216 index.back() = inverter.get(); |
1214 index.back() = inverter.get(); |
1217 } |
1215 } |
1218 } |
1216 } |
1219 while (getline(is, line)) { |
1217 while (getline(is, line)) { |
1220 std::istringstream ls(line); |
1218 std::istringstream ls(line); |
1221 typename Graph::Node from = nodeIdReader->read(ls); |
1219 Node from = nodeIdReader->read(ls); |
1222 typename Graph::Node to = nodeIdReader->read(ls); |
1220 Node to = nodeIdReader->read(ls); |
1223 typename Graph::UndirEdge edge = graph.addEdge(from, to); |
1221 UndirEdge edge = graph.addEdge(from, to); |
1224 for (int i = 0; i < (int)index.size(); ++i) { |
1222 for (int i = 0; i < (int)index.size(); ++i) { |
1225 index[i]->read(ls, edge); |
1223 index[i]->read(ls, edge); |
1226 } |
1224 } |
1227 } |
1225 } |
1228 } |
1226 } |
1239 |
1237 |
1240 /// \brief Gives back the undirected edge by its id. |
1238 /// \brief Gives back the undirected edge by its id. |
1241 /// |
1239 /// |
1242 /// It reads an id from the stream and gives back which undirected edge |
1240 /// It reads an id from the stream and gives back which undirected edge |
1243 /// belongs to it. It is possible only if there was read an "id" named map. |
1241 /// belongs to it. It is possible only if there was read an "id" named map. |
1244 Item readId(std::istream& is) const { |
1242 UndirEdge readId(std::istream& is, UndirEdge = UndirEdge()) const { |
1245 return inverter->read(is); |
1243 return inverter->read(is); |
1246 } |
1244 } |
1247 |
1245 |
1248 private: |
1246 /// \brief Gives back the directed edge by its id. |
1249 |
1247 /// |
1250 typedef std::map<std::string, ReaderBase<Item>*> MapReaders; |
1248 /// It reads an id from the stream and gives back which directed edge |
|
1249 /// belongs to it. The directed edge id is the \c '+' or \c '-' character |
|
1250 /// and the undirected edge id. It is possible only if there was read |
|
1251 /// an "id" named map. |
|
1252 Edge readId(std::istream& is, Edge = Edge()) const { |
|
1253 char c; |
|
1254 is >> c; |
|
1255 UndirEdge undirEdge = inverter->read(is); |
|
1256 if (c == '+') { |
|
1257 return graph.edgeWithSource(undirEdge, graph.source(undirEdge)); |
|
1258 } else if (c == '-') { |
|
1259 return graph.edgeWithSource(undirEdge, graph.target(undirEdge)); |
|
1260 } else { |
|
1261 throw DataFormatError("Wrong id format for edge " |
|
1262 "in undirected edgeset"); |
|
1263 } |
|
1264 } |
|
1265 |
|
1266 private: |
|
1267 |
|
1268 typedef std::map<std::string, ReaderBase<UndirEdge>*> MapReaders; |
1251 MapReaders readers; |
1269 MapReaders readers; |
1252 |
1270 |
1253 typename SmartReference<Graph>::Type graph; |
1271 typename SmartReference<Graph>::Type graph; |
1254 std::string id; |
1272 std::string id; |
1255 SkipReader<Item, DefaultSkipper> skipper; |
1273 SkipReader<UndirEdge, DefaultSkipper> skipper; |
1256 |
1274 |
1257 std::auto_ptr<InverterBase<Item> > inverter; |
1275 std::auto_ptr<InverterBase<UndirEdge> > inverter; |
1258 std::auto_ptr<IdReaderBase<typename Graph::Node> > nodeIdReader; |
1276 std::auto_ptr<IdReaderBase<Node> > nodeIdReader; |
1259 }; |
1277 }; |
1260 |
1278 |
1261 /// \ingroup io_group |
1279 /// \ingroup io_group |
1262 /// \brief SectionReader for reading labeled nodes. |
1280 /// \brief SectionReader for reading labeled nodes. |
1263 /// |
1281 /// |
1270 /// \relates LemonReader |
1288 /// \relates LemonReader |
1271 template <typename _Graph> |
1289 template <typename _Graph> |
1272 class NodeReader : public CommonSectionReaderBase { |
1290 class NodeReader : public CommonSectionReaderBase { |
1273 typedef CommonSectionReaderBase Parent; |
1291 typedef CommonSectionReaderBase Parent; |
1274 typedef _Graph Graph; |
1292 typedef _Graph Graph; |
1275 typedef typename Graph::Node Item; |
1293 typedef typename Graph::Node Node; |
1276 public: |
1294 public: |
1277 |
1295 |
1278 /// \brief Constructor. |
1296 /// \brief Constructor. |
1279 /// |
1297 /// |
1280 /// Constructor for NodeReader. It creates the NodeReader and |
1298 /// Constructor for NodeReader. It creates the NodeReader and |
1299 public: |
1317 public: |
1300 |
1318 |
1301 /// \brief Add a node reader command for the NodeReader. |
1319 /// \brief Add a node reader command for the NodeReader. |
1302 /// |
1320 /// |
1303 /// Add a node reader command for the NodeReader. |
1321 /// Add a node reader command for the NodeReader. |
1304 void readNode(const std::string& name, Item& item) { |
1322 void readNode(const std::string& name, Node& item) { |
1305 if (readers.find(name) != readers.end()) { |
1323 if (readers.find(name) != readers.end()) { |
1306 ErrorMessage msg; |
1324 ErrorMessage msg; |
1307 msg << "Multiple read rule for node: " << name; |
1325 msg << "Multiple read rule for node: " << name; |
1308 throw IOParameterError(msg.message()); |
1326 throw IOParameterError(msg.message()); |
1309 } |
1327 } |
1332 std::string line; |
1350 std::string line; |
1333 while (getline(is, line)) { |
1351 while (getline(is, line)) { |
1334 std::istringstream ls(line); |
1352 std::istringstream ls(line); |
1335 std::string id; |
1353 std::string id; |
1336 ls >> id; |
1354 ls >> id; |
1337 typename ItemReaders::iterator it = readers.find(id); |
1355 typename NodeReaders::iterator it = readers.find(id); |
1338 if (it != readers.end()) { |
1356 if (it != readers.end()) { |
1339 *(it->second) = idReader->read(ls); |
1357 *(it->second) = idReader->read(ls); |
1340 } |
1358 } |
1341 } |
1359 } |
1342 } |
1360 } |
1343 |
1361 |
1344 private: |
1362 private: |
1345 |
1363 |
1346 std::string id; |
1364 std::string id; |
1347 |
1365 |
1348 typedef std::map<std::string, Item*> ItemReaders; |
1366 typedef std::map<std::string, Node*> NodeReaders; |
1349 ItemReaders readers; |
1367 NodeReaders readers; |
1350 std::auto_ptr<IdReaderBase<Item> > idReader; |
1368 std::auto_ptr<IdReaderBase<Node> > idReader; |
1351 }; |
1369 }; |
1352 |
1370 |
1353 /// \ingroup io_group |
1371 /// \ingroup io_group |
1354 /// \brief SectionReader for reading labeled edges. |
1372 /// \brief SectionReader for reading labeled edges. |
1355 /// |
1373 /// |
1362 /// \relates LemonReader |
1380 /// \relates LemonReader |
1363 template <typename _Graph> |
1381 template <typename _Graph> |
1364 class EdgeReader : public CommonSectionReaderBase { |
1382 class EdgeReader : public CommonSectionReaderBase { |
1365 typedef CommonSectionReaderBase Parent; |
1383 typedef CommonSectionReaderBase Parent; |
1366 typedef _Graph Graph; |
1384 typedef _Graph Graph; |
1367 typedef typename Graph::Edge Item; |
1385 typedef typename Graph::Edge Edge; |
1368 public: |
1386 public: |
1369 |
1387 |
1370 /// \brief Constructor. |
1388 /// \brief Constructor. |
1371 /// |
1389 /// |
1372 /// Constructor for EdgeReader. It creates the EdgeReader and |
1390 /// Constructor for EdgeReader. It creates the EdgeReader and |
1390 public: |
1408 public: |
1391 |
1409 |
1392 /// \brief Add an edge reader command for the EdgeReader. |
1410 /// \brief Add an edge reader command for the EdgeReader. |
1393 /// |
1411 /// |
1394 /// Add an edge reader command for the EdgeReader. |
1412 /// Add an edge reader command for the EdgeReader. |
1395 void readEdge(const std::string& name, Item& item) { |
1413 void readEdge(const std::string& name, Edge& item) { |
1396 if (readers.find(name) != readers.end()) { |
1414 if (readers.find(name) != readers.end()) { |
1397 ErrorMessage msg; |
1415 ErrorMessage msg; |
1398 msg << "Multiple read rule for edge: " << name; |
1416 msg << "Multiple read rule for edge: " << name; |
1399 throw IOParameterError(msg.message()); |
1417 throw IOParameterError(msg.message()); |
1400 } |
1418 } |
1423 std::string line; |
1441 std::string line; |
1424 while (getline(is, line)) { |
1442 while (getline(is, line)) { |
1425 std::istringstream ls(line); |
1443 std::istringstream ls(line); |
1426 std::string id; |
1444 std::string id; |
1427 ls >> id; |
1445 ls >> id; |
1428 typename ItemReaders::iterator it = readers.find(id); |
1446 typename EdgeReaders::iterator it = readers.find(id); |
1429 if (it != readers.end()) { |
1447 if (it != readers.end()) { |
1430 *(it->second) = idReader->read(ls); |
1448 *(it->second) = idReader->read(ls); |
1431 } |
1449 } |
1432 } |
1450 } |
1433 } |
1451 } |
1434 |
1452 |
1435 private: |
1453 private: |
1436 |
1454 |
1437 std::string id; |
1455 std::string id; |
1438 |
1456 |
1439 typedef std::map<std::string, Item*> ItemReaders; |
1457 typedef std::map<std::string, Edge*> EdgeReaders; |
1440 ItemReaders readers; |
1458 EdgeReaders readers; |
1441 std::auto_ptr<IdReaderBase<Item> > idReader; |
1459 std::auto_ptr<IdReaderBase<Edge> > idReader; |
1442 }; |
1460 }; |
1443 |
1461 |
1444 /// \ingroup io_group |
1462 /// \ingroup io_group |
1445 /// \brief SectionReader for reading labeled undirected edges. |
1463 /// \brief SectionReader for reading labeled undirected edges. |
1446 /// |
1464 /// |
1453 /// \relates LemonReader |
1471 /// \relates LemonReader |
1454 template <typename _Graph> |
1472 template <typename _Graph> |
1455 class UndirEdgeReader : public CommonSectionReaderBase { |
1473 class UndirEdgeReader : public CommonSectionReaderBase { |
1456 typedef CommonSectionReaderBase Parent; |
1474 typedef CommonSectionReaderBase Parent; |
1457 typedef _Graph Graph; |
1475 typedef _Graph Graph; |
1458 typedef typename Graph::UndirEdge Item; |
1476 typedef typename Graph::Edge Edge; |
|
1477 typedef typename Graph::UndirEdge UndirEdge; |
1459 public: |
1478 public: |
1460 |
1479 |
1461 /// \brief Constructor. |
1480 /// \brief Constructor. |
1462 /// |
1481 /// |
1463 /// Constructor for UndirEdgeReader. It creates the UndirEdgeReader and |
1482 /// Constructor for UndirEdgeReader. It creates the UndirEdgeReader and |
1467 /// the same. |
1486 /// the same. |
1468 template <typename _IdReader> |
1487 template <typename _IdReader> |
1469 UndirEdgeReader(LemonReader& _reader, const _IdReader& _idReader, |
1488 UndirEdgeReader(LemonReader& _reader, const _IdReader& _idReader, |
1470 const std::string& _id = std::string()) |
1489 const std::string& _id = std::string()) |
1471 : Parent(_reader), id(_id), |
1490 : Parent(_reader), id(_id), |
1472 idReader(new IdReader<typename Graph::UndirEdge, _IdReader>(_idReader)) |
1491 undirEdgeIdReader(new IdReader<UndirEdge, _IdReader>(_idReader)), |
|
1492 edgeIdReader(new IdReader<Edge, _IdReader>(_idReader)) |
1473 {} |
1493 {} |
1474 |
1494 |
1475 /// \brief Destructor. |
1495 /// \brief Destructor. |
1476 /// |
1496 /// |
1477 /// Destructor for UndirEdgeReader. |
1497 /// Destructor for UndirEdgeReader. |
1483 public: |
1503 public: |
1484 |
1504 |
1485 /// \brief Add an undirected edge reader command for the UndirEdgeReader. |
1505 /// \brief Add an undirected edge reader command for the UndirEdgeReader. |
1486 /// |
1506 /// |
1487 /// Add an undirected edge reader command for the UndirEdgeReader. |
1507 /// Add an undirected edge reader command for the UndirEdgeReader. |
1488 void readUndirEdge(const std::string& name, Item& item) { |
1508 void readUndirEdge(const std::string& name, UndirEdge& item) { |
1489 if (readers.find(name) != readers.end()) { |
1509 if (undirEdgeReaders.find(name) != undirEdgeReaders.end()) { |
|
1510 ErrorMessage msg; |
|
1511 msg << "Multiple read rule for undirected edge: " << name; |
|
1512 throw IOParameterError(msg.message()); |
|
1513 } |
|
1514 undirEdgeReaders.insert(make_pair(name, &item)); |
|
1515 } |
|
1516 |
|
1517 /// \brief Add an edge reader command for the UndirEdgeReader. |
|
1518 /// |
|
1519 /// Add an edge reader command for the UndirEdgeReader. |
|
1520 void readEdge(const std::string& name, Edge& item) { |
|
1521 if (edgeReaders.find(name) != edgeReaders.end()) { |
1490 ErrorMessage msg; |
1522 ErrorMessage msg; |
1491 msg << "Multiple read rule for edge: " << name; |
1523 msg << "Multiple read rule for edge: " << name; |
1492 throw IOParameterError(msg.message()); |
1524 throw IOParameterError(msg.message()); |
1493 } |
1525 } |
1494 readers.insert(make_pair(name, &item)); |
1526 edgeReaders.insert(make_pair(name, &item)); |
1495 } |
1527 } |
1496 |
1528 |
1497 protected: |
1529 protected: |
1498 |
1530 |
1499 /// \brief Gives back true when the SectionReader can process |
1531 /// \brief Gives back true when the SectionReader can process |
1504 virtual bool header(const std::string& line) { |
1536 virtual bool header(const std::string& line) { |
1505 std::istringstream ls(line); |
1537 std::istringstream ls(line); |
1506 std::string command; |
1538 std::string command; |
1507 std::string name; |
1539 std::string name; |
1508 ls >> command >> name; |
1540 ls >> command >> name; |
1509 return command == "@edges" && name == id; |
1541 return command == "@undiredges" && name == id; |
1510 } |
1542 } |
1511 |
1543 |
1512 /// \brief Reader function of the section. |
1544 /// \brief Reader function of the section. |
1513 /// |
1545 /// |
1514 /// It reads the content of the section. |
1546 /// It reads the content of the section. |
1516 std::string line; |
1548 std::string line; |
1517 while (getline(is, line)) { |
1549 while (getline(is, line)) { |
1518 std::istringstream ls(line); |
1550 std::istringstream ls(line); |
1519 std::string id; |
1551 std::string id; |
1520 ls >> id; |
1552 ls >> id; |
1521 typename ItemReaders::iterator it = readers.find(id); |
1553 { |
1522 if (it != readers.end()) { |
1554 typename UndirEdgeReaders::iterator it = undirEdgeReaders.find(id); |
1523 *(it->second) = idReader->read(ls); |
1555 if (it != undirEdgeReaders.end()) { |
1524 } |
1556 *(it->second) = undirEdgeIdReader->read(ls); |
|
1557 break; |
|
1558 } |
|
1559 } { |
|
1560 typename EdgeReaders::iterator it = edgeReaders.find(id); |
|
1561 if (it != edgeReaders.end()) { |
|
1562 *(it->second) = edgeIdReader->read(ls); |
|
1563 break; |
|
1564 } |
|
1565 } |
1525 } |
1566 } |
1526 } |
1567 } |
1527 |
1568 |
1528 private: |
1569 private: |
1529 |
1570 |
1530 std::string id; |
1571 std::string id; |
1531 |
1572 |
1532 typedef std::map<std::string, Item*> ItemReaders; |
1573 typedef std::map<std::string, UndirEdge*> UndirEdgeReaders; |
1533 ItemReaders readers; |
1574 UndirEdgeReaders undirEdgeReaders; |
1534 std::auto_ptr<IdReaderBase<Item> > idReader; |
1575 std::auto_ptr<IdReaderBase<UndirEdge> > undirEdgeIdReader; |
|
1576 |
|
1577 typedef std::map<std::string, Edge*> EdgeReaders; |
|
1578 EdgeReaders edgeReaders; |
|
1579 std::auto_ptr<IdReaderBase<Edge> > edgeIdReader; |
1535 }; |
1580 }; |
1536 |
1581 |
1537 /// \ingroup io_group |
1582 /// \ingroup io_group |
1538 /// \brief SectionReader for attributes. |
1583 /// \brief SectionReader for attributes. |
1539 /// |
1584 /// |