lemon-1.1: lemon/bits/map_extender.h@33c6b6e755cd

     1 /* -*- mode: C++; indent-tabs-mode: nil; -*-

     2  *

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

     4  *

     5  * Copyright (C) 2003-2009

     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;

    50     typedef typename Parent::Reference Reference;

    51     typedef typename Parent::ConstReference ConstReference;

    53     class MapIt;

    54     class ConstMapIt;

    56     friend class MapIt;

    57     friend class ConstMapIt;

    59   public:

    61     MapExtender(const Graph& graph)

    62       : Parent(graph) {}

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

    65       : Parent(graph, value) {}

    67   private:

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

    69       return operator=<MapExtender>(cmap);

    70     }

    72     template <typename CMap>

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

    74       Parent::operator=(cmap);

    75       return *this;

    76     }

    78   public:

    79     class MapIt : public Item {

    80     public:

    82       typedef Item Parent;

    83       typedef typename Map::Value Value;

    85       MapIt() {}

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

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

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

    91       }

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

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

    96       MapIt& operator++() {

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

    98         return *this;

    99       }

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

   102         return map[*this];

   103       }

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

   106         return map[*this];

   107       }

   109       void set(const Value& value) {

   110         map.set(*this, value);

   111       }

   113     protected:

   114       Map& map;

   116     };

   118     class ConstMapIt : public Item {

   119     public:

   121       typedef Item Parent;

   123       typedef typename Map::Value Value;

   125       ConstMapIt() {}

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

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

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

   131       }

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

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

   136       ConstMapIt& operator++() {

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

   138         return *this;

   139       }

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

   142         return map[*this];

   143       }

   145     protected:

   146       const Map& map;

   147     };

   149     class ItemIt : public Item {

   150     public:

   152       typedef Item Parent;

   154       ItemIt() {}

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

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

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

   160       }

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

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

   165       ItemIt& operator++() {

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

   167         return *this;

   168       }

   170     protected:

   171       const Map& map;

   173     };

   174   };

   176   // \ingroup graphbits

   177   //

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

   179   template <typename _Graph, typename _Map>

   180   class SubMapExtender : public _Map {

   181   public:

   183     typedef _Map Parent;

   184     typedef SubMapExtender Map;

   186     typedef _Graph Graph;

   188     typedef typename Parent::Key Item;

   190     typedef typename Parent::Key Key;

   191     typedef typename Parent::Value Value;

   192     typedef typename Parent::Reference Reference;

   193     typedef typename Parent::ConstReference ConstReference;

   195     class MapIt;

   196     class ConstMapIt;

   198     friend class MapIt;

   199     friend class ConstMapIt;

   201   public:

   203     SubMapExtender(const Graph& _graph)

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

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

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

   209   private:

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

   211       return operator=<MapExtender>(cmap);

   212     }

   214     template <typename CMap>

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

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

   217       Item it;

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

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

   220       }

   221       return *this;

   222     }

   224   public:

   225     class MapIt : public Item {

   226     public:

   228       typedef Item Parent;

   229       typedef typename Map::Value Value;

   231       MapIt() {}

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

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

   236         map.graph.first(*this);

   237       }

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

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

   242       MapIt& operator++() {

   243         map.graph.next(*this);

   244         return *this;

   245       }

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

   248         return map[*this];

   249       }

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

   252         return map[*this];

   253       }

   255       void set(const Value& value) {

   256         map.set(*this, value);

   257       }

   259     protected:

   260       Map& map;

   262     };

   264     class ConstMapIt : public Item {

   265     public:

   267       typedef Item Parent;

   269       typedef typename Map::Value Value;

   271       ConstMapIt() {}

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

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

   276         map.graph.first(*this);

   277       }

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

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

   282       ConstMapIt& operator++() {

   283         map.graph.next(*this);

   284         return *this;

   285       }

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

   288         return map[*this];

   289       }

   291     protected:

   292       const Map& map;

   293     };

   295     class ItemIt : public Item {

   296     public:

   298       typedef Item Parent;

   300       ItemIt() {}

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

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

   305         map.graph.first(*this);

   306       }

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

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

   311       ItemIt& operator++() {

   312         map.graph.next(*this);

   313         return *this;

   314       }

   316     protected:

   317       const Map& map;

   319     };

   321   private:

   323     const Graph& graph;

   325   };

   327 }

   329 #endif

author	Peter Kovacs <kpeter@inf.elte.hu>
	Wed, 15 Apr 2009 02:04:37 +0200
changeset 576	33c6b6e755cd
parent 440	88ed40ad0d4f
child 609	4137ef9aacc6
permissions	-rw-r--r--