NewMapWin has become Dialog instead of Window. Therefore it is created dynamically, when there is need for it, instead of keeping one instance in memory. This solution is slower, but more correct than before.
2 * lemon/default_map.h - Part of LEMON, a generic C++ optimization library
4 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
5 * (Egervary Research Group on Combinatorial Optimization, EGRES).
7 * Permission to use, modify and distribute this software is granted
8 * provided that this copyright notice appears in all copies. For
9 * precise terms see the accompanying LICENSE file.
11 * This software is provided "AS IS" with no warranty of any kind,
12 * express or implied, and with no claim as to its suitability for any
17 #ifndef LEMON_DEFAULT_MAP_H
18 #define LEMON_DEFAULT_MAP_H
21 #include <lemon/bits/array_map.h>
22 #include <lemon/bits/vector_map.h>
24 ///\ingroup graphmapfactory
26 ///\brief Graph maps that construct and destruct
27 ///their elements dynamically.
32 template <typename _Graph, typename _Item, typename _Value>
33 struct DefaultMapSelector {
34 typedef ArrayMap<_Graph, _Item, _Value> Map;
38 template <typename _Graph, typename _Item>
39 struct DefaultMapSelector<_Graph, _Item, bool> {
40 typedef VectorMap<_Graph, _Item, bool> Map;
44 template <typename _Graph, typename _Item>
45 struct DefaultMapSelector<_Graph, _Item, char> {
46 typedef VectorMap<_Graph, _Item, char> Map;
49 template <typename _Graph, typename _Item>
50 struct DefaultMapSelector<_Graph, _Item, signed char> {
51 typedef VectorMap<_Graph, _Item, signed char> Map;
54 template <typename _Graph, typename _Item>
55 struct DefaultMapSelector<_Graph, _Item, unsigned char> {
56 typedef VectorMap<_Graph, _Item, unsigned char> Map;
61 template <typename _Graph, typename _Item>
62 struct DefaultMapSelector<_Graph, _Item, signed int> {
63 typedef VectorMap<_Graph, _Item, signed int> Map;
66 template <typename _Graph, typename _Item>
67 struct DefaultMapSelector<_Graph, _Item, unsigned int> {
68 typedef VectorMap<_Graph, _Item, unsigned int> Map;
73 template <typename _Graph, typename _Item>
74 struct DefaultMapSelector<_Graph, _Item, signed short> {
75 typedef VectorMap<_Graph, _Item, signed short> Map;
78 template <typename _Graph, typename _Item>
79 struct DefaultMapSelector<_Graph, _Item, unsigned short> {
80 typedef VectorMap<_Graph, _Item, unsigned short> Map;
85 template <typename _Graph, typename _Item>
86 struct DefaultMapSelector<_Graph, _Item, signed long> {
87 typedef VectorMap<_Graph, _Item, signed long> Map;
90 template <typename _Graph, typename _Item>
91 struct DefaultMapSelector<_Graph, _Item, unsigned long> {
92 typedef VectorMap<_Graph, _Item, unsigned long> Map;
95 // \todo handling long long type
99 template <typename _Graph, typename _Item>
100 struct DefaultMapSelector<_Graph, _Item, float> {
101 typedef VectorMap<_Graph, _Item, float> Map;
106 template <typename _Graph, typename _Item>
107 struct DefaultMapSelector<_Graph, _Item, double> {
108 typedef VectorMap<_Graph, _Item, double> Map;
113 template <typename _Graph, typename _Item>
114 struct DefaultMapSelector<_Graph, _Item, long double> {
115 typedef VectorMap<_Graph, _Item, long double> Map;
120 template <typename _Graph, typename _Item, typename _Ptr>
121 struct DefaultMapSelector<_Graph, _Item, _Ptr*> {
122 typedef VectorMap<_Graph, _Item, _Ptr*> Map;
131 : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
133 typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;
134 typedef DefaultMap<_Graph, _Item, _Value> Map;
136 typedef typename Parent::Graph Graph;
137 typedef typename Parent::Value Value;
139 DefaultMap(const Graph& _g) : Parent(_g) {}
140 DefaultMap(const Graph& _g, const Value& _v) : Parent(_g, _v) {}
146 template <typename _Base>
147 class MappableGraphExtender : public _Base {
150 typedef MappableGraphExtender<_Base> Graph;
151 typedef _Base Parent;
153 typedef typename Parent::Node Node;
154 typedef typename Parent::NodeIt NodeIt;
156 typedef typename Parent::Edge Edge;
157 typedef typename Parent::EdgeIt EdgeIt;
160 template <typename _Value>
162 : public IterableMapExtender<DefaultMap<Graph, Node, _Value> > {
164 typedef MappableGraphExtender Graph;
165 typedef IterableMapExtender<DefaultMap<Graph, Node, _Value> > Parent;
167 NodeMap(const Graph& _g)
169 NodeMap(const Graph& _g, const _Value& _v)
172 NodeMap& operator=(const NodeMap& cmap) {
173 return operator=<NodeMap>(cmap);
177 /// \brief Template assign operator.
179 /// The given parameter should be conform to the ReadMap
180 /// concecpt and could be indiced by the current item set of
181 /// the NodeMap. In this case the value for each item
182 /// is assigned by the value of the given ReadMap.
183 template <typename CMap>
184 NodeMap& operator=(const CMap& cmap) {
185 checkConcept<concept::ReadMap<Node, _Value>, CMap>();
186 const typename Parent::Graph* graph = Parent::getGraph();
188 for (graph->first(it); it != INVALID; graph->next(it)) {
189 Parent::set(it, cmap[it]);
196 template <typename _Value>
198 : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
200 typedef MappableGraphExtender Graph;
201 typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
203 EdgeMap(const Graph& _g)
205 EdgeMap(const Graph& _g, const _Value& _v)
208 EdgeMap& operator=(const EdgeMap& cmap) {
209 return operator=<EdgeMap>(cmap);
212 template <typename CMap>
213 EdgeMap& operator=(const CMap& cmap) {
214 checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
215 const typename Parent::Graph* graph = Parent::getGraph();
217 for (graph->first(it); it != INVALID; graph->next(it)) {
218 Parent::set(it, cmap[it]);
227 template <typename _Base>
228 class MappableUndirGraphExtender :
229 public MappableGraphExtender<_Base> {
232 typedef MappableUndirGraphExtender Graph;
233 typedef MappableGraphExtender<_Base> Parent;
235 typedef typename Parent::UndirEdge UndirEdge;
237 template <typename _Value>
239 : public IterableMapExtender<DefaultMap<Graph, UndirEdge, _Value> > {
241 typedef MappableUndirGraphExtender Graph;
242 typedef IterableMapExtender<
243 DefaultMap<Graph, UndirEdge, _Value> > Parent;
245 UndirEdgeMap(const Graph& _g)
247 UndirEdgeMap(const Graph& _g, const _Value& _v)
250 UndirEdgeMap& operator=(const UndirEdgeMap& cmap) {
251 return operator=<UndirEdgeMap>(cmap);
254 template <typename CMap>
255 UndirEdgeMap& operator=(const CMap& cmap) {
256 checkConcept<concept::ReadMap<UndirEdge, _Value>, CMap>();
257 const typename Parent::Graph* graph = Parent::getGraph();
259 for (graph->first(it); it != INVALID; graph->next(it)) {
260 Parent::set(it, cmap[it]);
270 template <typename _Base>
271 class MappableUndirBipartiteGraphExtender : public _Base {
274 typedef _Base Parent;
275 typedef MappableUndirBipartiteGraphExtender Graph;
277 typedef typename Parent::Node Node;
278 typedef typename Parent::UpperNode UpperNode;
279 typedef typename Parent::LowerNode LowerNode;
280 typedef typename Parent::Edge Edge;
281 typedef typename Parent::UndirEdge UndirEdge;
283 template <typename _Value>
285 : public IterableMapExtender<DefaultMap<Graph, UpperNode, _Value> > {
287 typedef MappableUndirBipartiteGraphExtender Graph;
288 typedef IterableMapExtender<DefaultMap<Graph, UpperNode, _Value> >
291 UpperNodeMap(const Graph& _g)
293 UpperNodeMap(const Graph& _g, const _Value& _v)
296 UpperNodeMap& operator=(const UpperNodeMap& cmap) {
297 return operator=<UpperNodeMap>(cmap);
301 /// \brief Template assign operator.
303 /// The given parameter should be conform to the ReadMap
304 /// concept and could be indiced by the current item set of
305 /// the UpperNodeMap. In this case the value for each item
306 /// is assigned by the value of the given ReadMap.
307 template <typename CMap>
308 UpperNodeMap& operator=(const CMap& cmap) {
309 checkConcept<concept::ReadMap<UpperNode, _Value>, CMap>();
310 const typename Parent::Graph* graph = Parent::getGraph();
312 for (graph->first(it); it != INVALID; graph->next(it)) {
313 Parent::set(it, cmap[it]);
320 template <typename _Value>
322 : public IterableMapExtender<DefaultMap<Graph, LowerNode, _Value> > {
324 typedef MappableUndirBipartiteGraphExtender Graph;
325 typedef IterableMapExtender<DefaultMap<Graph, LowerNode, _Value> >
328 LowerNodeMap(const Graph& _g)
330 LowerNodeMap(const Graph& _g, const _Value& _v)
333 LowerNodeMap& operator=(const LowerNodeMap& cmap) {
334 return operator=<LowerNodeMap>(cmap);
338 /// \brief Template assign operator.
340 /// The given parameter should be conform to the ReadMap
341 /// concept and could be indiced by the current item set of
342 /// the LowerNodeMap. In this case the value for each item
343 /// is assigned by the value of the given ReadMap.
344 template <typename CMap>
345 LowerNodeMap& operator=(const CMap& cmap) {
346 checkConcept<concept::ReadMap<LowerNode, _Value>, CMap>();
347 const typename Parent::Graph* graph = Parent::getGraph();
349 for (graph->first(it); it != INVALID; graph->next(it)) {
350 Parent::set(it, cmap[it]);
359 template <typename _Value>
360 class NodeMapBase : public Parent::NodeNotifier::ObserverBase {
362 typedef MappableUndirBipartiteGraphExtender Graph;
365 typedef _Value Value;
367 /// The reference type of the map;
368 typedef typename LowerNodeMap<_Value>::Reference Reference;
369 /// The pointer type of the map;
370 typedef typename LowerNodeMap<_Value>::Pointer Pointer;
372 /// The const value type of the map.
373 typedef const Value ConstValue;
374 /// The const reference type of the map;
375 typedef typename LowerNodeMap<_Value>::ConstReference ConstReference;
376 /// The pointer type of the map;
377 typedef typename LowerNodeMap<_Value>::ConstPointer ConstPointer;
379 typedef True ReferenceMapTag;
381 NodeMapBase(const Graph& _g)
382 : graph(&_g), lowerMap(_g), upperMap(_g) {
383 Parent::NodeNotifier::ObserverBase::attach(_g.getNotifier(Node()));
385 NodeMapBase(const Graph& _g, const _Value& _v)
386 : graph(&_g), lowerMap(_g, _v),
388 Parent::NodeNotifier::ObserverBase::attach(_g.getNotifier(Node()));
391 virtual ~NodeMapBase() {
392 if (Parent::NodeNotifier::ObserverBase::attached()) {
393 Parent::NodeNotifier::ObserverBase::detach();
397 ConstReference operator[](const Key& node) const {
398 if (Parent::upper(node)) {
399 return upperMap[node];
401 return lowerMap[node];
405 Reference operator[](const Key& node) {
406 if (Parent::upper(node)) {
407 return upperMap[node];
409 return lowerMap[node];
413 void set(const Key& node, const Value& value) {
414 if (Parent::upper(node)) {
415 upperMap.set(node, value);
417 lowerMap.set(node, value);
423 virtual void add(const Node&) {}
424 virtual void erase(const Node&) {}
425 virtual void clear() {}
426 virtual void build() {}
428 const Graph* getGraph() const { return graph; }
432 LowerNodeMap<_Value> lowerMap;
433 UpperNodeMap<_Value> upperMap;
438 template <typename _Value>
440 : public IterableMapExtender<NodeMapBase<_Value> > {
442 typedef MappableUndirBipartiteGraphExtender Graph;
443 typedef IterableMapExtender< NodeMapBase<_Value> > Parent;
445 NodeMap(const Graph& _g)
447 NodeMap(const Graph& _g, const _Value& _v)
450 NodeMap& operator=(const NodeMap& cmap) {
451 return operator=<NodeMap>(cmap);
455 /// \brief Template assign operator.
457 /// The given parameter should be conform to the ReadMap
458 /// concept and could be indiced by the current item set of
459 /// the NodeMap. In this case the value for each item
460 /// is assigned by the value of the given ReadMap.
461 template <typename CMap>
462 NodeMap& operator=(const CMap& cmap) {
463 checkConcept<concept::ReadMap<Node, _Value>, CMap>();
464 const typename Parent::Graph* graph = Parent::getGraph();
466 for (graph->first(it); it != INVALID; graph->next(it)) {
467 Parent::set(it, cmap[it]);
476 template <typename _Value>
478 : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
480 typedef MappableUndirBipartiteGraphExtender Graph;
481 typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
483 EdgeMap(const Graph& _g)
485 EdgeMap(const Graph& _g, const _Value& _v)
488 EdgeMap& operator=(const EdgeMap& cmap) {
489 return operator=<EdgeMap>(cmap);
492 template <typename CMap>
493 EdgeMap& operator=(const CMap& cmap) {
494 checkConcept<concept::ReadMap<Edge, _Value>, CMap>();
495 const typename Parent::Graph* graph = Parent::getGraph();
497 for (graph->first(it); it != INVALID; graph->next(it)) {
498 Parent::set(it, cmap[it]);
504 template <typename _Value>
506 : public IterableMapExtender<DefaultMap<Graph, UndirEdge, _Value> > {
508 typedef MappableUndirBipartiteGraphExtender Graph;
509 typedef IterableMapExtender<DefaultMap<Graph, UndirEdge, _Value> >
512 UndirEdgeMap(const Graph& _g)
514 UndirEdgeMap(const Graph& _g, const _Value& _v)
517 UndirEdgeMap& operator=(const UndirEdgeMap& cmap) {
518 return operator=<UndirEdgeMap>(cmap);
521 template <typename CMap>
522 UndirEdgeMap& operator=(const CMap& cmap) {
523 checkConcept<concept::ReadMap<UndirEdge, _Value>, CMap>();
524 const typename Parent::Graph* graph = Parent::getGraph();
526 for (graph->first(it); it != INVALID; graph->next(it)) {
527 Parent::set(it, cmap[it]);