Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | // |
2 | // SWIG typemaps for std::map | |
3 | // Luigi Ballabio | |
4 | // Jan. 2003 | |
5 | // | |
6 | // Common implementation | |
7 | ||
8 | %include <std_common.i> | |
9 | ||
10 | // ------------------------------------------------------------------------ | |
11 | // std::map | |
12 | // ------------------------------------------------------------------------ | |
13 | ||
14 | %{ | |
15 | #include <map> | |
16 | #include <algorithm> | |
17 | #include <stdexcept> | |
18 | %} | |
19 | ||
20 | // exported class | |
21 | ||
22 | namespace std { | |
23 | template<class K, class T> class map { | |
24 | // add typemaps here | |
25 | public: | |
26 | map(); | |
27 | map(const map<K,T> &); | |
28 | ||
29 | unsigned int size() const; | |
30 | bool empty() const; | |
31 | void clear(); | |
32 | %extend { | |
33 | T& get(const K& key) throw (std::out_of_range) { | |
34 | std::map<K,T >::iterator i = self->find(key); | |
35 | if (i != self->end()) | |
36 | return i->second; | |
37 | else | |
38 | throw std::out_of_range("key not found"); | |
39 | } | |
40 | void set(const K& key, const T& x) { | |
41 | (*self)[key] = x; | |
42 | } | |
43 | void del(const K& key) throw (std::out_of_range) { | |
44 | std::map<K,T >::iterator i = self->find(key); | |
45 | if (i != self->end()) | |
46 | self->erase(i); | |
47 | else | |
48 | throw std::out_of_range("key not found"); | |
49 | } | |
50 | bool has_key(const K& key) { | |
51 | std::map<K,T >::iterator i = self->find(key); | |
52 | return i != self->end(); | |
53 | } | |
54 | } | |
55 | }; | |
56 | ||
57 | ||
58 | // specializations for built-ins | |
59 | ||
60 | %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO) | |
61 | ||
62 | template<class T> class map<K,T> { | |
63 | // add typemaps here | |
64 | public: | |
65 | map(); | |
66 | map(const map<K,T> &); | |
67 | ||
68 | unsigned int size() const; | |
69 | bool empty() const; | |
70 | void clear(); | |
71 | %extend { | |
72 | T& get(K key) throw (std::out_of_range) { | |
73 | std::map<K,T >::iterator i = self->find(key); | |
74 | if (i != self->end()) | |
75 | return i->second; | |
76 | else | |
77 | throw std::out_of_range("key not found"); | |
78 | } | |
79 | void set(K key, const T& x) { | |
80 | (*self)[key] = x; | |
81 | } | |
82 | void del(K key) throw (std::out_of_range) { | |
83 | std::map<K,T >::iterator i = self->find(key); | |
84 | if (i != self->end()) | |
85 | self->erase(i); | |
86 | else | |
87 | throw std::out_of_range("key not found"); | |
88 | } | |
89 | bool has_key(K key) { | |
90 | std::map<K,T >::iterator i = self->find(key); | |
91 | return i != self->end(); | |
92 | } | |
93 | } | |
94 | }; | |
95 | %enddef | |
96 | ||
97 | %define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO) | |
98 | template<class K> class map<K,T> { | |
99 | // add typemaps here | |
100 | public: | |
101 | map(); | |
102 | map(const map<K,T> &); | |
103 | ||
104 | unsigned int size() const; | |
105 | bool empty() const; | |
106 | void clear(); | |
107 | %extend { | |
108 | T get(const K& key) throw (std::out_of_range) { | |
109 | std::map<K,T >::iterator i = self->find(key); | |
110 | if (i != self->end()) | |
111 | return i->second; | |
112 | else | |
113 | throw std::out_of_range("key not found"); | |
114 | } | |
115 | void set(const K& key, T x) { | |
116 | (*self)[key] = x; | |
117 | } | |
118 | void del(const K& key) throw (std::out_of_range) { | |
119 | std::map<K,T >::iterator i = self->find(key); | |
120 | if (i != self->end()) | |
121 | self->erase(i); | |
122 | else | |
123 | throw std::out_of_range("key not found"); | |
124 | } | |
125 | bool has_key(const K& key) { | |
126 | std::map<K,T >::iterator i = self->find(key); | |
127 | return i != self->end(); | |
128 | } | |
129 | } | |
130 | }; | |
131 | %enddef | |
132 | ||
133 | %define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO, | |
134 | T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO) | |
135 | template<> class map<K,T> { | |
136 | // add typemaps here | |
137 | public: | |
138 | map(); | |
139 | map(const map<K,T> &); | |
140 | ||
141 | unsigned int size() const; | |
142 | bool empty() const; | |
143 | void clear(); | |
144 | %extend { | |
145 | T get(K key) throw (std::out_of_range) { | |
146 | std::map<K,T >::iterator i = self->find(key); | |
147 | if (i != self->end()) | |
148 | return i->second; | |
149 | else | |
150 | throw std::out_of_range("key not found"); | |
151 | } | |
152 | void set(K key, T x) { | |
153 | (*self)[key] = x; | |
154 | } | |
155 | void del(K key) throw (std::out_of_range) { | |
156 | std::map<K,T >::iterator i = self->find(key); | |
157 | if (i != self->end()) | |
158 | self->erase(i); | |
159 | else | |
160 | throw std::out_of_range("key not found"); | |
161 | } | |
162 | bool has_key(K key) { | |
163 | std::map<K,T >::iterator i = self->find(key); | |
164 | return i != self->end(); | |
165 | } | |
166 | } | |
167 | }; | |
168 | %enddef | |
169 | ||
170 | // add specializations here | |
171 | } |