lemon/bits/map_extender.h
author Alpar Juttner <alpar@cs.elte.hu>
Fri, 12 Dec 2008 21:52:53 +0000
branch1.0
changeset 350 d5cfcff85dfd
parent 263 be8a861d3bb7
child 406 e9c203fb003d
permissions -rw-r--r--
Merge bugfix #195
     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  */
    18 
    19 #ifndef LEMON_BITS_MAP_EXTENDER_H
    20 #define LEMON_BITS_MAP_EXTENDER_H
    21 
    22 #include <iterator>
    23 
    24 #include <lemon/bits/traits.h>
    25 
    26 #include <lemon/concept_check.h>
    27 #include <lemon/concepts/maps.h>
    28 
    29 //\file
    30 //\brief Extenders for iterable maps.
    31 
    32 namespace lemon {
    33 
    34   // \ingroup graphbits
    35   //
    36   // \brief Extender for maps
    37   template <typename _Map>
    38   class MapExtender : public _Map {
    39   public:
    40 
    41     typedef _Map Parent;
    42     typedef MapExtender Map;
    43 
    44 
    45     typedef typename Parent::Graph Graph;
    46     typedef typename Parent::Key Item;
    47 
    48     typedef typename Parent::Key Key;
    49     typedef typename Parent::Value Value;
    50 
    51     class MapIt;
    52     class ConstMapIt;
    53 
    54     friend class MapIt;
    55     friend class ConstMapIt;
    56 
    57   public:
    58 
    59     MapExtender(const Graph& graph)
    60       : Parent(graph) {}
    61 
    62     MapExtender(const Graph& graph, const Value& value)
    63       : Parent(graph, value) {}
    64 
    65   private:
    66     MapExtender& operator=(const MapExtender& cmap) {
    67       return operator=<MapExtender>(cmap);
    68     }
    69 
    70     template <typename CMap>
    71     MapExtender& operator=(const CMap& cmap) {
    72       Parent::operator=(cmap);
    73       return *this;
    74     }
    75 
    76   public:
    77     class MapIt : public Item {
    78     public:
    79 
    80       typedef Item Parent;
    81       typedef typename Map::Value Value;
    82 
    83       MapIt() {}
    84 
    85       MapIt(Invalid i) : Parent(i) { }
    86 
    87       explicit MapIt(Map& _map) : map(_map) {
    88         map.notifier()->first(*this);
    89       }
    90 
    91       MapIt(const Map& _map, const Item& item)
    92         : Parent(item), map(_map) {}
    93 
    94       MapIt& operator++() {
    95         map.notifier()->next(*this);
    96         return *this;
    97       }
    98 
    99       typename MapTraits<Map>::ConstReturnValue operator*() const {
   100         return map[*this];
   101       }
   102 
   103       typename MapTraits<Map>::ReturnValue operator*() {
   104         return map[*this];
   105       }
   106 
   107       void set(const Value& value) {
   108         map.set(*this, value);
   109       }
   110 
   111     protected:
   112       Map& map;
   113 
   114     };
   115 
   116     class ConstMapIt : public Item {
   117     public:
   118 
   119       typedef Item Parent;
   120 
   121       typedef typename Map::Value Value;
   122 
   123       ConstMapIt() {}
   124 
   125       ConstMapIt(Invalid i) : Parent(i) { }
   126 
   127       explicit ConstMapIt(Map& _map) : map(_map) {
   128         map.notifier()->first(*this);
   129       }
   130 
   131       ConstMapIt(const Map& _map, const Item& item)
   132         : Parent(item), map(_map) {}
   133 
   134       ConstMapIt& operator++() {
   135         map.notifier()->next(*this);
   136         return *this;
   137       }
   138 
   139       typename MapTraits<Map>::ConstReturnValue operator*() const {
   140         return map[*this];
   141       }
   142 
   143     protected:
   144       const Map& map;
   145     };
   146 
   147     class ItemIt : public Item {
   148     public:
   149 
   150       typedef Item Parent;
   151 
   152       ItemIt() {}
   153 
   154       ItemIt(Invalid i) : Parent(i) { }
   155 
   156       explicit ItemIt(Map& _map) : map(_map) {
   157         map.notifier()->first(*this);
   158       }
   159 
   160       ItemIt(const Map& _map, const Item& item)
   161         : Parent(item), map(_map) {}
   162 
   163       ItemIt& operator++() {
   164         map.notifier()->next(*this);
   165         return *this;
   166       }
   167 
   168     protected:
   169       const Map& map;
   170 
   171     };
   172   };
   173 
   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:
   180 
   181     typedef _Map Parent;
   182     typedef SubMapExtender Map;
   183 
   184     typedef _Graph Graph;
   185 
   186     typedef typename Parent::Key Item;
   187 
   188     typedef typename Parent::Key Key;
   189     typedef typename Parent::Value Value;
   190 
   191     class MapIt;
   192     class ConstMapIt;
   193 
   194     friend class MapIt;
   195     friend class ConstMapIt;
   196 
   197   public:
   198 
   199     SubMapExtender(const Graph& _graph)
   200       : Parent(_graph), graph(_graph) {}
   201 
   202     SubMapExtender(const Graph& _graph, const Value& _value)
   203       : Parent(_graph, _value), graph(_graph) {}
   204 
   205   private:
   206     SubMapExtender& operator=(const SubMapExtender& cmap) {
   207       return operator=<MapExtender>(cmap);
   208     }
   209 
   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     }
   219 
   220   public:
   221     class MapIt : public Item {
   222     public:
   223 
   224       typedef Item Parent;
   225       typedef typename Map::Value Value;
   226 
   227       MapIt() {}
   228 
   229       MapIt(Invalid i) : Parent(i) { }
   230 
   231       explicit MapIt(Map& _map) : map(_map) {
   232         map.graph.first(*this);
   233       }
   234 
   235       MapIt(const Map& _map, const Item& item)
   236         : Parent(item), map(_map) {}
   237 
   238       MapIt& operator++() {
   239         map.graph.next(*this);
   240         return *this;
   241       }
   242 
   243       typename MapTraits<Map>::ConstReturnValue operator*() const {
   244         return map[*this];
   245       }
   246 
   247       typename MapTraits<Map>::ReturnValue operator*() {
   248         return map[*this];
   249       }
   250 
   251       void set(const Value& value) {
   252         map.set(*this, value);
   253       }
   254 
   255     protected:
   256       Map& map;
   257 
   258     };
   259 
   260     class ConstMapIt : public Item {
   261     public:
   262 
   263       typedef Item Parent;
   264 
   265       typedef typename Map::Value Value;
   266 
   267       ConstMapIt() {}
   268 
   269       ConstMapIt(Invalid i) : Parent(i) { }
   270 
   271       explicit ConstMapIt(Map& _map) : map(_map) {
   272         map.graph.first(*this);
   273       }
   274 
   275       ConstMapIt(const Map& _map, const Item& item)
   276         : Parent(item), map(_map) {}
   277 
   278       ConstMapIt& operator++() {
   279         map.graph.next(*this);
   280         return *this;
   281       }
   282 
   283       typename MapTraits<Map>::ConstReturnValue operator*() const {
   284         return map[*this];
   285       }
   286 
   287     protected:
   288       const Map& map;
   289     };
   290 
   291     class ItemIt : public Item {
   292     public:
   293 
   294       typedef Item Parent;
   295 
   296       ItemIt() {}
   297 
   298       ItemIt(Invalid i) : Parent(i) { }
   299 
   300       explicit ItemIt(Map& _map) : map(_map) {
   301         map.graph.first(*this);
   302       }
   303 
   304       ItemIt(const Map& _map, const Item& item)
   305         : Parent(item), map(_map) {}
   306 
   307       ItemIt& operator++() {
   308         map.graph.next(*this);
   309         return *this;
   310       }
   311 
   312     protected:
   313       const Map& map;
   314 
   315     };
   316 
   317   private:
   318 
   319     const Graph& graph;
   320 
   321   };
   322 
   323 }
   324 
   325 #endif