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