lemon-0.x: lemon/bits/map_extender.h@216c6bd5c18c

     1 /* -*- C++ -*-

     2  *

     3  * This file is a part of LEMON, a generic C++ optimization library

     4  *

     5  * Copyright (C) 2003-2007

     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).

     8  *

     9  * Permission to use, modify and distribute this software is granted

    10  * provided that this copyright notice appears in all copies. For

    11  * precise terms see the accompanying LICENSE file.

    12  *

    13  * This software is provided "AS IS" with no warranty of any kind,

    14  * express or implied, and with no claim as to its suitability for any

    15  * purpose.

    16  *

    17  */

    19 #ifndef LEMON_BITS_MAP_EXTENDER_H

    20 #define LEMON_BITS_MAP_EXTENDER_H

    22 #include <iterator>

    24 #include <lemon/bits/traits.h>

    26 #include <lemon/concept_check.h>

    27 #include <lemon/concepts/maps.h>

    29 ///\file

    30 ///\brief Extenders for iterable maps.

    32 namespace lemon {

    34   /// \ingroup graphbits

    35   ///

    36   /// \brief Extender for maps

    37   template <typename _Map>

    38   class MapExtender : public _Map {

    39   public:

    41     typedef _Map Parent;

    42     typedef MapExtender Map;

    45     typedef typename Parent::Graph Graph;

    46     typedef typename Parent::Key Item;

    48     typedef typename Parent::Key Key;

    49     typedef typename Parent::Value Value;

    51     class MapIt;

    52     class ConstMapIt;

    54     friend class MapIt;

    55     friend class ConstMapIt;

    57   public:

    59     MapExtender(const Graph& graph)

    60       : Parent(graph) {}

    62     MapExtender(const Graph& graph, const Value& value)

    63       : Parent(graph, value) {}

    65     MapExtender& operator=(const MapExtender& cmap) {

    66       return operator=<MapExtender>(cmap);

    67     }

    69     template <typename CMap>

    70     MapExtender& operator=(const CMap& cmap) {

    71       Parent::operator=(cmap);

    72       return *this;

    73     }

    75     class MapIt : public Item {

    76     public:

    78       typedef Item Parent;

    79       typedef typename Map::Value Value;

    81       MapIt() {}

    83       MapIt(Invalid i) : Parent(i) { }

    85       explicit MapIt(Map& _map) : map(_map) {

    86         map.notifier()->first(*this);

    87       }

    89       MapIt(const Map& _map, const Item& item)

    90 	: Parent(item), map(_map) {}

    92       MapIt& operator++() {

    93 	map.notifier()->next(*this);

    94 	return *this;

    95       }

    97       typename MapTraits<Map>::ConstReturnValue operator*() const {

    98 	return map[*this];

    99       }

   101       typename MapTraits<Map>::ReturnValue operator*() {

   102 	return map[*this];

   103       }

   105       void set(const Value& value) {

   106 	map.set(*this, value);

   107       }

   109     protected:

   110       Map& map;

   112     };

   114     class ConstMapIt : public Item {

   115     public:

   117       typedef Item Parent;

   119       typedef typename Map::Value Value;

   121       ConstMapIt() {}

   123       ConstMapIt(Invalid i) : Parent(i) { }

   125       explicit ConstMapIt(Map& _map) : map(_map) {

   126         map.notifier()->first(*this);

   127       }

   129       ConstMapIt(const Map& _map, const Item& item)

   130 	: Parent(item), map(_map) {}

   132       ConstMapIt& operator++() {

   133 	map.notifier()->next(*this);

   134 	return *this;

   135       }

   137       typename MapTraits<Map>::ConstReturnValue operator*() const {

   138 	return map[*this];

   139       }

   141     protected:

   142       const Map& map;

   143     };

   145     class ItemIt : public Item {

   146     public:

   148       typedef Item Parent;

   150       ItemIt() {}

   152       ItemIt(Invalid i) : Parent(i) { }

   154       explicit ItemIt(Map& _map) : map(_map) {

   155         map.notifier()->first(*this);

   156       }

   158       ItemIt(const Map& _map, const Item& item)

   159 	: Parent(item), map(_map) {}

   161       ItemIt& operator++() {

   162 	map.notifier()->next(*this);

   163 	return *this;

   164       }

   166     protected:

   167       const Map& map;

   169     };

   170   };

   172   /// \ingroup graphbits

   173   ///

   174   /// \brief Extender for maps which use a subset of the items.

   175   template <typename _Graph, typename _Map>

   176   class SubMapExtender : public _Map {

   177   public:

   179     typedef _Map Parent;

   180     typedef SubMapExtender Map;

   182     typedef _Graph Graph;

   184     typedef typename Parent::Key Item;

   186     typedef typename Parent::Key Key;

   187     typedef typename Parent::Value Value;

   189     class MapIt;

   190     class ConstMapIt;

   192     friend class MapIt;

   193     friend class ConstMapIt;

   195   public:

   197     SubMapExtender(const Graph& _graph)

   198       : Parent(_graph), graph(_graph) {}

   200     SubMapExtender(const Graph& _graph, const Value& _value)

   201       : Parent(_graph, _value), graph(_graph) {}

   203     SubMapExtender& operator=(const SubMapExtender& cmap) {

   204       return operator=<MapExtender>(cmap);

   205     }

   207     template <typename CMap>

   208     SubMapExtender& operator=(const CMap& cmap) {

   209       checkConcept<concepts::ReadMap<Key, Value>, CMap>();

   210       Item it;

   211       for (graph.first(it); it != INVALID; graph.next(it)) {

   212         Parent::set(it, cmap[it]);

   213       }

   214       return *this;

   215     }

   217     class MapIt : public Item {

   218     public:

   220       typedef Item Parent;

   221       typedef typename Map::Value Value;

   223       MapIt() {}

   225       MapIt(Invalid i) : Parent(i) { }

   227       explicit MapIt(Map& _map) : map(_map) {

   228         map.graph.first(*this);

   229       }

   231       MapIt(const Map& _map, const Item& item)

   232 	: Parent(item), map(_map) {}

   234       MapIt& operator++() {

   235 	map.graph.next(*this);

   236 	return *this;

   237       }

   239       typename MapTraits<Map>::ConstReturnValue operator*() const {

   240 	return map[*this];

   241       }

   243       typename MapTraits<Map>::ReturnValue operator*() {

   244 	return map[*this];

   245       }

   247       void set(const Value& value) {

   248 	map.set(*this, value);

   249       }

   251     protected:

   252       Map& map;

   254     };

   256     class ConstMapIt : public Item {

   257     public:

   259       typedef Item Parent;

   261       typedef typename Map::Value Value;

   263       ConstMapIt() {}

   265       ConstMapIt(Invalid i) : Parent(i) { }

   267       explicit ConstMapIt(Map& _map) : map(_map) {

   268         map.graph.first(*this);

   269       }

   271       ConstMapIt(const Map& _map, const Item& item)

   272 	: Parent(item), map(_map) {}

   274       ConstMapIt& operator++() {

   275 	map.graph.next(*this);

   276 	return *this;

   277       }

   279       typename MapTraits<Map>::ConstReturnValue operator*() const {

   280 	return map[*this];

   281       }

   283     protected:

   284       const Map& map;

   285     };

   287     class ItemIt : public Item {

   288     public:

   290       typedef Item Parent;

   292       ItemIt() {}

   294       ItemIt(Invalid i) : Parent(i) { }

   296       explicit ItemIt(Map& _map) : map(_map) {

   297         map.graph.first(*this);

   298       }

   300       ItemIt(const Map& _map, const Item& item)

   301 	: Parent(item), map(_map) {}

   303       ItemIt& operator++() {

   304 	map.graph.next(*this);

   305 	return *this;

   306       }

   308     protected:

   309       const Map& map;

   311     };

   313   private:

   315     const Graph& graph;

   317   };

   319 }

   321 #endif

author	deba
	Tue, 30 Oct 2007 20:44:53 +0000
changeset 2506	216c6bd5c18c
parent 2384	805c5a2a36dd
child 2553	bfced05fa852
permissions	-rw-r--r--