COIN-OR::LEMON - Graph Library

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


Ignore:
Timestamp:
03/02/07 19:04:28 (13 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/graph_reader.h

    r2334 r2386  
    185185    ///
    186186    /// Give a new node map reading command to the reader.
    187     template <typename Reader, typename Map>
     187    template <typename ItemReader, typename Map>
    188188    GraphReader& readNodeMap(std::string name, Map& map,
    189                              const Reader& reader = Reader()) {
    190       nodeset_reader.readNodeMap(name, map, reader);
    191       return *this;
    192     }
    193 
    194     template <typename Reader, typename Map>
     189                             const ItemReader& ir = ItemReader()) {
     190      nodeset_reader.readNodeMap(name, map, ir);
     191      return *this;
     192    }
     193
     194    template <typename ItemReader, typename Map>
    195195    GraphReader& readNodeMap(std::string name, const Map& map,
    196                              const Reader& reader = Reader()) {
    197       nodeset_reader.readNodeMap(name, map, reader);
     196                             const ItemReader& ir = ItemReader()) {
     197      nodeset_reader.readNodeMap(name, map, ir);
    198198      return *this;
    199199    }
     
    202202    ///
    203203    /// Give a new node map skipping command to the reader.
    204     template <typename Reader>
     204    template <typename ItemReader>
    205205    GraphReader& skipNodeMap(std::string name,
    206                              const Reader& reader = Reader()) {
    207       nodeset_reader.skipNodeMap(name, reader);
     206                             const ItemReader& ir = ItemReader()) {
     207      nodeset_reader.skipNodeMap(name, ir);
    208208      return *this;
    209209    }
     
    228228    ///
    229229    /// Give a new edge map reading command to the reader.
    230     template <typename Reader, typename Map>
     230    template <typename ItemReader, typename Map>
    231231    GraphReader& readEdgeMap(std::string name, Map& map,
    232                              const Reader& reader = Reader()) {
    233       edgeset_reader.readEdgeMap(name, map, reader);
    234       return *this;
    235     }
    236 
    237     template <typename Reader, typename Map>
     232                             const ItemReader& ir = ItemReader()) {
     233      edgeset_reader.readEdgeMap(name, map, ir);
     234      return *this;
     235    }
     236
     237    template <typename ItemReader, typename Map>
    238238    GraphReader& readEdgeMap(std::string name, const Map& map,
    239                              const Reader& reader = Reader()) {
    240       edgeset_reader.readEdgeMap(name, map, reader);
     239                             const ItemReader& ir = ItemReader()) {
     240      edgeset_reader.readEdgeMap(name, map, ir);
    241241      return *this;
    242242    }
     
    245245    ///
    246246    /// Give a new edge map skipping command to the reader.
    247     template <typename Reader>
     247    template <typename ItemReader>
    248248    GraphReader& skipEdgeMap(std::string name,
    249                              const Reader& reader = Reader()) {
    250       edgeset_reader.skipEdgeMap(name, reader);
     249                             const ItemReader& ir = ItemReader()) {
     250      edgeset_reader.skipEdgeMap(name, ir);
    251251      return *this;
    252252    }
     
    280280    ///
    281281    ///  Give a new attribute reading command.
    282     template <typename Reader, typename Value>
     282    template <typename ItemReader, typename Value>
    283283    GraphReader& readAttribute(std::string name, Value& value,
    284                                const Reader& reader) {
    285       attribute_reader.readAttribute<Reader>(name, value, reader);
     284                               const ItemReader& ir = ItemReader()) {
     285      attribute_reader.readAttribute(name, value, ir);
    286286      return *this;
    287287    }
     
    505505    ///
    506506    /// Give a new node map reading command to the reader.
    507     template <typename Reader, typename Map>
     507    template <typename ItemReader, typename Map>
    508508    UGraphReader& readNodeMap(std::string name, Map& map,
    509                                   const Reader& reader = Reader()) {
    510       nodeset_reader.readNodeMap(name, map, reader);
    511       return *this;
    512     }
    513 
    514     template <typename Reader, typename Map>
     509                              const ItemReader& ir = ItemReader()) {
     510      nodeset_reader.readNodeMap(name, map, ir);
     511      return *this;
     512    }
     513
     514    template <typename ItemReader, typename Map>
    515515    UGraphReader& readNodeMap(std::string name, const Map& map,
    516                                   const Reader& reader = Reader()) {
    517       nodeset_reader.readNodeMap(name, map, reader);
     516                              const ItemReader& ir = ItemReader()) {
     517      nodeset_reader.readNodeMap(name, map, ir);
    518518      return *this;
    519519    }
     
    522522    ///
    523523    /// Give a new node map skipping command to the reader.
    524     template <typename Reader>
     524    template <typename ItemReader>
    525525    UGraphReader& skipNodeMap(std::string name,
    526                              const Reader& reader = Reader()) {
    527       nodeset_reader.skipNodeMap(name, reader);
     526                              const ItemReader& ir = ItemReader()) {
     527      nodeset_reader.skipNodeMap(name, ir);
    528528      return *this;
    529529    }
     
    548548    ///
    549549    /// Give a new undirected edge map reading command to the reader.
    550     template <typename Reader, typename Map>
     550    template <typename ItemReader, typename Map>
    551551    UGraphReader& readUEdgeMap(std::string name, Map& map,
    552                                        const Reader& reader = Reader()) {
    553       u_edgeset_reader.readUEdgeMap(name, map, reader);
    554       return *this;
    555     }
    556 
    557     template <typename Reader, typename Map>
     552                               const ItemReader& ir = ItemReader()) {
     553      u_edgeset_reader.readUEdgeMap(name, map, ir);
     554      return *this;
     555    }
     556
     557    template <typename ItemReader, typename Map>
    558558    UGraphReader& readUEdgeMap(std::string name, const Map& map,
    559                                        const Reader& reader = Reader()) {
    560       u_edgeset_reader.readUEdgeMap(name, map, reader);
     559                               const ItemReader& ir = ItemReader()) {
     560      u_edgeset_reader.readUEdgeMap(name, map, ir);
    561561      return *this;
    562562    }
     
    565565    ///
    566566    /// Give a new undirected edge map skipping command to the reader.
    567     template <typename Reader>
     567    template <typename ItemReader>
    568568    UGraphReader& skipUEdgeMap(std::string name,
    569                                        const Reader& reader = Reader()) {
    570       u_edgeset_reader.skipUMap(name, reader);
     569                                       const ItemReader& ir = ItemReader()) {
     570      u_edgeset_reader.skipUMap(name, ir);
    571571      return *this;
    572572    }
     
    592592    ///
    593593    /// Give a new edge map reading command to the reader.
    594     template <typename Reader, typename Map>
     594    template <typename ItemReader, typename Map>
    595595    UGraphReader& readEdgeMap(std::string name, Map& map,
    596                                        const Reader& reader = Reader()) {
    597       u_edgeset_reader.readEdgeMap(name, map, reader);
    598       return *this;
    599     }
    600 
    601     template <typename Reader, typename Map>
     596                              const ItemReader& ir = ItemReader()) {
     597      u_edgeset_reader.readEdgeMap(name, map, ir);
     598      return *this;
     599    }
     600
     601    template <typename ItemReader, typename Map>
    602602    UGraphReader& readEdgeMap(std::string name, const Map& map,
    603                                        const Reader& reader = Reader()) {
    604       u_edgeset_reader.readEdgeMap(name, map, reader);
     603                              const ItemReader& ir = ItemReader()) {
     604      u_edgeset_reader.readEdgeMap(name, map, ir);
    605605      return *this;
    606606    }
     
    609609    ///
    610610    /// Give a new edge map skipping command to the reader.
    611     template <typename Reader>
     611    template <typename ItemReader>
    612612    UGraphReader& skipEdgeMap(std::string name,
    613                                        const Reader& reader = Reader()) {
    614       u_edgeset_reader.skipEdgeMap(name, reader);
     613                              const ItemReader& ir = ItemReader()) {
     614      u_edgeset_reader.skipEdgeMap(name, ir);
    615615      return *this;
    616616    }
     
    651651    ///
    652652    ///  Give a new attribute reading command.
    653     template <typename Reader, typename Value>
     653    template <typename ItemReader, typename Value>
    654654    UGraphReader& readAttribute(std::string name, Value& value,
    655                                const Reader& reader) {
    656       attribute_reader.readAttribute<Reader>(name, value, reader);
     655                               const ItemReader& ir = ItemReader()) {
     656      attribute_reader.readAttribute(name, value, ir);
    657657      return *this;
    658658    }
Note: See TracChangeset for help on using the changeset viewer.