61 /// Sets the value associated with a key. |
78 /// Sets the value associated with a key. |
62 void set(const Key &k,const Value &t) {} |
79 void set(const Key &k,const Value &t) {} |
63 |
80 |
64 ///Default constructor |
81 ///Default constructor |
65 WriteMap() {} |
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(key); |
|
91 ignore_unused_variable(val); |
|
92 ignore_unused_variable(own_key); |
|
93 ignore_unused_variable(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 }; |
66 }; |
103 }; |
67 |
104 |
68 ///Read/Writable map concept |
105 ///Read/Writable map concept |
69 template<typename K, typename T> |
106 template<typename K, typename T> |
70 class ReadWriteMap : public ReadMap<K,T>, |
107 class ReadWriteMap : public ReadMap<K,T>, |
79 /// Returns the value associated with a key. |
116 /// Returns the value associated with a key. |
80 Value operator[](const Key &k) const {return Value();} |
117 Value operator[](const Key &k) const {return Value();} |
81 /// Sets the value associated with a key. |
118 /// Sets the value associated with a key. |
82 void set(const Key &k,const Value &t) {} |
119 void set(const Key &k,const Value &t) {} |
83 |
120 |
84 ///Default constructor |
121 template<typename _ReadWriteMap> |
85 ReadWriteMap() {} |
122 struct Constraints { |
|
123 void constraints() { |
|
124 checkConcept<ReadMap<K, T>, _ReadWriteMap >(); |
|
125 checkConcept<ReadMap<K, T>, _ReadWriteMap >(); |
|
126 } |
|
127 }; |
86 }; |
128 }; |
87 |
129 |
88 |
130 |
89 ///Dereferable map concept |
131 ///Dereferable map concept |
90 template<typename K, typename T> |
132 template<typename K, typename T, typename R, typename CR> |
91 class ReferenceMap : public ReadWriteMap<K,T> |
133 class ReferenceMap : public ReadWriteMap<K,T> |
92 { |
134 { |
93 public: |
135 public: |
94 /// Map's key type. |
136 /// Map's key type. |
95 typedef K Key; |
137 typedef K Key; |
96 /// Map's value type. (The type of objects associated with the keys). |
138 /// Map's value type. (The type of objects associated with the keys). |
97 typedef T Value; |
139 typedef T Value; |
|
140 /// Map's reference type. |
|
141 typedef R Reference; |
|
142 /// Map's const reference type. |
|
143 typedef CR ConstReference; |
98 |
144 |
99 protected: |
145 protected: |
100 Value tmp; |
146 Value tmp; |
101 public: |
147 public: |
102 typedef Value& Reference; |
|
103 /// Map's const reference type. |
|
104 typedef const Value& ConstReference; |
|
105 |
148 |
106 ///Returns a reference to the value associated to a key. |
149 ///Returns a reference to the value associated to a key. |
107 Reference operator[](const Key &i) { return tmp; } |
150 Reference operator[](const Key &i) { return tmp; } |
108 ///Returns a const reference to the value associated to a key. |
151 ///Returns a const reference to the value associated to a key. |
109 ConstReference operator[](const Key &i) const |
152 ConstReference operator[](const Key &i) const |
110 { return tmp; } |
153 { return tmp; } |
111 /// Sets the value associated with a key. |
154 /// Sets the value associated with a key. |
112 void set(const Key &k,const Value &t) { operator[](k)=t; } |
155 void set(const Key &k,const Value &t) { operator[](k)=t; } |
113 |
156 |
114 ///Default constructor |
157 // \todo rethink this concept |
115 ReferenceMap() {} |
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 }; |
116 }; |
181 }; |
117 |
|
118 |
|
119 template<typename Item, typename T, typename Graph> |
|
120 class GraphMap : public ReadWriteMap<Item, T> { |
|
121 // I really, really don't like the idea that every graph should have |
|
122 // reference maps! --klao |
|
123 |
|
124 private: |
|
125 // We state explicitly that graph maps have no default constructor? |
|
126 GraphMap(); |
|
127 |
|
128 public: |
|
129 explicit GraphMap(Graph const&) {} |
|
130 // value for initializing |
|
131 GraphMap(Graph const&, T) {} |
|
132 |
|
133 // this probably should be required: |
|
134 GraphMap(GraphMap const&) {} |
|
135 GraphMap& operator=(GraphMap const&) { return *this; } |
|
136 |
|
137 // but this is a absolute no-op! We should provide a more generic |
|
138 // graph-map-copy operation. |
|
139 // |
|
140 // template<typename TT> |
|
141 // GraphMap(GraphMap<TT> const&); |
|
142 // |
|
143 // template<typename TT> |
|
144 // GraphMap& operator=(const GraphMap<TT>&); |
|
145 }; |
|
146 |
|
147 |
|
148 /**************** Concept-checking classes ****************/ |
|
149 |
|
150 template<typename ReadMap> |
|
151 struct ReadMapConcept { |
|
152 typedef typename ReadMap::Key Key; |
|
153 typedef typename ReadMap::Value Value; |
|
154 |
|
155 void constraints() { |
|
156 // No constraints for constructor. |
|
157 |
|
158 // What are the requirement for the Value? |
|
159 // CopyConstructible? Assignable? None of these? |
|
160 Value v = m[k]; |
|
161 v = m[k]; |
|
162 |
|
163 // FIXME: |
|
164 ignore_unused_variable_warning(v); |
|
165 } |
|
166 |
|
167 ReadMap m; |
|
168 Key k; |
|
169 }; |
|
170 |
|
171 template<typename WriteMap> |
|
172 struct WriteMapConcept { |
|
173 typedef typename WriteMap::Key Key; |
|
174 typedef typename WriteMap::Value Value; |
|
175 |
|
176 void constraints() { |
|
177 // No constraints for constructor. |
|
178 |
|
179 m.set(k, v); |
|
180 } |
|
181 |
|
182 WriteMap m; |
|
183 Key k; |
|
184 Value v; |
|
185 }; |
|
186 |
|
187 template<typename ReadWriteMap> |
|
188 struct ReadWriteMapConcept { |
|
189 void constraints() { |
|
190 function_requires< ReadMapConcept<ReadWriteMap> >(); |
|
191 function_requires< WriteMapConcept<ReadWriteMap> >(); |
|
192 } |
|
193 }; |
|
194 |
|
195 template<typename ReferenceMap> |
|
196 struct ReferenceMapConcept { |
|
197 typedef typename ReferenceMap::Key Key; |
|
198 typedef typename ReferenceMap::Value Value; |
|
199 typedef typename ReferenceMap::Reference Reference; |
|
200 |
|
201 // What for is this? |
|
202 typedef typename ReferenceMap::ConstReference ConstReference; |
|
203 |
|
204 void constraints() { |
|
205 function_requires< ReadWriteMapConcept<ReferenceMap> >(); |
|
206 |
|
207 m[k] = v; |
|
208 // Or should we require real reference? |
|
209 // Like this: |
|
210 // Value &vv = m[k]; |
|
211 // ignore_unused_variable_warning(vv); |
|
212 } |
|
213 |
|
214 ReferenceMap m; |
|
215 Key k; |
|
216 Value v; |
|
217 }; |
|
218 |
|
219 /// \todo GraphMapConceptCheck |
|
220 |
|
221 template<typename GraphMap, typename Graph> |
|
222 struct GraphMapConcept { |
|
223 void constraints() { |
|
224 function_requires< ReadWriteMapConcept<GraphMap> >(); |
|
225 // Construction with a graph parameter |
|
226 GraphMap a(g); |
|
227 // Ctor with a graph and a default value parameter |
|
228 GraphMap a2(g,t); |
|
229 // Copy ctor. Do we need it? |
|
230 GraphMap b=c; |
|
231 // Copy operator. Do we need it? |
|
232 a=b; |
|
233 |
|
234 ignore_unused_variable_warning(a2); |
|
235 } |
|
236 const GraphMap &c; |
|
237 const Graph &g; |
|
238 const typename GraphMap::Value &t; |
|
239 }; |
|
240 |
|
241 |
182 |
242 // @} |
183 // @} |
243 |
184 |
244 } //namespace concept |
185 } //namespace concept |
245 } //namespace lemon |
186 } //namespace lemon |