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