COIN-OR::LEMON - Graph Library

Changeset 1705:3f63d9db307b in lemon-0.x for lemon/lemon_reader.h


Ignore:
Timestamp:
10/05/05 15:18:51 (14 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2232
Message:

Removing smart references

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/lemon_reader.h

    r1627 r1705  
    3737#include <lemon/bits/item_reader.h>
    3838
     39#include <lemon/xy.h>
     40
    3941#include <lemon/concept_check.h>
    4042#include <lemon/concept/maps.h>
     
    9597    };
    9698
    97     template <typename M1, typename M2>
    98     class WriteComposeMap {
     99    template <typename Map>
     100    struct Ref { typedef Map& Type; };
     101    template <typename Map>
     102    struct Arg { typedef Map& Type; };
     103
     104    template <typename Graph, typename Map>
     105    class ForwardComposeMap {
    99106    public:
    100       typedef True NeedCopy;
     107      typedef typename Graph::UndirEdge Key;
     108      typedef typename Map::Value Value;
     109
     110      ForwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map)
     111        : graph(_graph), map(_map) {}
    101112     
    102       typedef typename M2::Key Key;
    103       typedef typename M1::Value Value;
    104 
    105       WriteComposeMap(typename SmartParameter<M1>::Type _m1, const M2& _m2)
    106         : m1(_m1), m2(_m2) {}
     113      void set(const Key& key, const Value& val) {
     114        map.set(graph.direct(key, true), val);
     115      }
     116
     117    private:
     118      typename Ref<Map>::Type map;
     119      const Graph& graph;
     120    };
     121
     122    template <typename Graph, typename Map>
     123    ForwardComposeMap<Graph, Map>
     124    forwardComposeMap(const Graph& graph, const Map& map) {
     125      return ForwardComposeMap<Graph, Map>(graph, map);
     126    }
     127
     128    template <typename Graph, typename Map>
     129    ForwardComposeMap<Graph, Map>
     130    forwardComposeMap(const Graph& graph, Map& map) {
     131      return ForwardComposeMap<Graph, Map>(graph, map);
     132    }
     133
     134    template <typename Graph, typename Map>
     135    class BackwardComposeMap {
     136    public:
     137      typedef typename Graph::UndirEdge Key;
     138      typedef typename Map::Value Value;
     139
     140      BackwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map)
     141        : graph(_graph), map(_map) {}
    107142     
    108       void set(const Key& key, const Value& value) {
    109         m1.set(m2[key], value);
     143      void set(const Key& key, const Value& val) {
     144        map.set(graph.direct(key, false), val);
    110145      }
    111146
    112147    private:
    113      
    114       typename SmartReference<M1>::Type m1;
    115       typename SmartConstReference<M2>::Type m2;
    116      
    117     };
    118 
    119     template <typename M1, typename M2>
    120     WriteComposeMap<M1, M2> writeComposeMap(M1& m1, const M2& m2) {
    121       return WriteComposeMap<M1, M2>(m1, m2);
    122     }
    123 
    124     template <typename M1, typename M2>
    125     WriteComposeMap<M1, M2> writeComposeMap(const M1& m1, const M2& m2) {
    126       return WriteComposeMap<M1, M2>(m1, m2);
    127     }
    128  
     148      typename Ref<Map>::Type map;
     149      const Graph& graph;
     150    };
     151
     152
     153    template <typename Graph, typename Map>
     154    BackwardComposeMap<Graph, Map>
     155    backwardComposeMap(const Graph& graph, const Map& map) {
     156      return BackwardComposeMap<Graph, Map>(graph, map);
     157    }
     158
     159    template <typename Graph, typename Map>
     160    BackwardComposeMap<Graph, Map>
     161    backwardComposeMap(const Graph& graph, Map& map) {
     162      return BackwardComposeMap<Graph, Map>(graph, map);
     163    }
     164
     165    template <typename Graph, typename Map>
     166    struct Ref<ForwardComposeMap<Graph, Map> > {
     167      typedef ForwardComposeMap<Graph, Map> Type;
     168    };
     169    template <typename Graph, typename Map>
     170    struct Arg<ForwardComposeMap<Graph, Map> > {
     171      typedef const ForwardComposeMap<Graph, Map>& Type;
     172    };
     173
     174    template <typename Graph, typename Map>
     175    struct Ref<BackwardComposeMap<Graph, Map> > {
     176      typedef BackwardComposeMap<Graph, Map> Type;
     177    };
     178    template <typename Graph, typename Map>
     179    struct Arg<BackwardComposeMap<Graph, Map> > {
     180      typedef const BackwardComposeMap<Graph, Map>& Type;
     181    };
     182
     183    template <typename Map>
     184    struct Ref<XMap<Map> > {
     185      typedef XMap<Map> Type;
     186    };
     187    template <typename Map>
     188    struct Arg<XMap<Map> > {
     189      typedef const XMap<Map>& Type;
     190    };
     191
     192    template <typename Map>
     193    struct Ref<YMap<Map> > {
     194      typedef YMap<Map> Type;
     195    };
     196    template <typename Map>
     197    struct Arg<YMap<Map> > {
     198      typedef const YMap<Map>& Type;
     199    };
     200
    129201  }
    130202
     
    433505      typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
    434506
    435       typename SmartReference<Map>::Type map;
     507      typename _reader_bits::Ref<Map>::Type map;
    436508      Reader reader;
    437509      Inverse inverse;
    438510
    439       MapReaderInverter(typename SmartParameter<Map>::Type _map,
     511      MapReaderInverter(typename _reader_bits::Arg<Map>::Type _map,
    440512                        const Reader& _reader)
    441513        : map(_map), reader(_reader) {}
     
    527599      typedef _Item Item;
    528600     
    529       typename SmartReference<Map>::Type map;
     601      typename _reader_bits::Ref<Map>::Type map;
    530602      Reader reader;
    531603
    532       MapReader(typename SmartParameter<Map>::Type _map,
     604      MapReader(typename _reader_bits::Arg<Map>::Type _map,
    533605                const Reader& _reader)
    534606        : map(_map), reader(_reader) {}
     
    660732    /// the section when the \c section_id and the \c _id are the same.
    661733    NodeSetReader(LemonReader& _reader,
    662                   typename SmartParameter<Graph>::Type _graph,
     734                  Graph& _graph,
    663735                  const std::string& _id = std::string(),
    664736                  const DefaultSkipper& _skipper = DefaultSkipper())
     
    689761      return _readMap<
    690762        typename Traits::template Reader<typename Map::Value>, Map,
    691         typename SmartParameter<Map>::Type>(name, map);
     763        typename _reader_bits::Arg<Map>::Type>(name, map);
    692764    }
    693765
     
    696768      return _readMap<
    697769        typename Traits::template Reader<typename Map::Value>, Map,
    698         typename SmartParameter<Map>::Type>(name, map);
     770        typename _reader_bits::Arg<Map>::Type>(name, map);
    699771    }
    700772
     
    705777    NodeSetReader& readNodeMap(std::string name, Map& map,
    706778                               const Reader& reader = Reader()) {
    707       return _readMap<Reader, Map, typename SmartParameter<Map>::Type>
     779      return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    708780        (name, map, reader);
    709781    }
     
    712784    NodeSetReader& readNodeMap(std::string name, const Map& map,
    713785                               const Reader& reader = Reader()) {
    714       return _readMap<Reader, Map, typename SmartParameter<Map>::Type>
     786      return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    715787        (name, map, reader);
    716788    }
     
    818890    MapReaders readers;
    819891   
    820     typename SmartReference<Graph>::Type graph;   
     892    Graph& graph;   
    821893    std::string id;
    822894    SkipReader<Node, DefaultSkipper> skipper;
     
    868940    template <typename NodeIdReader>
    869941    EdgeSetReader(LemonReader& _reader,
    870                   typename SmartParameter<Graph>::Type _graph,
     942                  Graph& _graph,
    871943                  const NodeIdReader& _nodeIdReader,
    872944                  const std::string& _id = std::string(),
     
    899971      return _readMap<
    900972        typename Traits::template Reader<typename Map::Value>, Map,
    901         typename SmartParameter<Map>::Type>(name, map);
     973        typename _reader_bits::Arg<Map>::Type>(name, map);
    902974    }
    903975
     
    906978      return _readMap<
    907979        typename Traits::template Reader<typename Map::Value>, Map,
    908         typename SmartParameter<Map>::Type>(name, map);
     980        typename _reader_bits::Arg<Map>::Type>(name, map);
    909981    }
    910982
     
    916988                           const Reader& reader = Reader()) {
    917989      return _readMap<Reader, Map,
    918         typename SmartParameter<Map>::Type>(name, map, reader);
     990        typename _reader_bits::Arg<Map>::Type>(name, map, reader);
    919991    }
    920992
     
    923995                               const Reader& reader = Reader()) {
    924996      return _readMap<Reader, Map,
    925         typename SmartParameter<Map>::Type>(name, map, reader);
     997        typename _reader_bits::Arg<Map>::Type>(name, map, reader);
    926998    }
    927999
     
    10331105    MapReaders readers;
    10341106   
    1035     typename SmartReference<Graph>::Type graph;   
     1107    Graph& graph;   
    10361108    std::string id;
    10371109    SkipReader<Edge, DefaultSkipper> skipper;
     
    10901162    template <typename NodeIdReader>
    10911163    UndirEdgeSetReader(LemonReader& _reader,
    1092                        typename SmartParameter<Graph>::Type _graph,
     1164                       Graph& _graph,
    10931165                       const NodeIdReader& _nodeIdReader,
    10941166                       const std::string& _id = std::string(),
     
    11211193      return _readMap<
    11221194        typename Traits::template Reader<typename Map::Value>, Map,
    1123         typename SmartParameter<Map>::Type>(name, map);
     1195        typename _reader_bits::Arg<Map>::Type>(name, map);
    11241196    }
    11251197
     
    11281200      return _readMap<
    11291201        typename Traits::template Reader<typename Map::Value>, Map,
    1130         typename SmartParameter<Map>::Type>(name, map);
     1202        typename _reader_bits::Arg<Map>::Type>(name, map);
    11311203    }
    11321204
     
    11371209    UndirEdgeSetReader& readUndirEdgeMap(std::string name, Map& map,
    11381210                                         const Reader& reader = Reader()) {
    1139       return _readMap<Reader, Map, typename SmartParameter<Map>::Type>
     1211      return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    11401212        (name, map, reader);
    11411213    }
     
    11441216    UndirEdgeSetReader& readUndirEdgeMap(std::string name, const Map& map,
    11451217                                         const Reader& reader = Reader()) {
    1146       return _readMap<Reader, Map, typename SmartParameter<Map>::Type >
     1218      return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type >
    11471219        (name, map, reader);
    11481220    }
     
    11901262      return _readDirMap<
    11911263        typename Traits::template Reader<typename Map::Value>, Map,
    1192         typename SmartParameter<Map>::Type>(name, map);
     1264        typename _reader_bits::Arg<Map>::Type>(name, map);
    11931265    }
    11941266
     
    11971269      return _readDirMap<
    11981270        typename Traits::template Reader<typename Map::Value>, Map,
    1199         typename SmartParameter<Map>::Type>(name, map);
     1271        typename _reader_bits::Arg<Map>::Type>(name, map);
    12001272    }
    12011273
     
    12061278    UndirEdgeSetReader& readEdgeMap(std::string name, Map& map,
    12071279                                    const Reader& reader = Reader()) {
    1208       return _readDirMap<Reader, Map, typename SmartParameter<Map>::Type>
     1280      return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    12091281        (name, map, reader);
    12101282    }
     
    12131285    UndirEdgeSetReader& readEdgeMap(std::string name, const Map& map,
    12141286                                    const Reader& reader = Reader()) {
    1215       return _readDirMap<Reader, Map, typename SmartParameter<Map>::Type>
     1287      return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
    12161288        (name, map, reader);
    12171289    }
     
    12251297      checkConcept<concept::WriteMap<Edge, typename Map::Value>, Map>();
    12261298      readMap("+" + name,
    1227               _reader_bits::writeComposeMap(map, forwardMap(graph)), reader);
     1299              _reader_bits::forwardComposeMap(graph, map), reader);
    12281300      readMap("-" + name,
    1229               _reader_bits::writeComposeMap(map, backwardMap(graph)), reader);
     1301              _reader_bits::backwardComposeMap(graph, map), reader);
    12301302      return *this;     
    12311303    }
     
    13371409    MapReaders readers;
    13381410   
    1339     typename SmartReference<Graph>::Type graph;   
     1411    Graph& graph;   
    13401412    std::string id;
    13411413    SkipReader<UndirEdge, DefaultSkipper> skipper;
Note: See TracChangeset for help on using the changeset viewer.