lemon-0.x: src/hugo/sym_map_factory.h@88226d9fe821

     1 // -*- c++ -*-

     2 #ifndef SYM_MAP_FACTORY_H

     3 #define SYM_MAP_FACTORY_H

     5 namespace hugo {

     7   template <typename Graph, typename Edge, typename EdgeIt>

     8   class SymEdgeIt : public EdgeIt {

     9   public:

    11     SymEdgeIt()

    12       : EdgeIt() {}

    14     SymEdgeIt(const Graph& graph)

    15       : EdgeIt(graph) {

    16       while ( n != -1 && (n & 1)) {

    17 	EdgeIt::operator++();

    18       }

    19     }

    21     SymEdgeIt(Invalid invalid)

    22       : EdgeIt(invalid) {}

    24     SymEdgeIt(const Graph& graph, Edge edge)

    25       : EdgeIt(graph, edge) {}

    27     SymEdgeIt& operator++() {

    28       EdgeIt::operator++();

    29       while ( n != -1 && (n & 1)) {

    30 	EdgeIt::operator++();

    31       }

    32       return *this;

    33     }

    34   };

    36   template <typename MapRegistry, template <typename> class MapFactory>

    37   class SymMapFactory {

    39   public:

    41     typedef typename MapRegistry::Graph Graph;

    42     typedef typename MapRegistry::KeyType KeyType;

    43     typedef typename MapRegistry::KeyIt KeyIt;

    45     typedef typename MapRegistry::MapBase MapBase;

    47     template <typename V>

    48     class Map : public MapFactory<MapRegistry>::template Map<V> {

    50       typedef typename MapFactory<MapRegistry>::template Map<V> MapImpl;

    51     public:

    53       typedef V Value;

    55       Map() : MapImpl() {}

    57       Map(const Graph& g, MapRegistry& r) : MapImpl(g, r) {}

    59       Map(const Graph& g, MapRegistry& r, const Value& v)

    60 	: MapImpl(g, r, v) {}

    62       Map(const Map& copy) : MapImpl(static_cast<const MapImpl&>(copy)) {}

    64       template <typename CMap> Map(const CMap& copy) : MapImpl(copy) {}

    66       Map& operator=(const Map& copy) {

    67 	MapImpl::operator=(static_cast<const MapImpl&>(copy));

    68 	return *this;

    69       }

    71       template <typename CMap> Map& operator=(const CMap& copy) {

    72 	MapImpl::operator=(copy);

    73 	return *this;

    74       }

    76       Value& operator[](const KeyType& key) {

    77 	int id = MapBase::getGraph()->id(key);

    78 	return MapImpl::operator[](id >> 1);

    79       }

    81       const Value& operator[](const KeyType& key) const {

    82 	int id = MapBase::getGraph()->id(key);

    83 	return MapImpl::operator[](id >> 1);

    84       }

    86       const Value& get(const KeyType& key) const {

    87 	int id = MapBase::getGraph()->id(key);

    88 	return MapImpl::operator[](id >> 1);

    89       }

    91       void set(const KeyType& key, const Value& val) {

    92 	int id = MapBase::getGraph()->id(key);

    93 	MapImpl::operator[](id >> 1) = val;

    94       }

    96       void add(const KeyType& key) {

    97 	int id = MapBase::getGraph()->id(key);

    98 	if (id & 1) return;

    99 	MapImpl::add(key);

   100       }

   102       void erase(const KeyType& key) {

   103 	int id = MapBase::getGraph()->id(key);

   104 	if (id & 1) return;

   105 	MapImpl::add(key);

   106       }

   109     };

   110   };

   111 }

   112 #endif

author	deba
	Wed, 08 Sep 2004 12:06:45 +0000
changeset 822	88226d9fe821
parent 786	d7b3b13b9df6
permissions	-rw-r--r--