bindings/swig/package/local/std_multimap.i


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

//file std_multimap.i

%include <std_common.i>


%{
#include <map>
#include <algorithm>
#include <stdexcept>
#include <iostream>
%}

// exported class

namespace std {

        template<class T1, class T2> class multimap {
                // add typemaps here
                public:
                        multimap();
                        multimap(const multimap<T1,T2> &);

                        unsigned int size() const;
                        bool empty() const;
                        void clear();

                        %extend {
                                //need a way to get the first element 
                                const T1 getElementOne(std::multimap<T1,T2>::iterator it) throw (std::out_of_range) {
                                        return it->first;
                                }
                                //and the second
                                T2 getElementTwo(std::multimap<T1,T2>::iterator it) throw (std::out_of_range) {
                                        return it->second;
                                }
                                //nice to have the beginning iterator
                                std::multimap<T1,T2>::iterator getBeginIterator() {
                                        return self->begin();
                                }
                                //and to get the next iterator
                                std::multimap<T1,T2>::iterator getNextIterator(std::multimap<T1,T2>::iterator it) {
                                        if (it != self->end()) {
                                                return ++it;
                                        } else {
                                                return it;
                                        }
                                }
                        }
        };

        //The rest is pretty much straight from std_map.i with name and signature changes
        // specializations for built-ins 

        %define specialize_std_multimap_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)

                template<class T> class multimap<K,T> {
                        // add typemaps here
                        public:
                                multimap();
                                multimap(const multimap<K,T> &);

                                unsigned int size() const;
                                bool empty() const;
                                void clear();
                                %extend {
                                        T& get(K key) throw (std::out_of_range) {
                                                std::multimap<K,T >::iterator i = self->find(key);
                                                if (i != self->end())
                                                        return i->second;
                                                else
                                                        throw std::out_of_range("key not found");
                                        }
                                        void set(K key, const T& x) {
                                                (*self)[key] = x;
                                        }
                                        void del(K key) throw (std::out_of_range) {
                                                std::multimap<K,T >::iterator i = self->find(key);
                                                if (i != self->end())
                                                        self->erase(i);
                                                else
                                                        throw std::out_of_range("key not found");
                                        }
                                        bool has_key(K key) {
                                                std::multimap<K,T >::iterator i = self->find(key);
                                                return i != self->end();
                                        }
                                }
                };
        %enddef

                %define specialize_std_multimap_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
                template<class K> class multimap<K,T> {
                        // add typemaps here
                        public:
                                multimap();
                                multimap(const multimap<K,T> &);

                                unsigned int size() const;
                                bool empty() const;
                                void clear();
                                %extend {
                                        T get(const K& key) throw (std::out_of_range) {
                                                std::multimap<K,T >::iterator i = self->find(key);
                                                if (i != self->end())
                                                        return i->second;
                                                else
                                                        throw std::out_of_range("key not found");
                                        }
                                        void set(const K& key, T x) {
                                                (*self)[key] = x;
                                        }
                                        void del(const K& key) throw (std::out_of_range) {
                                                std::multimap<K,T >::iterator i = self->find(key);
                                                if (i != self->end())
                                                        self->erase(i);
                                                else
                                                        throw std::out_of_range("key not found");
                                        }
                                        bool has_key(const K& key) {
                                                std::multimap<K,T >::iterator i = self->find(key);
                                                return i != self->end();
                                        }
                                }
                };
        %enddef

                %define specialize_std_multimap_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO,
                                T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
                template<> class multimap<K,T> {
                        // add typemaps here
                        public:
                                multimap();
                                multimap(const multimap<K,T> &);

                                unsigned int size() const;
                                bool empty() const;
                                void clear();
                                %extend {
                                        T get(K key) throw (std::out_of_range) {
                                                std::multimap<K,T >::iterator i = self->find(key);
                                                if (i != self->end())
                                                        return i->second;
                                                else
                                                        throw std::out_of_range("key not found");
                                        }
                                        void set(K key, T x) {
                                                (*self)[key] = x;
                                        }
                                        void del(K key) throw (std::out_of_range) {
                                                std::multimap<K,T >::iterator i = self->find(key);
                                                if (i != self->end())
                                                        self->erase(i);
                                                else
                                                        throw std::out_of_range("key not found");
                                        }
                                        bool has_key(K key) {
                                                std::multimap<K,T >::iterator i = self->find(key);
                                                return i != self->end();
                                        }
                                }
                };
        %enddef

                // add specializations here

}