Changeset 1070:c8c8801db0a4 in lemon for lemon
 Timestamp:
 08/04/11 21:33:17 (9 years ago)
 Branch:
 1.2
 Parents:
 1065:b522385b2a0d (diff), 1067:54464584b157 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.  Phase:
 public
 Files:

 2 edited
Legend:
 Unmodified
 Added
 Removed

lemon/lgf_reader.h
r956 r1070 3 3 * This file is a part of LEMON, a generic C++ optimization library. 4 4 * 5 * Copyright (C) 2003201 05 * Copyright (C) 20032011 6 6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport 7 7 * (Egervary Research Group on Combinatorial Optimization, EGRES). … … 965 965 int index = 0; 966 966 while (_reader_bits::readToken(line, map)) { 967 if(map == "") { 968 if(index!=0) 969 throw FormatError("'' is not allowed as a map name"); 970 else if (line >> std::ws >> c) 971 throw FormatError("Extra character at the end of line"); 972 else break; 973 } 967 974 if (maps.find(map) != maps.end()) { 968 975 std::ostringstream msg; … … 1835 1842 int index = 0; 1836 1843 while (_reader_bits::readToken(line, map)) { 1844 if(map == "") { 1845 if(index!=0) 1846 throw FormatError("'' is not allowed as a map name"); 1847 else if (line >> std::ws >> c) 1848 throw FormatError("Extra character at the end of line"); 1849 else break; 1850 } 1837 1851 if (maps.find(map) != maps.end()) { 1838 1852 std::ostringstream msg; 
lemon/lgf_reader.h
r1067 r1070 102 102 }; 103 103 104 template <typename _G raph, bool _dir, typename _Map,104 template <typename _GR, bool _dir, typename _Map, 105 105 typename _Converter = DefaultConverter<typename _Map::Value> > 106 class GraphArcMapStorage : public MapStorageBase<typename _G raph::Edge> {106 class GraphArcMapStorage : public MapStorageBase<typename _GR::Edge> { 107 107 public: 108 108 typedef _Map Map; 109 109 typedef _Converter Converter; 110 typedef _G raph Graph;111 typedef typename G raph::Edge Item;110 typedef _GR GR; 111 typedef typename GR::Edge Item; 112 112 static const bool dir = _dir; 113 113 114 114 private: 115 const G raph& _graph;115 const GR& _graph; 116 116 Map& _map; 117 117 Converter _converter; 118 118 119 119 public: 120 GraphArcMapStorage(const G raph& graph, Map& map,120 GraphArcMapStorage(const GR& graph, Map& map, 121 121 const Converter& converter = Converter()) 122 122 : _graph(graph), _map(map), _converter(converter) {} … … 174 174 }; 175 175 176 template <typename G raph>176 template <typename GR> 177 177 struct GraphArcLookUpConverter { 178 const G raph& _graph;179 const std::map<std::string, typename G raph::Edge>& _map;180 181 GraphArcLookUpConverter(const G raph& graph,178 const GR& _graph; 179 const std::map<std::string, typename GR::Edge>& _map; 180 181 GraphArcLookUpConverter(const GR& graph, 182 182 const std::map<std::string, 183 typename G raph::Edge>& map)183 typename GR::Edge>& map) 184 184 : _graph(graph), _map(map) {} 185 185 186 typename G raph::Arc operator()(const std::string& str) {186 typename GR::Arc operator()(const std::string& str) { 187 187 if (str.empty()  (str[0] != '+' && str[0] != '')) { 188 188 throw FormatError("Item must start with '+' or ''"); 189 189 } 190 typename std::map<std::string, typename G raph::Edge>190 typename std::map<std::string, typename GR::Edge> 191 191 ::const_iterator it = _map.find(str.substr(1)); 192 192 if (it == _map.end()) { … … 388 388 } 389 389 390 template <typename D igraph>390 template <typename DGR> 391 391 class DigraphReader; 392 392 393 template <typename Digraph> 394 DigraphReader<Digraph> digraphReader(Digraph& digraph, 395 std::istream& is = std::cin); 396 template <typename Digraph> 397 DigraphReader<Digraph> digraphReader(Digraph& digraph, const std::string& fn); 398 template <typename Digraph> 399 DigraphReader<Digraph> digraphReader(Digraph& digraph, const char *fn); 393 template <typename TDGR> 394 DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is = std::cin); 395 template <typename TDGR> 396 DigraphReader<TDGR> digraphReader(TDGR& digraph, const std::string& fn); 397 template <typename TDGR> 398 DigraphReader<TDGR> digraphReader(TDGR& digraph, const char *fn); 400 399 401 400 /// \ingroup lemon_io … … 420 419 /// 421 420 ///\code 422 /// DigraphReader<D igraph>(digraph, std::cin).421 /// DigraphReader<DGR>(digraph, std::cin). 423 422 /// nodeMap("coordinates", coord_map). 424 423 /// arcMap("capacity", cap_map). … … 429 428 ///\endcode 430 429 /// 431 /// By default the reader uses the first section in the file of the430 /// By default, the reader uses the first section in the file of the 432 431 /// proper type. If a section has an optional name, then it can be 433 432 /// selected for reading by giving an optional name parameter to the … … 449 448 /// a single pass, because the arcs are not constructed when the node 450 449 /// maps are read. 451 template <typename _Digraph>450 template <typename DGR> 452 451 class DigraphReader { 453 452 public: 454 453 455 typedef _Digraph Digraph; 456 TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); 454 typedef DGR Digraph; 457 455 458 456 private: 459 457 458 TEMPLATE_DIGRAPH_TYPEDEFS(DGR); 460 459 461 460 std::istream* _is; … … 463 462 std::string _filename; 464 463 465 D igraph& _digraph;464 DGR& _digraph; 466 465 467 466 std::string _nodes_caption; … … 501 500 /// Construct a directed graph reader, which reads from the given 502 501 /// input stream. 503 DigraphReader(D igraph& digraph, std::istream& is = std::cin)502 DigraphReader(DGR& digraph, std::istream& is = std::cin) 504 503 : _is(&is), local_is(false), _digraph(digraph), 505 504 _use_nodes(false), _use_arcs(false), … … 510 509 /// Construct a directed graph reader, which reads from the given 511 510 /// file. 512 DigraphReader(D igraph& digraph, const std::string& fn)511 DigraphReader(DGR& digraph, const std::string& fn) 513 512 : _is(new std::ifstream(fn.c_str())), local_is(true), 514 513 _filename(fn), _digraph(digraph), … … 525 524 /// Construct a directed graph reader, which reads from the given 526 525 /// file. 527 DigraphReader(D igraph& digraph, const char* fn)526 DigraphReader(DGR& digraph, const char* fn) 528 527 : _is(new std::ifstream(fn)), local_is(true), 529 528 _filename(fn), _digraph(digraph), … … 561 560 private: 562 561 563 template <typename DGR>564 friend DigraphReader< DGR> digraphReader(DGR& digraph, std::istream& is);565 template <typename DGR>566 friend DigraphReader< DGR> digraphReader(DGR& digraph,567 const std::string& fn);568 template <typename DGR>569 friend DigraphReader< DGR> digraphReader(DGR& digraph, const char *fn);562 template <typename TDGR> 563 friend DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is); 564 template <typename TDGR> 565 friend DigraphReader<TDGR> digraphReader(TDGR& digraph, 566 const std::string& fn); 567 template <typename TDGR> 568 friend DigraphReader<TDGR> digraphReader(TDGR& digraph, const char *fn); 570 569 571 570 DigraphReader(DigraphReader& other) … … 594 593 public: 595 594 596 /// \name Reading rules595 /// \name Reading Rules 597 596 /// @{ 598 597 … … 699 698 /// @} 700 699 701 /// \name Select section by name700 /// \name Select Section by Name 702 701 /// @{ 703 702 … … 728 727 /// @} 729 728 730 /// \name Using previously constructed node or arc set729 /// \name Using Previously Constructed Node or Arc Set 731 730 /// @{ 732 731 … … 848 847 readLine(); 849 848 } 850 line.putback(c); 849 if (readSuccess()) { 850 line.putback(c); 851 } 851 852 } 852 853 … … 1122 1123 public: 1123 1124 1124 /// \name Execution of the reader1125 /// \name Execution of the Reader 1125 1126 /// @{ 1126 1127 … … 1195 1196 }; 1196 1197 1198 /// \ingroup lemon_io 1199 /// 1200 /// \brief Return a \ref DigraphReader class 1201 /// 1202 /// This function just returns a \ref DigraphReader class. 1203 /// 1204 /// With this function a digraph can be read from an 1205 /// \ref lgfformat "LGF" file or input stream with several maps and 1206 /// attributes. For example, there is network flow problem on a 1207 /// digraph, i.e. a digraph with a \e capacity map on the arcs and 1208 /// \e source and \e target nodes. This digraph can be read with the 1209 /// following code: 1210 /// 1211 ///\code 1212 ///ListDigraph digraph; 1213 ///ListDigraph::ArcMap<int> cm(digraph); 1214 ///ListDigraph::Node src, trg; 1215 ///digraphReader(digraph, std::cin). 1216 /// arcMap("capacity", cap). 1217 /// node("source", src). 1218 /// node("target", trg). 1219 /// run(); 1220 ///\endcode 1221 /// 1222 /// For a complete documentation, please see the \ref DigraphReader 1223 /// class documentation. 1224 /// \warning Don't forget to put the \ref DigraphReader::run() "run()" 1225 /// to the end of the parameter list. 1226 /// \relates DigraphReader 1227 /// \sa digraphReader(TDGR& digraph, const std::string& fn) 1228 /// \sa digraphReader(TDGR& digraph, const char* fn) 1229 template <typename TDGR> 1230 DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is) { 1231 DigraphReader<TDGR> tmp(digraph, is); 1232 return tmp; 1233 } 1234 1197 1235 /// \brief Return a \ref DigraphReader class 1198 1236 /// 1199 1237 /// This function just returns a \ref DigraphReader class. 1200 1238 /// \relates DigraphReader 1201 template <typename Digraph> 1202 DigraphReader<Digraph> digraphReader(Digraph& digraph, std::istream& is) { 1203 DigraphReader<Digraph> tmp(digraph, is); 1239 /// \sa digraphReader(TDGR& digraph, std::istream& is) 1240 template <typename TDGR> 1241 DigraphReader<TDGR> digraphReader(TDGR& digraph, const std::string& fn) { 1242 DigraphReader<TDGR> tmp(digraph, fn); 1204 1243 return tmp; 1205 1244 } … … 1209 1248 /// This function just returns a \ref DigraphReader class. 1210 1249 /// \relates DigraphReader 1211 template <typename Digraph>1212 DigraphReader<Digraph> digraphReader(Digraph& digraph,1213 const std::string&fn) {1214 DigraphReader< Digraph> tmp(digraph, fn);1250 /// \sa digraphReader(TDGR& digraph, std::istream& is) 1251 template <typename TDGR> 1252 DigraphReader<TDGR> digraphReader(TDGR& digraph, const char* fn) { 1253 DigraphReader<TDGR> tmp(digraph, fn); 1215 1254 return tmp; 1216 1255 } 1217 1256 1218 /// \brief Return a \ref DigraphReader class 1219 /// 1220 /// This function just returns a \ref DigraphReader class. 1221 /// \relates DigraphReader 1222 template <typename Digraph> 1223 DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) { 1224 DigraphReader<Digraph> tmp(digraph, fn); 1225 return tmp; 1226 } 1227 1228 template <typename Graph> 1257 template <typename GR> 1229 1258 class GraphReader; 1230 1231 template <typename Graph> 1232 GraphReader<Graph> graphReader(Graph& graph, 1233 std::istream& is = std::cin); 1234 template <typename Graph> 1235 GraphReader<Graph> graphReader(Graph& graph, const std::string& fn); 1236 template <typename Graph> 1237 GraphReader<Graph> graphReader(Graph& graph, const char *fn); 1259 1260 template <typename TGR> 1261 GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin); 1262 template <typename TGR> 1263 GraphReader<TGR> graphReader(TGR& graph, const std::string& fn); 1264 template <typename TGR> 1265 GraphReader<TGR> graphReader(TGR& graph, const char *fn); 1238 1266 1239 1267 /// \ingroup lemon_io … … 1252 1280 /// arc map. Similarly, an attribute can be read into an arc, if 1253 1281 /// it's value is an edge label prefixed with \c '+' or \c ''. 1254 template <typename _Graph>1282 template <typename GR> 1255 1283 class GraphReader { 1256 1284 public: 1257 1285 1258 typedef _Graph Graph; 1259 TEMPLATE_GRAPH_TYPEDEFS(Graph); 1286 typedef GR Graph; 1260 1287 1261 1288 private: 1289 1290 TEMPLATE_GRAPH_TYPEDEFS(GR); 1262 1291 1263 1292 std::istream* _is; … … 1265 1294 std::string _filename; 1266 1295 1267 G raph& _graph;1296 GR& _graph; 1268 1297 1269 1298 std::string _nodes_caption; … … 1303 1332 /// Construct an undirected graph reader, which reads from the given 1304 1333 /// input stream. 1305 GraphReader(G raph& graph, std::istream& is = std::cin)1334 GraphReader(GR& graph, std::istream& is = std::cin) 1306 1335 : _is(&is), local_is(false), _graph(graph), 1307 1336 _use_nodes(false), _use_edges(false), … … 1312 1341 /// Construct an undirected graph reader, which reads from the given 1313 1342 /// file. 1314 GraphReader(G raph& graph, const std::string& fn)1343 GraphReader(GR& graph, const std::string& fn) 1315 1344 : _is(new std::ifstream(fn.c_str())), local_is(true), 1316 1345 _filename(fn), _graph(graph), … … 1327 1356 /// Construct an undirected graph reader, which reads from the given 1328 1357 /// file. 1329 GraphReader(G raph& graph, const char* fn)1358 GraphReader(GR& graph, const char* fn) 1330 1359 : _is(new std::ifstream(fn)), local_is(true), 1331 1360 _filename(fn), _graph(graph), … … 1362 1391 1363 1392 private: 1364 template <typename GR>1365 friend GraphReader< GR> graphReader(GR& graph, std::istream& is);1366 template <typename GR>1367 friend GraphReader< GR> graphReader(GR& graph, const std::string& fn);1368 template <typename GR>1369 friend GraphReader< GR> graphReader(GR& graph, const char *fn);1393 template <typename TGR> 1394 friend GraphReader<TGR> graphReader(TGR& graph, std::istream& is); 1395 template <typename TGR> 1396 friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn); 1397 template <typename TGR> 1398 friend GraphReader<TGR> graphReader(TGR& graph, const char *fn); 1370 1399 1371 1400 GraphReader(GraphReader& other) … … 1394 1423 public: 1395 1424 1396 /// \name Reading rules1425 /// \name Reading Rules 1397 1426 /// @{ 1398 1427 … … 1459 1488 _edge_maps.push_back(std::make_pair('+' + caption, forward_storage)); 1460 1489 _reader_bits::MapStorageBase<Edge>* backward_storage = 1461 new _reader_bits::GraphArcMapStorage<G raph, false, Map>(_graph, map);1490 new _reader_bits::GraphArcMapStorage<GR, false, Map>(_graph, map); 1462 1491 _edge_maps.push_back(std::make_pair('' + caption, backward_storage)); 1463 1492 return *this; … … 1473 1502 checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>(); 1474 1503 _reader_bits::MapStorageBase<Edge>* forward_storage = 1475 new _reader_bits::GraphArcMapStorage<G raph, true, Map, Converter>1504 new _reader_bits::GraphArcMapStorage<GR, true, Map, Converter> 1476 1505 (_graph, map, converter); 1477 1506 _edge_maps.push_back(std::make_pair('+' + caption, forward_storage)); 1478 1507 _reader_bits::MapStorageBase<Edge>* backward_storage = 1479 new _reader_bits::GraphArcMapStorage<G raph, false, Map, Converter>1508 new _reader_bits::GraphArcMapStorage<GR, false, Map, Converter> 1480 1509 (_graph, map, converter); 1481 1510 _edge_maps.push_back(std::make_pair('' + caption, backward_storage)); … … 1535 1564 /// Add an arc reading rule to reader. 1536 1565 GraphReader& arc(const std::string& caption, Arc& arc) { 1537 typedef _reader_bits::GraphArcLookUpConverter<G raph> Converter;1566 typedef _reader_bits::GraphArcLookUpConverter<GR> Converter; 1538 1567 Converter converter(_graph, _edge_index); 1539 1568 _reader_bits::ValueStorageBase* storage = … … 1545 1574 /// @} 1546 1575 1547 /// \name Select section by name1576 /// \name Select Section by Name 1548 1577 /// @{ 1549 1578 … … 1574 1603 /// @} 1575 1604 1576 /// \name Using previously constructed node or edge set1605 /// \name Using Previously Constructed Node or Edge Set 1577 1606 /// @{ 1578 1607 … … 1695 1724 readLine(); 1696 1725 } 1697 line.putback(c); 1726 if (readSuccess()) { 1727 line.putback(c); 1728 } 1698 1729 } 1699 1730 … … 1969 2000 public: 1970 2001 1971 /// \name Execution of the reader2002 /// \name Execution of the Reader 1972 2003 /// @{ 1973 2004 … … 2043 2074 }; 2044 2075 2076 /// \ingroup lemon_io 2077 /// 2078 /// \brief Return a \ref GraphReader class 2079 /// 2080 /// This function just returns a \ref GraphReader class. 2081 /// 2082 /// With this function a graph can be read from an 2083 /// \ref lgfformat "LGF" file or input stream with several maps and 2084 /// attributes. For example, there is weighted matching problem on a 2085 /// graph, i.e. a graph with a \e weight map on the edges. This 2086 /// graph can be read with the following code: 2087 /// 2088 ///\code 2089 ///ListGraph graph; 2090 ///ListGraph::EdgeMap<int> weight(graph); 2091 ///graphReader(graph, std::cin). 2092 /// edgeMap("weight", weight). 2093 /// run(); 2094 ///\endcode 2095 /// 2096 /// For a complete documentation, please see the \ref GraphReader 2097 /// class documentation. 2098 /// \warning Don't forget to put the \ref GraphReader::run() "run()" 2099 /// to the end of the parameter list. 2100 /// \relates GraphReader 2101 /// \sa graphReader(TGR& graph, const std::string& fn) 2102 /// \sa graphReader(TGR& graph, const char* fn) 2103 template <typename TGR> 2104 GraphReader<TGR> graphReader(TGR& graph, std::istream& is) { 2105 GraphReader<TGR> tmp(graph, is); 2106 return tmp; 2107 } 2108 2045 2109 /// \brief Return a \ref GraphReader class 2046 2110 /// 2047 2111 /// This function just returns a \ref GraphReader class. 2048 2112 /// \relates GraphReader 2049 template <typename Graph> 2050 GraphReader<Graph> graphReader(Graph& graph, std::istream& is) { 2051 GraphReader<Graph> tmp(graph, is); 2113 /// \sa graphReader(TGR& graph, std::istream& is) 2114 template <typename TGR> 2115 GraphReader<TGR> graphReader(TGR& graph, const std::string& fn) { 2116 GraphReader<TGR> tmp(graph, fn); 2052 2117 return tmp; 2053 2118 } … … 2057 2122 /// This function just returns a \ref GraphReader class. 2058 2123 /// \relates GraphReader 2059 template <typename Graph> 2060 GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) { 2061 GraphReader<Graph> tmp(graph, fn); 2062 return tmp; 2063 } 2064 2065 /// \brief Return a \ref GraphReader class 2066 /// 2067 /// This function just returns a \ref GraphReader class. 2068 /// \relates GraphReader 2069 template <typename Graph> 2070 GraphReader<Graph> graphReader(Graph& graph, const char* fn) { 2071 GraphReader<Graph> tmp(graph, fn); 2124 /// \sa graphReader(TGR& graph, std::istream& is) 2125 template <typename TGR> 2126 GraphReader<TGR> graphReader(TGR& graph, const char* fn) { 2127 GraphReader<TGR> tmp(graph, fn); 2072 2128 return tmp; 2073 2129 } … … 2168 2224 public: 2169 2225 2170 /// \name Section readers2226 /// \name Section Readers 2171 2227 /// @{ 2172 2228 … … 2180 2236 /// whitespaces are trimmed from each processed string. 2181 2237 /// 2182 /// For example let's see a section, which contain several2238 /// For example, let's see a section, which contain several 2183 2239 /// integers, which should be inserted into a vector. 2184 2240 ///\code … … 2259 2315 readLine(); 2260 2316 } 2261 line.putback(c); 2317 if (readSuccess()) { 2318 line.putback(c); 2319 } 2262 2320 } 2263 2321 … … 2265 2323 2266 2324 2267 /// \name Execution of the reader2325 /// \name Execution of the Reader 2268 2326 /// @{ 2269 2327 … … 2324 2382 }; 2325 2383 2384 /// \ingroup lemon_io 2385 /// 2326 2386 /// \brief Return a \ref SectionReader class 2327 2387 /// 2328 2388 /// This function just returns a \ref SectionReader class. 2389 /// 2390 /// Please see SectionReader documentation about the custom section 2391 /// input. 2392 /// 2329 2393 /// \relates SectionReader 2394 /// \sa sectionReader(const std::string& fn) 2395 /// \sa sectionReader(const char *fn) 2330 2396 inline SectionReader sectionReader(std::istream& is) { 2331 2397 SectionReader tmp(is); … … 2337 2403 /// This function just returns a \ref SectionReader class. 2338 2404 /// \relates SectionReader 2405 /// \sa sectionReader(std::istream& is) 2339 2406 inline SectionReader sectionReader(const std::string& fn) { 2340 2407 SectionReader tmp(fn); … … 2346 2413 /// This function just returns a \ref SectionReader class. 2347 2414 /// \relates SectionReader 2415 /// \sa sectionReader(std::istream& is) 2348 2416 inline SectionReader sectionReader(const char* fn) { 2349 2417 SectionReader tmp(fn); … … 2447 2515 2448 2516 2449 /// \name Node sections2517 /// \name Node Sections 2450 2518 /// @{ 2451 2519 … … 2473 2541 /// @} 2474 2542 2475 /// \name Arc/Edge sections2543 /// \name Arc/Edge Sections 2476 2544 /// @{ 2477 2545 … … 2531 2599 /// @} 2532 2600 2533 /// \name Attribute sections2601 /// \name Attribute Sections 2534 2602 /// @{ 2535 2603 … … 2557 2625 /// @} 2558 2626 2559 /// \name Extra sections2627 /// \name Extra Sections 2560 2628 /// @{ 2561 2629 … … 2600 2668 readLine(); 2601 2669 } 2602 line.putback(c); 2670 if (readSuccess()) { 2671 line.putback(c); 2672 } 2603 2673 } 2604 2674 … … 2631 2701 public: 2632 2702 2633 /// \name Execution of the contents reader2703 /// \name Execution of the Contents Reader 2634 2704 /// @{ 2635 2705
Note: See TracChangeset
for help on using the changeset viewer.