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