lemon-main: lemon/bits/map_extender.h@54464584b157

     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-2008

     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   private:

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

    67       return operator=<MapExtender>(cmap);

    68     }

    70     template <typename CMap>

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

    72       Parent::operator=(cmap);

    73       return *this;

    74     }

    76   public:

    77     class MapIt : public Item {

    78     public:

    80       typedef Item Parent;

    81       typedef typename Map::Value Value;

    83       MapIt() : map(NULL) {}

    85       MapIt(Invalid i) : Parent(i), map(NULL) {}

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

    88         map->notifier()->first(*this);

    89       }

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

    92         : Parent(item), map(&_map) {}

    94       MapIt& operator++() {

    95         map->notifier()->next(*this);

    96         return *this;

    97       }

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

   100         return (*map)[*this];

   101       }

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

   104         return (*map)[*this];

   105       }

   107       void set(const Value& value) {

   108         map->set(*this, value);

   109       }

   111     protected:

   112       Map* map;

   114     };

   116     class ConstMapIt : public Item {

   117     public:

   119       typedef Item Parent;

   121       typedef typename Map::Value Value;

   123       ConstMapIt() : map(NULL) {}

   125       ConstMapIt(Invalid i) : Parent(i), map(NULL) {}

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

   128         map->notifier()->first(*this);

   129       }

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

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

   134       ConstMapIt& operator++() {

   135         map->notifier()->next(*this);

   136         return *this;

   137       }

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

   140         return map[*this];

   141       }

   143     protected:

   144       const Map* map;

   145     };

   147     class ItemIt : public Item {

   148     public:

   150       typedef Item Parent;

   152       ItemIt() : map(NULL) {}

   154       ItemIt(Invalid i) : Parent(i), map(NULL) {}

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

   157         map->notifier()->first(*this);

   158       }

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

   161         : Parent(item), map(&_map) {}

   163       ItemIt& operator++() {

   164         map->notifier()->next(*this);

   165         return *this;

   166       }

   168     protected:

   169       const Map* map;

   171     };

   172   };

   174   // \ingroup graphbits

   175   //

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

   177   template <typename _Graph, typename _Map>

   178   class SubMapExtender : public _Map {

   179   public:

   181     typedef _Map Parent;

   182     typedef SubMapExtender Map;

   184     typedef _Graph Graph;

   186     typedef typename Parent::Key Item;

   188     typedef typename Parent::Key Key;

   189     typedef typename Parent::Value Value;

   191     class MapIt;

   192     class ConstMapIt;

   194     friend class MapIt;

   195     friend class ConstMapIt;

   197   public:

   199     SubMapExtender(const Graph& _graph)

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

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

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

   205   private:

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

   207       return operator=<MapExtender>(cmap);

   208     }

   210     template <typename CMap>

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

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

   213       Item it;

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

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

   216       }

   217       return *this;

   218     }

   220   public:

   221     class MapIt : public Item {

   222     public:

   224       typedef Item Parent;

   225       typedef typename Map::Value Value;

   227       MapIt() : map(NULL) {}

   229       MapIt(Invalid i) : Parent(i), map(NULL) { }

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

   232         map->graph.first(*this);

   233       }

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

   236         : Parent(item), map(&_map) {}

   238       MapIt& operator++() {

   239         map->graph.next(*this);

   240         return *this;

   241       }

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

   244         return (*map)[*this];

   245       }

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

   248         return (*map)[*this];

   249       }

   251       void set(const Value& value) {

   252         map->set(*this, value);

   253       }

   255     protected:

   256       Map* map;

   258     };

   260     class ConstMapIt : public Item {

   261     public:

   263       typedef Item Parent;

   265       typedef typename Map::Value Value;

   267       ConstMapIt() : map(NULL) {}

   269       ConstMapIt(Invalid i) : Parent(i), map(NULL) { }

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

   272         map->graph.first(*this);

   273       }

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

   276         : Parent(item), map(&_map) {}

   278       ConstMapIt& operator++() {

   279         map->graph.next(*this);

   280         return *this;

   281       }

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

   284         return (*map)[*this];

   285       }

   287     protected:

   288       const Map* map;

   289     };

   291     class ItemIt : public Item {

   292     public:

   294       typedef Item Parent;

   296       ItemIt() : map(NULL) {}

   298       ItemIt(Invalid i) : Parent(i), map(NULL) { }

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

   301         map->graph.first(*this);

   302       }

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

   305         : Parent(item), map(&_map) {}

   307       ItemIt& operator++() {

   308         map->graph.next(*this);

   309         return *this;

   310       }

   312     protected:

   313       const Map* map;

   315     };

   317   private:

   319     const Graph& graph;

   321   };

   323 }

   325 #endif

author	Alpar Juttner <alpar@cs.elte.hu>
	Tue, 02 Aug 2011 18:13:34 +0200
changeset 949	54464584b157
parent 314	2cc60866a0c9
child 802	994c7df296c9
permissions	-rw-r--r--