COIN-OR::LEMON - Graph Library

Changeset 2467:2025a571895e in lemon-0.x for lemon/graph_reader.h


Ignore:
Timestamp:
08/28/07 16:00:42 (12 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3305
Message:

PathNodeIt?

PathWriter/Reader? structures
Distinict MapSet? readers and writers

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/graph_reader.h

    r2391 r2467  
    325325    /// it. It is possible only if there was read a "label" named edge map.
    326326    void readLabel(std::istream& is, Edge& edge) const {
    327       return edgeset_reader.readLabel(is, edge);
     327      edgeset_reader.readLabel(is, edge);
    328328    }
    329329
     
    444444      : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper),
    445445        nodeset_reader(*reader, _graph, std::string(), skipper),
    446         u_edgeset_reader(*reader, _graph, nodeset_reader,
     446        uedgeset_reader(*reader, _graph, nodeset_reader,
    447447                             std::string(), skipper),
    448448        node_reader(*reader, nodeset_reader, std::string()),
    449         u_edge_reader(*reader, u_edgeset_reader, std::string()),
     449        uedge_reader(*reader, uedgeset_reader, std::string()),
    450450        attribute_reader(*reader, std::string()) {}
    451451
     
    459459        skipper(_skipper),
    460460        nodeset_reader(*reader, _graph, std::string(), skipper),
    461         u_edgeset_reader(*reader, _graph, nodeset_reader,
     461        uedgeset_reader(*reader, _graph, nodeset_reader,
    462462                             std::string(), skipper),
    463463        node_reader(*reader, nodeset_reader, std::string()),
    464         u_edge_reader(*reader, u_edgeset_reader, std::string()),
     464        uedge_reader(*reader, uedgeset_reader, std::string()),
    465465        attribute_reader(*reader, std::string()) {}
    466466
     
    473473      : reader(_reader), own_reader(false), skipper(_skipper),
    474474        nodeset_reader(*reader, _graph, std::string(), skipper),
    475         u_edgeset_reader(*reader, _graph, nodeset_reader,
     475        uedgeset_reader(*reader, _graph, nodeset_reader,
    476476                             std::string(), skipper),
    477477        node_reader(*reader, nodeset_reader, std::string()),
    478         u_edge_reader(*reader, u_edgeset_reader, std::string()),
     478        uedge_reader(*reader, uedgeset_reader, std::string()),
    479479        attribute_reader(*reader, std::string()) {}
    480480
     
    534534    template <typename Map>
    535535    UGraphReader& readUEdgeMap(std::string name, Map& map) {
    536       u_edgeset_reader.readUEdgeMap(name, map);
     536      uedgeset_reader.readUEdgeMap(name, map);
    537537      return *this;
    538538    }
     
    540540    template <typename Map>
    541541    UGraphReader& readUEdgeMap(std::string name, const Map& map) {
    542       u_edgeset_reader.readUEdgeMap(name, map);
     542      uedgeset_reader.readUEdgeMap(name, map);
    543543      return *this;
    544544    }
     
    551551    UGraphReader& readUEdgeMap(std::string name, Map& map,
    552552                               const ItemReader& ir = ItemReader()) {
    553       u_edgeset_reader.readUEdgeMap(name, map, ir);
     553      uedgeset_reader.readUEdgeMap(name, map, ir);
    554554      return *this;
    555555    }
     
    558558    UGraphReader& readUEdgeMap(std::string name, const Map& map,
    559559                               const ItemReader& ir = ItemReader()) {
    560       u_edgeset_reader.readUEdgeMap(name, map, ir);
     560      uedgeset_reader.readUEdgeMap(name, map, ir);
    561561      return *this;
    562562    }
     
    568568    UGraphReader& skipUEdgeMap(std::string name,
    569569                                       const ItemReader& ir = ItemReader()) {
    570       u_edgeset_reader.skipUMap(name, ir);
     570      uedgeset_reader.skipUMap(name, ir);
    571571      return *this;
    572572    }
     
    578578    template <typename Map>
    579579    UGraphReader& readEdgeMap(std::string name, Map& map) {
    580       u_edgeset_reader.readEdgeMap(name, map);
     580      uedgeset_reader.readEdgeMap(name, map);
    581581      return *this;
    582582    }
     
    584584    template <typename Map>
    585585    UGraphReader& readEdgeMap(std::string name, const Map& map) {
    586       u_edgeset_reader.readEdgeMap(name, map);
     586      uedgeset_reader.readEdgeMap(name, map);
    587587      return *this;
    588588    }
     
    595595    UGraphReader& readEdgeMap(std::string name, Map& map,
    596596                              const ItemReader& ir = ItemReader()) {
    597       u_edgeset_reader.readEdgeMap(name, map, ir);
     597      uedgeset_reader.readEdgeMap(name, map, ir);
    598598      return *this;
    599599    }
     
    602602    UGraphReader& readEdgeMap(std::string name, const Map& map,
    603603                              const ItemReader& ir = ItemReader()) {
    604       u_edgeset_reader.readEdgeMap(name, map, ir);
     604      uedgeset_reader.readEdgeMap(name, map, ir);
    605605      return *this;
    606606    }
     
    612612    UGraphReader& skipEdgeMap(std::string name,
    613613                              const ItemReader& ir = ItemReader()) {
    614       u_edgeset_reader.skipEdgeMap(name, ir);
     614      uedgeset_reader.skipEdgeMap(name, ir);
    615615      return *this;
    616616    }
     
    628628    /// Give a new labeled edge reading command to the reader.
    629629    UGraphReader& readEdge(std::string name, Edge& edge) {
    630       u_edge_reader.readEdge(name, edge);
     630      uedge_reader.readEdge(name, edge);
    631631    }
    632632
     
    636636    /// Give a new labeled undirected edge reading command to the reader.
    637637    UGraphReader& readUEdge(std::string name, UEdge& edge) {
    638       u_edge_reader.readUEdge(name, edge);
     638      uedge_reader.readUEdge(name, edge);
    639639    }
    640640
     
    678678    /// \brief Returns true if the reader can give back the items by its label.
    679679    ///
    680     /// \brief Returns true if the reader can give back the items by its label.
     680    /// Returns true if the reader can give back the items by its label.
    681681    bool isLabelReader() const {
    682682      return nodeset_reader.isLabelReader() &&
    683         u_edgeset_reader.isLabelReader();
     683        uedgeset_reader.isLabelReader();
    684684    }
    685685
     
    697697    /// it. It is possible only if there was read a "label" named edge map.
    698698    void readLabel(std::istream& is, Edge& edge) const {
    699       return u_edgeset_reader.readLabel(is, edge);
     699      return uedgeset_reader.readLabel(is, edge);
    700700    }
    701701
     
    706706    /// edge map.
    707707    void readLabel(std::istream& is, UEdge& uedge) const {
    708       return u_edgeset_reader.readLabel(is, uedge);
     708      return uedgeset_reader.readLabel(is, uedge);
    709709    }
    710710   
     
    718718
    719719    NodeSetReader<Graph, ReaderTraits> nodeset_reader;
    720     UEdgeSetReader<Graph, ReaderTraits> u_edgeset_reader;
     720    UEdgeSetReader<Graph, ReaderTraits> uedgeset_reader;
    721721
    722722    NodeReader<Graph> node_reader;
    723     UEdgeReader<Graph> u_edge_reader;
     723    UEdgeReader<Graph> uedge_reader;
    724724   
    725725    AttributeReader<ReaderTraits> attribute_reader;
Note: See TracChangeset for help on using the changeset viewer.