161 ///Map based on std::map |
161 ///Map based on std::map |
162 |
162 |
163 ///This is essentially a wrapper for \c std::map with addition that |
163 ///This is essentially a wrapper for \c std::map with addition that |
164 ///you can specify a default value different from \c Value(). |
164 ///you can specify a default value different from \c Value(). |
165 template <typename K, typename T, typename Compare = std::less<K> > |
165 template <typename K, typename T, typename Compare = std::less<K> > |
166 class StdMap { |
166 class StdMap : public MapBase<K, T> { |
167 template <typename K1, typename T1, typename C1> |
167 template <typename K1, typename T1, typename C1> |
168 friend class StdMap; |
168 friend class StdMap; |
169 public: |
169 public: |
170 |
170 |
|
171 typedef MapBase<K, T> Parent; |
|
172 ///\e |
|
173 typedef typename Parent::Key Key; |
|
174 ///\e |
|
175 typedef typename Parent::Value Value; |
|
176 ///\e |
|
177 typedef T& Reference; |
|
178 ///\e |
|
179 typedef const T& ConstReference; |
|
180 |
171 typedef True ReferenceMapTag; |
181 typedef True ReferenceMapTag; |
172 ///\e |
|
173 typedef K Key; |
|
174 ///\e |
|
175 typedef T Value; |
|
176 ///\e |
|
177 typedef T& Reference; |
|
178 ///\e |
|
179 typedef const T& ConstReference; |
|
180 |
182 |
181 private: |
183 private: |
182 |
184 |
183 typedef std::map<K, T, Compare> Map; |
185 typedef std::map<K, T, Compare> Map; |
184 Value _value; |
186 Value _value; |
237 _value = t; |
239 _value = t; |
238 _map.clear(); |
240 _map.clear(); |
239 } |
241 } |
240 |
242 |
241 }; |
243 }; |
|
244 |
|
245 ///Returns a \ref StdMap class |
|
246 |
|
247 ///This function just returns a \ref StdMap class with specified |
|
248 ///default value. |
|
249 ///\relates StdMap |
|
250 template<typename K, typename V, typename Compare = std::less<K> > |
|
251 inline StdMap<K, V, Compare> stdMap(const V& value = V()) { |
|
252 return StdMap<K, V, Compare>(value); |
|
253 } |
|
254 |
|
255 ///Returns a \ref StdMap class created from an appropriate std::map |
|
256 |
|
257 ///This function just returns a \ref StdMap class created from an |
|
258 ///appropriate std::map. |
|
259 ///\relates StdMap |
|
260 template<typename K, typename V, typename Compare = std::less<K> > |
|
261 inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map, |
|
262 const V& value = V() ) { |
|
263 return StdMap<K, V, Compare>(map, value); |
|
264 } |
242 |
265 |
243 /// \brief Map for storing values for keys from the range <tt>[0..size-1]</tt> |
266 /// \brief Map for storing values for keys from the range <tt>[0..size-1]</tt> |
244 /// |
267 /// |
245 /// The current map has the <tt>[0..size-1]</tt> keyset and the values |
268 /// The current map has the <tt>[0..size-1]</tt> keyset and the values |
246 /// are stored in a \c std::vector<T> container. It can be used with |
269 /// are stored in a \c std::vector<T> container. It can be used with |
247 /// some data structures, for example \c UnionFind, \c BinHeap, when |
270 /// some data structures, for example \c UnionFind, \c BinHeap, when |
248 /// the used items are small integer numbers. |
271 /// the used items are small integer numbers. |
249 /// |
272 /// |
250 /// \todo Revise its name |
273 /// \todo Revise its name |
251 template <typename T> |
274 template <typename T> |
252 class IntegerMap { |
275 class IntegerMap : public MapBase<int, T> { |
253 |
276 |
254 template <typename T1> |
277 template <typename T1> |
255 friend class IntegerMap; |
278 friend class IntegerMap; |
256 |
279 |
257 public: |
280 public: |
258 |
281 |
|
282 typedef MapBase<int, T> Parent; |
|
283 ///\e |
|
284 typedef typename Parent::Key Key; |
|
285 ///\e |
|
286 typedef typename Parent::Value Value; |
|
287 ///\e |
|
288 typedef T& Reference; |
|
289 ///\e |
|
290 typedef const T& ConstReference; |
|
291 |
259 typedef True ReferenceMapTag; |
292 typedef True ReferenceMapTag; |
260 ///\e |
|
261 typedef int Key; |
|
262 ///\e |
|
263 typedef T Value; |
|
264 ///\e |
|
265 typedef T& Reference; |
|
266 ///\e |
|
267 typedef const T& ConstReference; |
|
268 |
293 |
269 private: |
294 private: |
270 |
295 |
271 typedef std::vector<T> Vector; |
296 typedef std::vector<T> Vector; |
272 Vector _vector; |
297 Vector _vector; |
403 ///Constructor |
437 ///Constructor |
404 SimpleMap(const M &_m) : m(_m) {}; |
438 SimpleMap(const M &_m) : m(_m) {}; |
405 ///\e |
439 ///\e |
406 Value operator[](Key k) const {return m[k];} |
440 Value operator[](Key k) const {return m[k];} |
407 }; |
441 }; |
|
442 |
|
443 ///Returns a \ref SimpleMap class |
|
444 |
|
445 ///This function just returns a \ref SimpleMap class. |
|
446 ///\relates SimpleMap |
|
447 template<typename M> |
|
448 inline SimpleMap<M> simpleMap(const M &m) { |
|
449 return SimpleMap<M>(m); |
|
450 } |
408 |
451 |
409 ///Simple writable wrapping of a map |
452 ///Simple writable wrapping of a map |
410 |
453 |
411 ///This \ref concepts::WriteMap "write map" returns the simple |
454 ///This \ref concepts::WriteMap "write map" returns the simple |
412 ///wrapping of the given map. Sometimes the reference maps cannot be |
455 ///wrapping of the given map. Sometimes the reference maps cannot be |
430 ///\e |
473 ///\e |
431 Value operator[](Key k) const {return m[k];} |
474 Value operator[](Key k) const {return m[k];} |
432 ///\e |
475 ///\e |
433 void set(Key k, const Value& c) { m.set(k, c); } |
476 void set(Key k, const Value& c) { m.set(k, c); } |
434 }; |
477 }; |
|
478 |
|
479 ///Returns a \ref SimpleWriteMap class |
|
480 |
|
481 ///This function just returns a \ref SimpleWriteMap class. |
|
482 ///\relates SimpleWriteMap |
|
483 template<typename M> |
|
484 inline SimpleWriteMap<M> simpleWriteMap(M &m) { |
|
485 return SimpleWriteMap<M>(m); |
|
486 } |
435 |
487 |
436 ///Sum of two maps |
488 ///Sum of two maps |
437 |
489 |
438 ///This \c concepts::ReadMap "read only map" returns the sum of the two |
490 ///This \c concepts::ReadMap "read only map" returns the sum of the two |
439 ///given maps. |
491 ///given maps. |