COIN-OR::LEMON - Graph Library

source: lemon/lemon/bits/map_extender.h @ 463:88ed40ad0d4f

Last change on this file since 463:88ed40ad0d4f was 463:88ed40ad0d4f, checked in by Alpar Juttner <alpar@…>, 11 years ago

Happy New Year again

  • update the copyright headers + run the source unifier
File size: 6.4 KB
Line 
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 */
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
32namespace 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
Note: See TracBrowser for help on using the repository browser.