Changeset 1909:2d806130e700 in lemon-0.x for lemon/lemon_reader.h
- Timestamp:
- 01/26/06 16:42:13 (18 years ago)
- Branch:
- default
- Phase:
- public
- Convert:
- svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2484
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
lemon/lemon_reader.h
r1901 r1909 105 105 class ForwardComposeMap { 106 106 public: 107 typedef typename Graph::U ndirEdge Key;107 typedef typename Graph::UEdge Key; 108 108 typedef typename Map::Value Value; 109 109 … … 135 135 class BackwardComposeMap { 136 136 public: 137 typedef typename Graph::U ndirEdge Key;137 typedef typename Graph::UEdge Key; 138 138 typedef typename Map::Value Value; 139 139 … … 1168 1168 /// 1169 1169 /// The lemon format can store multiple undirected edgesets with several 1170 /// maps. The undirected edgeset section's header line is \c \@u ndiredgeset1171 /// \c u ndiredgeset_name, but the \c undiredgeset_name may be empty.1170 /// maps. The undirected edgeset section's header line is \c \@uedgeset 1171 /// \c uedgeset_name, but the \c uedgeset_name may be empty. 1172 1172 /// 1173 1173 /// The first line of the section contains the names of the maps separated … … 1184 1184 /// as id map. This map should contain only unique values and when the 1185 1185 /// \c readLabel() member will read a value from the given stream it will 1186 /// give back that u ndiricted edge which is mapped to this value.1186 /// give back that uicted edge which is mapped to this value. 1187 1187 /// 1188 1188 /// The undirected edgeset reader needs a node id reader to identify which … … 1192 1192 /// \relates LemonReader 1193 1193 template <typename _Graph, typename _Traits = DefaultReaderTraits> 1194 class U ndirEdgeSetReader : public LemonReader::SectionReader {1194 class UEdgeSetReader : public LemonReader::SectionReader { 1195 1195 typedef LemonReader::SectionReader Parent; 1196 1196 public: … … 1200 1200 typedef typename Graph::Node Node; 1201 1201 typedef typename Graph::Edge Edge; 1202 typedef typename Graph::U ndirEdge UndirEdge;1202 typedef typename Graph::UEdge UEdge; 1203 1203 typedef typename Traits::Skipper DefaultSkipper; 1204 1204 1205 1205 /// \brief Constructor. 1206 1206 /// 1207 /// Constructor for U ndirEdgeSetReader. It creates the UndirEdgeSetReader1207 /// Constructor for UEdgeSetReader. It creates the UEdgeSetReader 1208 1208 /// and attach it into the given LemonReader. The undirected edgeset 1209 1209 /// reader will add the readed undirected edges to the given Graph. It 1210 1210 /// will use the given node id reader to read the source and target 1211 1211 /// nodes of the edges. The reader will read the section only if the 1212 /// \c _name and the \c u ndiredgset_name are the same.1212 /// \c _name and the \c uedgset_name are the same. 1213 1213 template <typename NodeLabelReader> 1214 U ndirEdgeSetReader(LemonReader& _reader,1214 UEdgeSetReader(LemonReader& _reader, 1215 1215 Graph& _graph, 1216 1216 const NodeLabelReader& _nodeLabelReader, … … 1224 1224 /// \brief Destructor. 1225 1225 /// 1226 /// Destructor for U ndirEdgeSetReader.1227 virtual ~U ndirEdgeSetReader() {1226 /// Destructor for UEdgeSetReader. 1227 virtual ~UEdgeSetReader() { 1228 1228 for (typename MapReaders::iterator it = readers.begin(); 1229 1229 it != readers.end(); ++it) { … … 1233 1233 1234 1234 private: 1235 U ndirEdgeSetReader(const UndirEdgeSetReader&);1236 void operator=(const U ndirEdgeSetReader&);1235 UEdgeSetReader(const UEdgeSetReader&); 1236 void operator=(const UEdgeSetReader&); 1237 1237 1238 1238 public: … … 1242 1242 /// Add a new edge undirected map reader command for the reader. 1243 1243 template <typename Map> 1244 U ndirEdgeSetReader& readUndirEdgeMap(std::string name, Map& map) {1244 UEdgeSetReader& readUEdgeMap(std::string name, Map& map) { 1245 1245 return _readMap< 1246 1246 typename Traits::template Reader<typename Map::Value>, Map, … … 1249 1249 1250 1250 template <typename Map> 1251 U ndirEdgeSetReader& readUndirEdgeMap(std::string name, const Map& map) {1251 UEdgeSetReader& readUEdgeMap(std::string name, const Map& map) { 1252 1252 return _readMap< 1253 1253 typename Traits::template Reader<typename Map::Value>, Map, … … 1259 1259 /// Add a new edge undirected map reader command for the reader. 1260 1260 template <typename Reader, typename Map> 1261 U ndirEdgeSetReader& readUndirEdgeMap(std::string name, Map& map,1261 UEdgeSetReader& readUEdgeMap(std::string name, Map& map, 1262 1262 const Reader& reader = Reader()) { 1263 1263 return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type> … … 1266 1266 1267 1267 template <typename Reader, typename Map> 1268 U ndirEdgeSetReader& readUndirEdgeMap(std::string name, const Map& map,1268 UEdgeSetReader& readUEdgeMap(std::string name, const Map& map, 1269 1269 const Reader& reader = Reader()) { 1270 1270 return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type > … … 1275 1275 1276 1276 template <typename Reader, typename Map, typename MapParameter> 1277 U ndirEdgeSetReader& _readMap(std::string name, MapParameter map,1277 UEdgeSetReader& _readMap(std::string name, MapParameter map, 1278 1278 const Reader& reader = Reader()) { 1279 checkConcept<concept::WriteMap<U ndirEdge, typename Map::Value>, Map>();1279 checkConcept<concept::WriteMap<UEdge, typename Map::Value>, Map>(); 1280 1280 checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>(); 1281 1281 if (readers.find(name) != readers.end()) { … … 1286 1286 readers.insert( 1287 1287 make_pair(name, new _reader_bits:: 1288 MapReader<U ndirEdge, Map, Reader>(map, reader)));1288 MapReader<UEdge, Map, Reader>(map, reader))); 1289 1289 return *this; 1290 1290 } … … 1296 1296 /// Add a new undirected edge map skipper command for the reader. 1297 1297 template <typename Reader> 1298 U ndirEdgeSetReader& skipUndirEdgeMap(std::string name,1298 UEdgeSetReader& skipUEdgeMap(std::string name, 1299 1299 const Reader& reader = Reader()) { 1300 1300 if (readers.find(name) != readers.end()) { … … 1304 1304 } 1305 1305 readers.insert(make_pair(name, new _reader_bits:: 1306 SkipReader<U ndirEdge, Reader>(reader)));1306 SkipReader<UEdge, Reader>(reader))); 1307 1307 return *this; 1308 1308 } … … 1312 1312 /// Add a new directed edge map reader command for the reader. 1313 1313 template <typename Map> 1314 U ndirEdgeSetReader& readEdgeMap(std::string name, Map& map) {1314 UEdgeSetReader& readEdgeMap(std::string name, Map& map) { 1315 1315 return _readDirMap< 1316 1316 typename Traits::template Reader<typename Map::Value>, Map, … … 1319 1319 1320 1320 template <typename Map> 1321 U ndirEdgeSetReader& readEdgeMap(std::string name, const Map& map) {1321 UEdgeSetReader& readEdgeMap(std::string name, const Map& map) { 1322 1322 return _readDirMap< 1323 1323 typename Traits::template Reader<typename Map::Value>, Map, … … 1329 1329 /// Add a new directed edge map reader command for the reader. 1330 1330 template <typename Reader, typename Map> 1331 U ndirEdgeSetReader& readEdgeMap(std::string name, Map& map,1331 UEdgeSetReader& readEdgeMap(std::string name, Map& map, 1332 1332 const Reader& reader = Reader()) { 1333 1333 return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type> … … 1336 1336 1337 1337 template <typename Reader, typename Map> 1338 U ndirEdgeSetReader& readEdgeMap(std::string name, const Map& map,1338 UEdgeSetReader& readEdgeMap(std::string name, const Map& map, 1339 1339 const Reader& reader = Reader()) { 1340 1340 return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type> … … 1345 1345 1346 1346 template <typename Reader, typename Map, typename MapParameter> 1347 U ndirEdgeSetReader& _readDirMap(std::string name, MapParameter map,1347 UEdgeSetReader& _readDirMap(std::string name, MapParameter map, 1348 1348 const Reader& reader = Reader()) { 1349 1349 checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>(); … … 1362 1362 /// Add a new directed edge map skipper command for the reader. 1363 1363 template <typename Reader> 1364 U ndirEdgeSetReader& skipEdgeMap(std::string name,1364 UEdgeSetReader& skipEdgeMap(std::string name, 1365 1365 const Reader& reader = Reader()) { 1366 1366 skipMap("+" + name, reader); … … 1374 1374 /// the section with the given header line. 1375 1375 /// 1376 /// It gives back true when the header line starts with \c \@u ndiredgeset,1376 /// It gives back true when the header line starts with \c \@uedgeset, 1377 1377 /// and the header line's name and the edgeset's name are the same. 1378 1378 virtual bool header(const std::string& line) { … … 1381 1381 std::string id; 1382 1382 ls >> command >> name; 1383 return command == "@u ndiredgeset" && name == id;1383 return command == "@uedgeset" && name == id; 1384 1384 } 1385 1385 … … 1391 1391 throw DataFormatError("Cannot find nodeset or label map"); 1392 1392 } 1393 std::vector<_reader_bits::MapReaderBase<U ndirEdge>* > index;1393 std::vector<_reader_bits::MapReaderBase<UEdge>* > index; 1394 1394 std::string line; 1395 1395 … … 1422 1422 Node from = nodeLabelReader->read(ls); 1423 1423 Node to = nodeLabelReader->read(ls); 1424 U ndirEdge edge = graph.addEdge(from, to);1424 UEdge edge = graph.addEdge(from, to); 1425 1425 for (int i = 0; i < (int)index.size(); ++i) { 1426 1426 index[i]->read(ls, edge); … … 1443 1443 /// It reads an id from the stream and gives back which undirected edge 1444 1444 /// belongs to it. It is possible only if there was read an "label" named map. 1445 void readLabel(std::istream& is, U ndirEdge& undirEdge) const {1446 u ndirEdge = inverter->read(is);1445 void readLabel(std::istream& is, UEdge& uEdge) const { 1446 uEdge = inverter->read(is); 1447 1447 } 1448 1448 … … 1456 1456 char c; 1457 1457 is >> c; 1458 U ndirEdge undirEdge = inverter->read(is);1458 UEdge uEdge = inverter->read(is); 1459 1459 if (c == '+') { 1460 edge = graph.direct(u ndirEdge, true);1460 edge = graph.direct(uEdge, true); 1461 1461 } else if (c == '-') { 1462 edge = graph.direct(u ndirEdge, false);1462 edge = graph.direct(uEdge, false); 1463 1463 } else { 1464 1464 throw DataFormatError("Wrong id format for edge " … … 1470 1470 1471 1471 typedef std::map<std::string, 1472 _reader_bits::MapReaderBase<U ndirEdge>*> MapReaders;1472 _reader_bits::MapReaderBase<UEdge>*> MapReaders; 1473 1473 MapReaders readers; 1474 1474 1475 1475 Graph& graph; 1476 1476 std::string name; 1477 _reader_bits::SkipReader<U ndirEdge, DefaultSkipper> skipper;1478 1479 std::auto_ptr<_reader_bits::MapInverterBase<U ndirEdge> > inverter;1477 _reader_bits::SkipReader<UEdge, DefaultSkipper> skipper; 1478 1479 std::auto_ptr<_reader_bits::MapInverterBase<UEdge> > inverter; 1480 1480 std::auto_ptr<_reader_bits::LabelReaderBase<Node> > nodeLabelReader; 1481 1481 }; … … 1697 1697 /// \brief SectionReader for reading labeled undirected edges. 1698 1698 /// 1699 /// The undirected edges section's header line is \c \@u ndiredges1700 /// \c u ndiredges_name, but the \c undiredges_name may be empty.1699 /// The undirected edges section's header line is \c \@uedges 1700 /// \c uedges_name, but the \c uedges_name may be empty. 1701 1701 /// 1702 1702 /// Each line in the section contains the name of the undirected edge … … 1705 1705 /// \relates LemonReader 1706 1706 template <typename _Graph> 1707 class U ndirEdgeReader : public LemonReader::SectionReader {1707 class UEdgeReader : public LemonReader::SectionReader { 1708 1708 typedef LemonReader::SectionReader Parent; 1709 1709 typedef _Graph Graph; 1710 1710 typedef typename Graph::Edge Edge; 1711 typedef typename Graph::U ndirEdge UndirEdge;1711 typedef typename Graph::UEdge UEdge; 1712 1712 public: 1713 1713 1714 1714 /// \brief Constructor. 1715 1715 /// 1716 /// Constructor for U ndirEdgeReader. It creates the UndirEdgeReader and1716 /// Constructor for UEdgeReader. It creates the UEdgeReader and 1717 1717 /// attach it into the given LemonReader. It will use the given 1718 1718 /// undirected edge id reader to give back the edges. The reader will 1719 /// read the section only if the \c _name and the \c u ndiredges_name are1719 /// read the section only if the \c _name and the \c uedges_name are 1720 1720 /// the same. 1721 1721 template <typename _LabelReader> 1722 U ndirEdgeReader(LemonReader& _reader, const _LabelReader& _labelReader,1722 UEdgeReader(LemonReader& _reader, const _LabelReader& _labelReader, 1723 1723 const std::string& _name = std::string()) 1724 1724 : Parent(_reader), name(_name) { 1725 checkConcept<_reader_bits::ItemLabelReader<U ndirEdge>, _LabelReader>();1725 checkConcept<_reader_bits::ItemLabelReader<UEdge>, _LabelReader>(); 1726 1726 checkConcept<_reader_bits::ItemLabelReader<Edge>, _LabelReader>(); 1727 u ndirEdgeLabelReader.reset(new _reader_bits::1728 LabelReader<U ndirEdge, _LabelReader>(_labelReader));1727 uEdgeLabelReader.reset(new _reader_bits:: 1728 LabelReader<UEdge, _LabelReader>(_labelReader)); 1729 1729 edgeLabelReader.reset(new _reader_bits:: 1730 1730 LabelReader<Edge, _LabelReader>(_labelReader)); … … 1733 1733 /// \brief Destructor. 1734 1734 /// 1735 /// Destructor for U ndirEdgeReader.1736 virtual ~U ndirEdgeReader() {}1735 /// Destructor for UEdgeReader. 1736 virtual ~UEdgeReader() {} 1737 1737 private: 1738 U ndirEdgeReader(const UndirEdgeReader&);1739 void operator=(const U ndirEdgeReader&);1740 1741 public: 1742 1743 /// \brief Add an undirected edge reader command for the U ndirEdgeReader.1744 /// 1745 /// Add an undirected edge reader command for the U ndirEdgeReader.1746 void readU ndirEdge(const std::string& name, UndirEdge& item) {1747 if (u ndirEdgeReaders.find(name) != undirEdgeReaders.end()) {1738 UEdgeReader(const UEdgeReader&); 1739 void operator=(const UEdgeReader&); 1740 1741 public: 1742 1743 /// \brief Add an undirected edge reader command for the UEdgeReader. 1744 /// 1745 /// Add an undirected edge reader command for the UEdgeReader. 1746 void readUEdge(const std::string& name, UEdge& item) { 1747 if (uEdgeReaders.find(name) != uEdgeReaders.end()) { 1748 1748 ErrorMessage msg; 1749 1749 msg << "Multiple read rule for undirected edge: " << name; 1750 1750 throw IOParameterError(msg.message()); 1751 1751 } 1752 u ndirEdgeReaders.insert(make_pair(name, _reader_bits::1753 ItemStore<U ndirEdge>(item)));1754 } 1755 1756 /// \brief Add an edge reader command for the U ndirEdgeReader.1757 /// 1758 /// Add an edge reader command for the U ndirEdgeReader.1752 uEdgeReaders.insert(make_pair(name, _reader_bits:: 1753 ItemStore<UEdge>(item))); 1754 } 1755 1756 /// \brief Add an edge reader command for the UEdgeReader. 1757 /// 1758 /// Add an edge reader command for the UEdgeReader. 1759 1759 void readEdge(const std::string& name, Edge& item) { 1760 1760 if (edgeReaders.find(name) != edgeReaders.end()) { … … 1778 1778 std::string id; 1779 1779 ls >> command >> name; 1780 return command == "@u ndiredges" && name == id;1780 return command == "@uedges" && name == id; 1781 1781 } 1782 1782 … … 1788 1788 throw DataFormatError("Cannot find undirected edgeset or label map"); 1789 1789 } 1790 if (!u ndirEdgeLabelReader->isLabelReader()) {1790 if (!uEdgeLabelReader->isLabelReader()) { 1791 1791 throw DataFormatError("Cannot find undirected edgeset or label map"); 1792 1792 } … … 1797 1797 ls >> id; 1798 1798 { 1799 typename U ndirEdgeReaders::iterator it = undirEdgeReaders.find(id);1800 if (it != u ndirEdgeReaders.end()) {1801 it->second.read(u ndirEdgeLabelReader->read(ls));1799 typename UEdgeReaders::iterator it = uEdgeReaders.find(id); 1800 if (it != uEdgeReaders.end()) { 1801 it->second.read(uEdgeLabelReader->read(ls)); 1802 1802 it->second.touch(); 1803 1803 continue; … … 1820 1820 } 1821 1821 } 1822 for (typename U ndirEdgeReaders::iterator it = undirEdgeReaders.begin();1823 it != u ndirEdgeReaders.end(); ++it) {1822 for (typename UEdgeReaders::iterator it = uEdgeReaders.begin(); 1823 it != uEdgeReaders.end(); ++it) { 1824 1824 if (!it->second.touched()) { 1825 1825 ErrorMessage msg; 1826 msg << "U ndirEdge not found in file: " << it->first;1826 msg << "UEdge not found in file: " << it->first; 1827 1827 throw IOParameterError(msg.message()); 1828 1828 } … … 1835 1835 1836 1836 typedef std::map<std::string, 1837 _reader_bits::ItemStore<U ndirEdge> > UndirEdgeReaders;1838 U ndirEdgeReaders undirEdgeReaders;1839 std::auto_ptr<_reader_bits::LabelReaderBase<U ndirEdge> > undirEdgeLabelReader;1837 _reader_bits::ItemStore<UEdge> > UEdgeReaders; 1838 UEdgeReaders uEdgeReaders; 1839 std::auto_ptr<_reader_bits::LabelReaderBase<UEdge> > uEdgeLabelReader; 1840 1840 1841 1841 typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders; … … 2026 2026 /// 2027 2027 /// Gives back how many undirected edgesets are in the file. 2028 int u ndirEdgeSetNum() const {2029 return u ndiredgesets.size();2028 int uEdgeSetNum() const { 2029 return uedgesets.size(); 2030 2030 } 2031 2031 … … 2034 2034 /// 2035 2035 /// Gives back the name of undirected edgeset on the indiced position. 2036 std::string u ndirEdgeSetName(int index) const {2037 return u ndiredgesets[index].name;2036 std::string uEdgeSetName(int index) const { 2037 return uedgesets[index].name; 2038 2038 } 2039 2039 … … 2042 2042 /// 2043 2043 /// Gives back the map names of undirected edgeset on the indiced position. 2044 const std::vector<std::string>& u ndirEdgeSetMaps(int index) const {2045 return u ndiredgesets[index].items;2044 const std::vector<std::string>& uEdgeSetMaps(int index) const { 2045 return uedgesets[index].items; 2046 2046 } 2047 2047 … … 2096 2096 /// 2097 2097 /// Gives back how many labeled undirected edges section are in the file. 2098 int u ndirEdgesNum() const {2099 return u ndiredges.size();2098 int uEdgesNum() const { 2099 return uedges.size(); 2100 2100 } 2101 2101 … … 2105 2105 /// Gives back the name of labeled undirected edges section on the 2106 2106 /// indiced position. 2107 std::string u ndirEdgesName(int index) const {2108 return u ndiredges[index].name;2107 std::string uEdgesName(int index) const { 2108 return uedges[index].name; 2109 2109 } 2110 2110 … … 2114 2114 /// Gives back the names of the labeled undirected edges in the 2115 2115 /// indiced section. 2116 const std::vector<std::string>& u ndirEdgesItems(int index) const {2117 return u ndiredges[index].items;2116 const std::vector<std::string>& uEdgesItems(int index) const { 2117 return uedges[index].items; 2118 2118 } 2119 2119 … … 2161 2161 current = command; 2162 2162 edgesets.push_back(SectionInfo(name)); 2163 } else if (command == "@u ndiredgeset") {2163 } else if (command == "@uedgeset") { 2164 2164 current = command; 2165 u ndiredgesets.push_back(SectionInfo(name));2165 uedgesets.push_back(SectionInfo(name)); 2166 2166 } else if (command == "@nodes") { 2167 2167 current = command; … … 2170 2170 current = command; 2171 2171 edges.push_back(SectionInfo(name)); 2172 } else if (command == "@u ndiredges") {2172 } else if (command == "@uedges") { 2173 2173 current = command; 2174 u ndiredges.push_back(SectionInfo(name));2174 uedges.push_back(SectionInfo(name)); 2175 2175 } else if (command == "@attributes") { 2176 2176 current = command; … … 2191 2191 } else if (current == "@edgeset") { 2192 2192 readMapNames(is, edgesets.back().items); 2193 } else if (current == "@u ndiredgeset") {2194 readMapNames(is, u ndiredgesets.back().items);2193 } else if (current == "@uedgeset") { 2194 readMapNames(is, uedgesets.back().items); 2195 2195 } else if (current == "@nodes") { 2196 2196 readItemNames(is, nodes.back().items); 2197 2197 } else if (current == "@edges") { 2198 2198 readItemNames(is, edges.back().items); 2199 } else if (current == "@u ndiredges") {2200 readItemNames(is, u ndiredges.back().items);2199 } else if (current == "@uedges") { 2200 readItemNames(is, uedges.back().items); 2201 2201 } else if (current == "@attributes") { 2202 2202 readItemNames(is, attributes.back().items); … … 2234 2234 std::vector<SectionInfo> nodesets; 2235 2235 std::vector<SectionInfo> edgesets; 2236 std::vector<SectionInfo> u ndiredgesets;2236 std::vector<SectionInfo> uedgesets; 2237 2237 2238 2238 std::vector<SectionInfo> nodes; 2239 2239 std::vector<SectionInfo> edges; 2240 std::vector<SectionInfo> u ndiredges;2240 std::vector<SectionInfo> uedges; 2241 2241 2242 2242 std::vector<SectionInfo> attributes;
Note: See TracChangeset
for help on using the changeset viewer.