COIN-OR::LEMON - Graph Library

source: lemon-0.x/src/include/maps.h @ 286:d3c4d99860a9

Last change on this file since 286:d3c4d99860a9 was 286:d3c4d99860a9, checked in by Mihaly Barasz, 16 years ago

Miscellaneous maps, early version
skeletons/maps.h: minor bug

File size: 3.2 KB
Line 
1// -*- C++ -*- //
2#ifndef HUGO_MAPS_H
3#define HUGO_MAPS_H
4
5///\file
6///\brief Miscellaneous property maps
7///
8///\todo This file has the same name as the concept file in skeletons,
9/// and this is not easily detectable in docs...
10
11#include <map>
12
13namespace hugo {
14
15  /// Null map. (aka DoNothingMap)
16
17  /// If you have to provide a map only for its type definitions,
18  /// or if you have to provide a writable map, but will not use the
19  /// data written to it...
20  template<typename K, typename T>
21  class NullMap
22  {
23  public:
24    typedef K KeyType;
25    typedef T ValueType;
26
27    T operator[](const K&) const { return T(); }
28    void set(const K&, const T&) {}
29  };
30
31
32  /// Constant map.
33
34  /// This is a readable map which assignes a specified value to each key.
35  /// In other aspects it is equivalent to the \ref NullMap
36  template<typename K, typename T>
37  class ConstMap
38  {
39    T v;
40  public:
41    typedef K KeyType;
42    typedef T ValueType;
43
44    ConstMap() {}
45    ConstMap(const T &_v) : v(_v) {}
46
47    T operator[](const K&) const { return v; }
48    void set(const K&, const T&) {}
49
50    template<typename T1>
51    struct rebind {
52      typedef ConstMap<K,T1> other;
53    };
54
55    template<typename T1>
56    ConstMap(const ConstMap<K,T1> &, const T &_v) : v(_v) {}
57  };
58
59
60
61  /// \c std::map wrapper
62
63  /// This is essentially a wrapper for \c std::map. With addition that
64  /// you can specify a default value different from \c ValueType() .
65  ///
66  /// \todo Provide allocator parameter...
67  template <typename Key, typename T, typename Compare = std::less<Key> >
68  class StdMap : public std::map<Key,T,Compare> {
69    typedef std::map<Key,T,Compare> parent;
70    T v;
71    typedef typename parent::value_type PairType;
72
73  public:
74    typedef Key KeyType;
75    typedef T ValueType;
76    typedef T& ReferenceType;
77    typedef const T& ConstReferenceType;
78
79
80    StdMap() {}
81    /// Constructor with specified default value
82    StdMap(const T& _v) : v(_v) {}
83
84    /// \brief Constructs the map from an appropriate std::map.
85    ///
86    /// \warning Inefficient: copies the content of \c m !
87    StdMap(const parent &m) : parent(m) {}
88    /// \brief Constructs the map from an appropriate std::map, and explicitly
89    /// specifies a default value.
90    ///
91    /// \warning Inefficient: copies the content of \c m !
92    StdMap(const parent &m, const T& _v) : parent(m), v(_v) {}
93   
94    template<typename T1, typename Comp1>
95    StdMap(const StdMap<Key,T1,Comp1> &m, const T &_v) { FIXME; }
96
97    ReferenceType operator[](const Key &k) {
98      return (  *( (insert(PairType(k,v))).first )  ).second;
99    }
100    ConstReferenceType operator[](const Key &k) const {
101      typename parent::iterator i = lower_bound(__k);
102      if (i == end() || key_comp()(k, (*i).first))
103        return v;
104      return (*i).second;
105    }
106    void set(const Key &k, const T &t) { parent::operator[](k)=t; }
107
108    /// Changes the default value of the map.
109    /// \return Returns the previous default value.
110    ///
111    /// \warning The value of some keys (which has alredy been queried, but
112    /// the value has been unchanged from the default) may change!
113    T setDefault(const T &_v) { T old=v; v=_v; return old; }
114
115    template<typename T1>
116    struct rebind {
117      typedef StdMap<Key,T1,Compare> other;
118    };
119  };
120 
121}
122#endif // HUGO_MAPS_H
Note: See TracBrowser for help on using the repository browser.