COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changeset 2386:81b47fc5c444 in lemon-0.x for lemon/lemon_reader.h


Ignore:
Timestamp:
03/02/07 19:04:28 (17 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3217
Message:

Hard Warning checking

  • based on the remark of the ZIB user
  • we do not use -Winline
File:
1 edited

Legend:

Unmodified
Added
Removed

  • lemon/lemon_reader.h

    r2368 r2386  
    534534      virtual std::streambuf* setbuf(char *buf, std::streamsize len) {
    535535        if (base()) return 0;
    536         if (buf != 0 && len >= (int)sizeof(small_buf)) {
     536        if (buf != 0 && len >= int(sizeof(small_buf))) {
    537537          setb(buf, len);
    538538        } else {
    … …  
    710710              FilterStreamBuf buffer(*is, line_num);
    711711              buffer.pubsetbuf(buf, sizeof(buf));
    712               std::istream is(&buffer);
    713               it->first->read(is);
     712              std::istream ss(&buffer);
     713              it->first->read(ss);
    714714              break;
    715715            }
    … …  
    798798    /// Add a new node map reader command for the reader.
    799799    template <typename Map>
    800     NodeSetReader& readNodeMap(std::string name, Map& map) {
     800    NodeSetReader& readNodeMap(std::string label, Map& map) {
    801801      return _readMap<
    802802        typename Traits::template Reader<typename Map::Value>, Map,
    803         typename _reader_bits::Arg<Map>::Type>(name, map);
     803        typename _reader_bits::Arg<Map>::Type>(label, map);
    804804    }
    805805
    806806    template <typename Map>
    807     NodeSetReader& readNodeMap(std::string name, const Map& map) {
     807    NodeSetReader& readNodeMap(std::string label, const Map& map) {
    808808      return _readMap<
    809809        typename Traits::template Reader<typename Map::Value>, Map,
    810         typename _reader_bits::Arg<Map>::Type>(name, map);
     810        typename _reader_bits::Arg<Map>::Type>(label, map);
    811811    }
    812812
    … …  
    814814    ///
    815815    /// Add a new node map reader command for the reader.
    816     template <typename Reader, typename Map>
    817     NodeSetReader& readNodeMap(std::string name, Map& map,
    818                                const Reader& reader = Reader()) {
    819       return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    820         (name, map, reader);
    821     }
    822 
    823     template <typename Reader, typename Map>
    824     NodeSetReader& readNodeMap(std::string name, const Map& map,
    825                                const Reader& reader = Reader()) {
    826       return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    827         (name, map, reader);
     816    template <typename ItemReader, typename Map>
     817    NodeSetReader& readNodeMap(std::string label, Map& map,
     818                               const ItemReader& ir = ItemReader()) {
     819      return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
     820        (label, map, ir);
     821    }
     822
     823    template <typename ItemReader, typename Map>
     824    NodeSetReader& readNodeMap(std::string label, const Map& map,
     825                               const ItemReader& ir = ItemReader()) {
     826      return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
     827        (label, map, ir);
    828828    }
    829829
    830830  private:
    831831
    832     template <typename Reader, typename Map, typename MapParameter>
    833     NodeSetReader& _readMap(std::string name, MapParameter map,
    834                             const Reader& reader = Reader()) {
     832    template <typename ItemReader, typename Map, typename MapParameter>
     833    NodeSetReader& _readMap(std::string label, MapParameter map,
     834                            const ItemReader& ir = ItemReader()) {
    835835      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
    836       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
    837       if (readers.find(name) != readers.end()) {
     836      checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
     837      if (readers.find(label) != readers.end()) {
    838838        ErrorMessage msg;
    839         msg << "Multiple read rule for node map: " << name;
     839        msg << "Multiple read rule for node map: " << label;
    840840        throw IoParameterError(msg.message());
    841841      }     
    842842      readers.insert(
    843         make_pair(name, new _reader_bits::
    844                   MapReader<Node, Map, Reader>(map, reader)));
     843        make_pair(label, new _reader_bits::
     844                  MapReader<Node, Map, ItemReader>(map, ir)));
    845845      return *this;
    846846    }
    … …  
    851851    ///
    852852    /// Add a new node map skipper command for the reader.
    853     template <typename Reader>
    854     NodeSetReader& skipNodeMap(std::string name,
    855                            const Reader& reader = Reader()) {
    856       if (readers.find(name) != readers.end()) {
     853    template <typename ItemReader>
     854    NodeSetReader& skipNodeMap(std::string label,
     855                               const ItemReader& ir = ItemReader()) {
     856      if (readers.find(label) != readers.end()) {
    857857        ErrorMessage msg;
    858         msg << "Multiple read rule for node map: " << name;
     858        msg << "Multiple read rule for node map: " << label;
    859859        throw IoParameterError(msg.message());
    860860      }
    861       readers.insert(make_pair(name, new _reader_bits::
    862                                SkipReader<Node, Reader>(reader)));
     861      readers.insert(make_pair(label, new _reader_bits::
     862                               SkipReader<Node, ItemReader>(ir)));
    863863      return *this;
    864864    }
    … …  
    886886      std::string line;
    887887
    888       getline(is, line);
    889       std::istringstream ls(line);
    890       std::string id;
    891       while (ls >> id) {
    892         typename MapReaders::iterator it = readers.find(id);
    893         if (it != readers.end()) {
    894           it->second->touch();
    895           index.push_back(it->second);
    896         } else {
    897           index.push_back(&skipper);
    898         }
    899         if (id == "label") {
    900           inverter.reset(index.back()->getInverter());
    901           index.back() = inverter.get();
    902         }
     888      {
     889        getline(is, line);
     890        std::istringstream ls(line);
     891        std::string id;
     892        while (ls >> id) {
     893          typename MapReaders::iterator it = readers.find(id);
     894          if (it != readers.end()) {
     895            it->second->touch();
     896            index.push_back(it->second);
     897          } else {
     898            index.push_back(&skipper);
     899          }
     900          if (id == "label") {
     901            inverter.reset(index.back()->getInverter());
     902            index.back() = inverter.get();
     903          }
     904        }
    903905      }
    904906      for (typename MapReaders::iterator it = readers.begin();
    … …  
    913915        Node node = graph.addNode();
    914916        std::istringstream ls(line);
    915         for (int i = 0; i < (int)index.size(); ++i) {
     917        for (int i = 0; i < int(index.size()); ++i) {
    916918          index[i]->read(ls, node);
    917919        }
    … …  
    10281030    /// Add a new edge map reader command for the reader.
    10291031    template <typename Map>
    1030     EdgeSetReader& readEdgeMap(std::string name, Map& map) {
     1032    EdgeSetReader& readEdgeMap(std::string label, Map& map) {
    10311033      return _readMap<
    10321034        typename Traits::template Reader<typename Map::Value>, Map,
    1033         typename _reader_bits::Arg<Map>::Type>(name, map);
     1035        typename _reader_bits::Arg<Map>::Type>(label, map);
    10341036    }
    10351037
    10361038    template <typename Map>
    1037     EdgeSetReader& readEdgeMap(std::string name, const Map& map) {
     1039    EdgeSetReader& readEdgeMap(std::string label, const Map& map) {
    10381040      return _readMap<
    10391041        typename Traits::template Reader<typename Map::Value>, Map,
    1040         typename _reader_bits::Arg<Map>::Type>(name, map);
     1042        typename _reader_bits::Arg<Map>::Type>(label, map);
    10411043    }
    10421044
    … …  
    10441046    ///
    10451047    /// Add a new edge map reader command for the reader.
    1046     template <typename Reader, typename Map>
    1047     EdgeSetReader& readEdgeMap(std::string name, Map& map,
    1048                            const Reader& reader = Reader()) {
    1049       return _readMap<Reader, Map,
    1050         typename _reader_bits::Arg<Map>::Type>(name, map, reader);
    1051     }
    1052 
    1053     template <typename Reader, typename Map>
    1054     EdgeSetReader& readEdgeMap(std::string name, const Map& map,
    1055                                const Reader& reader = Reader()) {
    1056       return _readMap<Reader, Map,
    1057         typename _reader_bits::Arg<Map>::Type>(name, map, reader);
     1048    template <typename ItemReader, typename Map>
     1049    EdgeSetReader& readEdgeMap(std::string label, Map& map,
     1050                               const ItemReader& ir = ItemReader()) {
     1051      return _readMap<ItemReader, Map,
     1052        typename _reader_bits::Arg<Map>::Type>(label, map, ir);
     1053    }
     1054
     1055    template <typename ItemReader, typename Map>
     1056    EdgeSetReader& readEdgeMap(std::string label, const Map& map,
     1057                               const ItemReader& ir = ItemReader()) {
     1058      return _readMap<ItemReader, Map,
     1059        typename _reader_bits::Arg<Map>::Type>(label, map, ir);
    10581060    }
    10591061
    10601062  private:
    10611063
    1062     template <typename Reader, typename Map, typename MapParameter>
    1063     EdgeSetReader& _readMap(std::string name, MapParameter map,
    1064                             const Reader& reader = Reader()) {
     1064    template <typename ItemReader, typename Map, typename MapParameter>
     1065    EdgeSetReader& _readMap(std::string label, MapParameter map,
     1066                            const ItemReader& ir = ItemReader()) {
    10651067      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
    1066       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
    1067       if (readers.find(name) != readers.end()) {
     1068      checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
     1069      if (readers.find(label) != readers.end()) {
    10681070        ErrorMessage msg;
    1069         msg << "Multiple read rule for edge map: " << name;
     1071        msg << "Multiple read rule for edge map: " << label;
    10701072        throw IoParameterError(msg.message());
    10711073      }
    10721074      readers.insert(
    1073         make_pair(name, new _reader_bits::
    1074                   MapReader<Edge, Map, Reader>(map, reader)));
     1075        make_pair(label, new _reader_bits::
     1076                  MapReader<Edge, Map, ItemReader>(map, ir)));
    10751077      return *this;
    10761078    }
    … …  
    10811083    ///
    10821084    /// Add a new edge map skipper command for the reader.
    1083     template <typename Reader>
    1084     EdgeSetReader& skipEdgeMap(std::string name,
    1085                                const Reader& reader = Reader()) {
    1086       if (readers.find(name) != readers.end()) {
     1085    template <typename ItemReader>
     1086    EdgeSetReader& skipEdgeMap(std::string label,
     1087                               const ItemReader& ir = ItemReader()) {
     1088      if (readers.find(label) != readers.end()) {
    10871089        ErrorMessage msg;
    1088         msg << "Multiple read rule for edge map: " << name;
     1090        msg << "Multiple read rule for edge map: " << label;
    10891091        throw IoParameterError(msg.message());
    10901092      }
    1091       readers.insert(make_pair(name, new _reader_bits::
    1092                                SkipReader<Edge, Reader>(reader)));
     1093      readers.insert(make_pair(label, new _reader_bits::
     1094                               SkipReader<Edge, ItemReader>(ir)));
    10931095      return *this;
    10941096    }
    … …  
    11191121      std::string line;
    11201122
    1121       getline(is, line);
    1122       std::istringstream ls(line);     
    1123       std::string id;
    1124       while (ls >> id) {
    1125         typename MapReaders::iterator it = readers.find(id);
    1126         if (it != readers.end()) {
    1127           index.push_back(it->second);
    1128           it->second->touch();
    1129         } else {
    1130           index.push_back(&skipper);
    1131         }
    1132         if (id == "label") {
    1133           inverter.reset(index.back()->getInverter());
    1134           index.back() = inverter.get();
    1135         }
     1123      {
     1124        getline(is, line);
     1125        std::istringstream ls(line);   
     1126        std::string id;
     1127        while (ls >> id) {
     1128          typename MapReaders::iterator it = readers.find(id);
     1129          if (it != readers.end()) {
     1130            index.push_back(it->second);
     1131            it->second->touch();
     1132          } else {
     1133            index.push_back(&skipper);
     1134          }
     1135          if (id == "label") {
     1136            inverter.reset(index.back()->getInverter());
     1137            index.back() = inverter.get();
     1138          }
     1139        }
    11361140      }
    11371141      for (typename MapReaders::iterator it = readers.begin();
    … …  
    11481152        Node to = nodeLabelReader->read(ls);
    11491153        Edge edge = graph.addEdge(from, to);
    1150         for (int i = 0; i < (int)index.size(); ++i) {
     1154        for (int i = 0; i < int(index.size()); ++i) {
    11511155          index[i]->read(ls, edge);
    11521156        }
    … …  
    12721276    /// Add a new edge undirected map reader command for the reader.
    12731277    template <typename Map>
    1274     UEdgeSetReader& readUEdgeMap(std::string name, Map& map) {
     1278    UEdgeSetReader& readUEdgeMap(std::string label, Map& map) {
    12751279      return _readMap<
    12761280        typename Traits::template Reader<typename Map::Value>, Map,
    1277         typename _reader_bits::Arg<Map>::Type>(name, map);
     1281        typename _reader_bits::Arg<Map>::Type>(label, map);
    12781282    }
    12791283
    12801284    template <typename Map>
    1281     UEdgeSetReader& readUEdgeMap(std::string name, const Map& map) {
     1285    UEdgeSetReader& readUEdgeMap(std::string label, const Map& map) {
    12821286      return _readMap<
    12831287        typename Traits::template Reader<typename Map::Value>, Map,
    1284         typename _reader_bits::Arg<Map>::Type>(name, map);
     1288        typename _reader_bits::Arg<Map>::Type>(label, map);
    12851289    }
    12861290
    … …  
    12881292    ///
    12891293    /// Add a new edge undirected map reader command for the reader.
    1290     template <typename Reader, typename Map>
    1291     UEdgeSetReader& readUEdgeMap(std::string name, Map& map,
    1292                                          const Reader& reader = Reader()) {
    1293       return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    1294         (name, map, reader);
    1295     }
    1296 
    1297     template <typename Reader, typename Map>
    1298     UEdgeSetReader& readUEdgeMap(std::string name, const Map& map,
    1299                                          const Reader& reader = Reader()) {
    1300       return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type >
    1301         (name, map, reader);
     1294    template <typename ItemReader, typename Map>
     1295    UEdgeSetReader& readUEdgeMap(std::string label, Map& map,
     1296                                 const ItemReader& ir = ItemReader()) {
     1297      return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type>
     1298        (label, map, ir);
     1299    }
     1300
     1301    template <typename ItemReader, typename Map>
     1302    UEdgeSetReader& readUEdgeMap(std::string label, const Map& map,
     1303                                 const ItemReader& ir = ItemReader()) {
     1304      return _readMap<ItemReader, Map, typename _reader_bits::Arg<Map>::Type >
     1305        (label, map, ir);
    13021306    }
    13031307
    13041308  private:
    13051309
    1306     template <typename Reader, typename Map, typename MapParameter>
    1307     UEdgeSetReader& _readMap(std::string name, MapParameter map,
    1308                                  const Reader& reader = Reader()) {
     1310    template <typename ItemReader, typename Map, typename MapParameter>
     1311    UEdgeSetReader& _readMap(std::string label, MapParameter map,
     1312                             const ItemReader& ir = ItemReader()) {
    13091313      checkConcept<concepts::WriteMap<UEdge, typename Map::Value>, Map>();
    1310       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
    1311       if (readers.find(name) != readers.end()) {
     1314      checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
     1315      if (readers.find(label) != readers.end()) {
    13121316        ErrorMessage msg;
    1313         msg << "Multiple read rule for edge map: " << name;
     1317        msg << "Multiple read rule for edge map: " << label;
    13141318        throw IoParameterError(msg.message());
    13151319      }
    13161320      readers.insert(
    1317         make_pair(name, new _reader_bits::
    1318                   MapReader<UEdge, Map, Reader>(map, reader)));
     1321        make_pair(label, new _reader_bits::
     1322                  MapReader<UEdge, Map, ItemReader>(map, ir)));
    13191323      return *this;
    13201324    }
    … …  
    13251329    ///
    13261330    /// Add a new undirected edge map skipper command for the reader.
    1327     template <typename Reader>
    1328     UEdgeSetReader& skipUEdgeMap(std::string name,
    1329                                          const Reader& reader = Reader()) {
    1330       if (readers.find(name) != readers.end()) {
     1331    template <typename ItemReader>
     1332    UEdgeSetReader& skipUEdgeMap(std::string label,
     1333                                 const ItemReader& ir = ItemReader()) {
     1334      if (readers.find(label) != readers.end()) {
    13311335        ErrorMessage msg;
    1332         msg << "Multiple read rule for node map: " << name;
     1336        msg << "Multiple read rule for node map: " << label;
    13331337        throw IoParameterError(msg.message());
    13341338      }
    1335       readers.insert(make_pair(name, new _reader_bits::
    1336                                SkipReader<UEdge, Reader>(reader)));
     1339      readers.insert(make_pair(label, new _reader_bits::
     1340                               SkipReader<UEdge, ItemReader>(ir)));
    13371341      return *this;
    13381342    }
    … …  
    13421346    /// Add a new directed edge map reader command for the reader.
    13431347    template <typename Map>
    1344     UEdgeSetReader& readEdgeMap(std::string name, Map& map) {
     1348    UEdgeSetReader& readEdgeMap(std::string label, Map& map) {
    13451349      return _readDirMap<
    13461350        typename Traits::template Reader<typename Map::Value>, Map,
    1347         typename _reader_bits::Arg<Map>::Type>(name, map);
     1351        typename _reader_bits::Arg<Map>::Type>(label, map);
    13481352    }
    13491353
    13501354    template <typename Map>
    1351     UEdgeSetReader& readEdgeMap(std::string name, const Map& map) {
     1355    UEdgeSetReader& readEdgeMap(std::string label, const Map& map) {
    13521356      return _readDirMap<
    13531357        typename Traits::template Reader<typename Map::Value>, Map,
    1354         typename _reader_bits::Arg<Map>::Type>(name, map);
     1358        typename _reader_bits::Arg<Map>::Type>(label, map);
    13551359    }
    13561360
    … …  
    13581362    ///
    13591363    /// Add a new directed edge map reader command for the reader.
    1360     template <typename Reader, typename Map>
    1361     UEdgeSetReader& readEdgeMap(std::string name, Map& map,
    1362                                     const Reader& reader = Reader()) {
    1363       return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    1364         (name, map, reader);
    1365     }
    1366 
    1367     template <typename Reader, typename Map>
    1368     UEdgeSetReader& readEdgeMap(std::string name, const Map& map,
    1369                                     const Reader& reader = Reader()) {
    1370       return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    1371         (name, map, reader);
     1364    template <typename ItemReader, typename Map>
     1365    UEdgeSetReader& readEdgeMap(std::string label, Map& map,
     1366                                    const ItemReader& ir = ItemReader()) {
     1367      return _readDirMap<ItemReader, Map,
     1368        typename _reader_bits::Arg<Map>::Type>(label, map, ir);
     1369    }
     1370
     1371    template <typename ItemReader, typename Map>
     1372    UEdgeSetReader& readEdgeMap(std::string label, const Map& map,
     1373                                    const ItemReader& ir = ItemReader()) {
     1374      return _readDirMap<ItemReader, Map,
     1375        typename _reader_bits::Arg<Map>::Type>(label, map, ir);
    13721376    }
    13731377
    13741378  private:
    13751379
    1376     template <typename Reader, typename Map, typename MapParameter>
    1377     UEdgeSetReader& _readDirMap(std::string name, MapParameter map,
    1378                                     const Reader& reader = Reader()) {
    1379       checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
     1380    template <typename ItemReader, typename Map, typename MapParameter>
     1381    UEdgeSetReader& _readDirMap(std::string label, MapParameter map,
     1382                                    const ItemReader& ir = ItemReader()) {
     1383      checkConcept<_reader_bits::ItemReader<typename Map::Value>, ItemReader>();
    13801384      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
    1381       readUEdgeMap("+" + name,
    1382                    _reader_bits::forwardComposeMap(graph, map), reader);
    1383       readUEdgeMap("-" + name,
    1384                    _reader_bits::backwardComposeMap(graph, map), reader);
     1385      readUEdgeMap("+" + label,
     1386                   _reader_bits::forwardComposeMap(graph, map), ir);
     1387      readUEdgeMap("-" + label,
     1388                   _reader_bits::backwardComposeMap(graph, map), ir);
    13851389      return *this;     
    13861390    }
    … …  
    13911395    ///
    13921396    /// Add a new directed edge map skipper command for the reader.
    1393     template <typename Reader>
    1394     UEdgeSetReader& skipEdgeMap(std::string name,
    1395                                 const Reader& reader = Reader()) {
    1396       skipUEdgeMap("+" + name, reader);
    1397       skipUEdgeMap("-" + name, reader);
     1397    template <typename ItemReader>
     1398    UEdgeSetReader& skipEdgeMap(std::string label,
     1399                                const ItemReader& ir = ItemReader()) {
     1400      skipUEdgeMap("+" + label, ir);
     1401      skipUEdgeMap("-" + label, ir);
    13981402      return *this;
    13991403    }
    … …  
    14241428      std::string line;
    14251429
    1426       getline(is, line);
    1427       std::istringstream ls(line);     
    1428       std::string id;
    1429       while (ls >> id) {
    1430         typename MapReaders::iterator it = readers.find(id);
    1431         if (it != readers.end()) {
    1432           index.push_back(it->second);
    1433           it->second->touch();
    1434         } else {
    1435           index.push_back(&skipper);
    1436         }
    1437         if (id == "label") {
    1438           inverter.reset(index.back()->getInverter());
    1439           index.back() = inverter.get();
    1440         }
    1441       }
    1442       for (typename MapReaders::iterator it = readers.begin();
    1443            it != readers.end(); ++it) {
    1444         if (!it->second->touched()) {
    1445           ErrorMessage msg;
    1446           msg << "Map not found in file: " << it->first;
    1447           throw IoParameterError(msg.message());
    1448         }
     1430      {
     1431        getline(is, line);
     1432        std::istringstream ls(line);   
     1433        std::string id;
     1434        while (ls >> id) {
     1435          typename MapReaders::iterator it = readers.find(id);
     1436          if (it != readers.end()) {
     1437            index.push_back(it->second);
     1438            it->second->touch();
     1439          } else {
     1440            index.push_back(&skipper);
     1441          }
     1442          if (id == "label") {
     1443            inverter.reset(index.back()->getInverter());
     1444            index.back() = inverter.get();
     1445          }
     1446        }
     1447        for (typename MapReaders::iterator it = readers.begin();
     1448             it != readers.end(); ++it) {
     1449          if (!it->second->touched()) {
     1450            ErrorMessage msg;
     1451            msg << "Map not found in file: " << it->first;
     1452            throw IoParameterError(msg.message());
     1453          }
     1454        }
    14491455      }
    14501456      while (getline(is, line)) {       
    … …  
    14531459        Node to = nodeLabelReader->read(ls);
    14541460        UEdge edge = graph.addEdge(from, to);
    1455         for (int i = 0; i < (int)index.size(); ++i) {
     1461        for (int i = 0; i < int(index.size()); ++i) {
    14561462          index[i]->read(ls, edge);
    14571463        }
    … …  
    15641570    ///
    15651571    /// Add a node reader command for the NodeReader.
    1566     void readNode(const std::string& name, Node& item) {
    1567       if (readers.find(name) != readers.end()) {
     1572    void readNode(std::string label, Node& item) {
     1573      if (readers.find(label) != readers.end()) {
    15681574        ErrorMessage msg;
    1569         msg << "Multiple read rule for node: " << name;
     1575        msg << "Multiple read rule for node: " << label;
    15701576        throw IoParameterError(msg.message());
    15711577      }
    1572       readers.insert(make_pair(name, _reader_bits::ItemStore<Node>(item)));
     1578      readers.insert(make_pair(label, _reader_bits::ItemStore<Node>(item)));
    15731579    }
    15741580
    … …  
    16771683    ///
    16781684    /// Add an edge reader command for the EdgeReader.
    1679     void readEdge(const std::string& name, Edge& item) {
    1680       if (readers.find(name) != readers.end()) {
     1685    void readEdge(std::string label, Edge& item) {
     1686      if (readers.find(label) != readers.end()) {
    16811687        ErrorMessage msg;
    1682         msg << "Multiple read rule for edge: " << name;
     1688        msg << "Multiple read rule for edge: " << label;
    16831689        throw IoParameterError(msg.message());
    16841690      }
    1685       readers.insert(make_pair(name, _reader_bits::ItemStore<Edge>(item)));
     1691      readers.insert(make_pair(label, _reader_bits::ItemStore<Edge>(item)));
    16861692    }
    16871693
    … …  
    17951801    ///
    17961802    /// Add an undirected edge reader command for the UEdgeReader.
    1797     void readUEdge(const std::string& name, UEdge& item) {
    1798       if (uEdgeReaders.find(name) != uEdgeReaders.end()) {
     1803    void readUEdge(std::string label, UEdge& item) {
     1804      if (uEdgeReaders.find(label) != uEdgeReaders.end()) {
    17991805        ErrorMessage msg;
    1800         msg << "Multiple read rule for undirected edge: " << name;
     1806        msg << "Multiple read rule for undirected edge: " << label;
    18011807        throw IoParameterError(msg.message());
    18021808      }
    1803       uEdgeReaders.insert(make_pair(name, _reader_bits::
     1809      uEdgeReaders.insert(make_pair(label, _reader_bits::
    18041810                                        ItemStore<UEdge>(item)));
    18051811    }
    … …  
    18081814    ///
    18091815    /// Add an edge reader command for the UEdgeReader.
    1810     void readEdge(const std::string& name, Edge& item) {
    1811       if (edgeReaders.find(name) != edgeReaders.end()) {
     1816    void readEdge(std::string label, Edge& item) {
     1817      if (edgeReaders.find(label) != edgeReaders.end()) {
    18121818        ErrorMessage msg;
    1813         msg << "Multiple read rule for edge: " << name;
     1819        msg << "Multiple read rule for edge: " << label;
    18141820        throw IoParameterError(msg.message());
    18151821      }
    1816       edgeReaders.insert(make_pair(name, _reader_bits::ItemStore<Edge>(item)));
     1822      edgeReaders.insert(make_pair(label, _reader_bits::ItemStore<Edge>(item)));
    18171823    }
    18181824
    … …  
    19541960    ///
    19551961    /// Add an attribute reader command for the reader.
    1956     template <typename Reader, typename Value>
    1957     AttributeReader& readAttribute(const std::string& name, Value& value,
    1958                                    const Reader& reader = Reader()) {
    1959       checkConcept<_reader_bits::ItemReader<Value>, Reader>();
    1960       if (readers.find(name) != readers.end()) {
     1962    template <typename ItemReader, typename Value>
     1963    AttributeReader& readAttribute(std::string label, Value& value,
     1964                                   const ItemReader& ir = ItemReader()) {
     1965      checkConcept<_reader_bits::ItemReader<Value>, ItemReader>();
     1966      if (readers.find(label) != readers.end()) {
    19611967        ErrorMessage msg;
    1962         msg << "Multiple read rule for attribute: " << name;
     1968        msg << "Multiple read rule for attribute: " << label;
    19631969        throw IoParameterError(msg.message());
    19641970      }
    1965       readers.insert(make_pair(name, new _reader_bits::
    1966                                ValueReader<Value, Reader>(value, reader)));
     1971      readers.insert(make_pair(label, new _reader_bits::
     1972                               ValueReader<Value, ItemReader>(value, ir)));
    19671973      return *this;
    19681974    }
Note: See TracChangeset for help on using the changeset viewer.