COIN-OR::LEMON - Graph Library

source: lemon-0.x/src/lemon/concept/maps.h @ 1359:1581f961cfaa

Last change on this file since 1359:1581f961cfaa was 1359:1581f961cfaa, checked in by Alpar Juttner, 15 years ago

Correct the english name of EGRES.

File size: 4.7 KB
Line 
1/* -*- C++ -*-
2 * src/lemon/concept/maps.h - Part of LEMON, a generic C++ optimization library
3 *
4 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
5 * (Egervary Research Group on Combinatorial Optimization, EGRES).
6 *
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.
10 *
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
13 * purpose.
14 *
15 */
16
17#ifndef LEMON_CONCEPT_MAPS_H
18#define LEMON_CONCEPT_MAPS_H
19
20#include <lemon/concept_check.h>
21
22///\ingroup concept
23///\file
24///\brief Map concepts checking classes for testing and documenting.
25
26namespace lemon {
27
28  namespace concept {
29 
30    /// \addtogroup concept
31    /// @{
32
33    /// Readable map concept
34    template<typename K, typename T>
35    class ReadMap
36    {
37    public:
38      /// Map's key type.
39      typedef K Key;   
40      /// Map's value type. (The type of objects associated with the keys).
41      typedef T Value;
42
43      // \bug Value don't need to be default constructible.
44      /// Returns the value associated with a key.
45      Value operator[](const Key &) const {return Value();}
46
47      template<typename _ReadMap>
48      struct Constraints {
49
50        void constraints() {
51          Value val = m[key];
52          val = m[key];
53          typename _ReadMap::Value own_val = m[own_key];
54          own_val = m[own_key];
55
56          ignore_unused_variable_warning(val);
57          ignore_unused_variable_warning(own_val);
58          ignore_unused_variable_warning(key);
59        }
60        Key& key;
61        typename _ReadMap::Key& own_key;
62        _ReadMap& m;
63      };
64     
65    };
66
67
68    /// Writable map concept
69    template<typename K, typename T>
70    class WriteMap
71    {
72    public:
73      /// Map's key type.
74      typedef K Key;   
75      /// Map's value type. (The type of objects associated with the keys).
76      typedef T Value;
77
78      /// Sets the value associated with a key.
79      void set(const Key &k,const Value &t) {}
80
81      ///Default constructor
82      WriteMap() {}
83
84      template <typename _WriteMap>
85      struct Constraints {
86        void constraints() {
87          // No constraints for constructor.
88          m.set(key, val);
89          m.set(own_key, own_val);
90          ignore_unused_variable_warning(key);
91          ignore_unused_variable_warning(val);
92          ignore_unused_variable_warning(own_key);
93          ignore_unused_variable_warning(own_val);
94        }
95
96        Value& val;
97        typename _WriteMap::Value own_val;
98        Key& key;
99        typename _WriteMap::Key& own_key;
100        WriteMap& m;
101
102      };
103    };
104
105    ///Read/Writable map concept
106    template<typename K, typename T>
107    class ReadWriteMap : public ReadMap<K,T>,
108                            public WriteMap<K,T>
109    {
110    public:
111      /// Map's key type.
112      typedef K Key;   
113      /// Map's value type. (The type of objects associated with the keys).
114      typedef T Value;
115
116      /// Returns the value associated with a key.
117      Value operator[](const Key &k) const {return Value();}
118      /// Sets the value associated with a key.
119      void set(const Key &k,const Value &t) {}
120
121      template<typename _ReadWriteMap>
122      struct Constraints {
123        void constraints() {
124          checkConcept<ReadMap<K, T>, _ReadWriteMap >();
125          checkConcept<ReadMap<K, T>, _ReadWriteMap >();
126        }
127      };
128    };
129 
130 
131    ///Dereferable map concept
132    template<typename K, typename T, typename R, typename CR>
133    class ReferenceMap : public ReadWriteMap<K,T>
134    {
135    public:
136      /// Map's key type.
137      typedef K Key;   
138      /// Map's value type. (The type of objects associated with the keys).
139      typedef T Value;
140      /// Map's reference type.
141      typedef R Reference;
142      /// Map's const reference type.
143      typedef CR ConstReference;
144
145    protected:
146      Value tmp;
147    public:
148
149      ///Returns a reference to the value associated to a key.
150      Reference operator[](const Key &i) { return tmp; }
151      ///Returns a const reference to the value associated to a key.
152      ConstReference operator[](const Key &i) const
153      { return tmp; }
154      /// Sets the value associated with a key.
155      void set(const Key &k,const Value &t) { operator[](k)=t; }
156
157      // \todo rethink this concept
158      template<typename _ReferenceMap>
159      struct ReferenceMapConcept {
160
161        void constraints() {
162          checkConcept<ReadWriteMap, _ReferenceMap >();
163          m[key] = val;
164          val  = m[key];
165          m[key] = ref;
166          ref = m[key];
167          m[own_key] = own_val;
168          own_val  = m[own_key];
169          m[own_key] = own_ref;
170          own_ref = m[own_key];           
171        }
172
173        typename _ReferenceMap::Key& own_key;
174        typename _ReferenceMap::Value& own_val;
175        typename _ReferenceMap::Reference& own_ref;
176        Key& key;
177        Value& val;
178        Reference& ref;
179        ReferenceMap& m;
180      };
181    };
182
183    // @}
184
185  } //namespace concept
186} //namespace lemon
187#endif // LEMON_CONCEPT_MAPS_H
Note: See TracBrowser for help on using the repository browser.