Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | // |
2 | // SWIG typemaps for std::map | |
3 | // Luigi Ballabio | |
4 | // Jan. 2003 | |
5 | // | |
6 | // Ruby implementation | |
7 | ||
8 | %include <std_common.i> | |
9 | ||
10 | // ------------------------------------------------------------------------ | |
11 | // std::map | |
12 | // | |
13 | // The aim of all that follows would be to integrate std::map with | |
14 | // Ruby as much as possible, namely, to allow the user to pass and | |
15 | // be returned Ruby hash maps. | |
16 | // const declarations are used to guess the intent of the function being | |
17 | // exported; therefore, the following rationale is applied: | |
18 | // | |
19 | // -- f(std::map<T>), f(const std::map<T>&), f(const std::map<T>*): | |
20 | // the parameter being read-only, either a Ruby hash or a | |
21 | // previously wrapped std::map<T> can be passed. | |
22 | // -- f(std::map<T>&), f(std::map<T>*): | |
23 | // the parameter must be modified; therefore, only a wrapped std::map | |
24 | // can be passed. | |
25 | // -- std::map<T> f(): | |
26 | // the map is returned by copy; therefore, a Ruby hash | |
27 | // is returned which is most easily used in other Ruby functions | |
28 | // -- std::map<T>& f(), std::map<T>* f(), const std::map<T>& f(), | |
29 | // const std::map<T>* f(): | |
30 | // the map is returned by reference; therefore, a wrapped std::map | |
31 | // is returned | |
32 | // ------------------------------------------------------------------------ | |
33 | ||
34 | %{ | |
35 | #include <map> | |
36 | #include <algorithm> | |
37 | #include <stdexcept> | |
38 | %} | |
39 | ||
40 | // exported class | |
41 | ||
42 | namespace std { | |
43 | ||
44 | %mixin map "Enumerable"; | |
45 | ||
46 | template<class K, class T> class map { | |
47 | %typemap(in) map<K,T> (std::map<K,T>* m) { | |
48 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
49 | $1 = std::map<K,T >(); | |
50 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
51 | unsigned int size = RARRAY(keys)->len; | |
52 | for (unsigned int i=0; i<size; i++) { | |
53 | K* k; | |
54 | T* x; | |
55 | VALUE key = RARRAY(keys)->ptr[i]; | |
56 | VALUE val = rb_hash_aref($input,key); | |
57 | SWIG_ConvertPtr(key, (void **) &k, $descriptor(K *), 1); | |
58 | SWIG_ConvertPtr(val, (void **) &x, $descriptor(T *), 1); | |
59 | (($1_type &)$1)[*k] = *x; | |
60 | } | |
61 | } else { | |
62 | SWIG_ConvertPtr($input, (void **) &m, $&1_descriptor, 1); | |
63 | $1 = *m; | |
64 | } | |
65 | } | |
66 | %typemap(in) const map<K,T>& (std::map<K,T> temp, | |
67 | std::map<K,T>* m), | |
68 | const map<K,T>* (std::map<K,T> temp, | |
69 | std::map<K,T>* m) { | |
70 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
71 | temp = std::map<K,T >(); | |
72 | $1 = &temp; | |
73 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
74 | unsigned int size = RARRAY(keys)->len; | |
75 | for (unsigned int i=0; i<size; i++) { | |
76 | K* k; | |
77 | T* x; | |
78 | VALUE key = RARRAY(keys)->ptr[i]; | |
79 | VALUE val = rb_hash_aref($input,key); | |
80 | SWIG_ConvertPtr(key, (void **) &k, $descriptor(K *), 1); | |
81 | SWIG_ConvertPtr(val, (void **) &x, $descriptor(T *), 1); | |
82 | temp[*k] = *x; | |
83 | } | |
84 | } else { | |
85 | SWIG_ConvertPtr($input, (void **) &m, $1_descriptor, 1); | |
86 | $1 = m; | |
87 | } | |
88 | } | |
89 | %typemap(out) map<K,T> { | |
90 | $result = rb_hash_new(); | |
91 | for (std::map<K,T >::iterator i=$1.begin(); i!=$1.end(); ++i) { | |
92 | K* key = new K(i->first); | |
93 | T* val = new T(i->second); | |
94 | rb_hash_aset($result, | |
95 | SWIG_NewPointerObj((void *) key, | |
96 | $descriptor(K *), 1), | |
97 | SWIG_NewPointerObj((void *) val, | |
98 | $descriptor(T *), 1)); | |
99 | } | |
100 | } | |
101 | %typecheck(SWIG_TYPECHECK_MAP) map<K,T> { | |
102 | /* native sequence? */ | |
103 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
104 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
105 | unsigned int size = RARRAY(keys)->len; | |
106 | if (size == 0) { | |
107 | /* an empty dictionary can be of any type */ | |
108 | $1 = 1; | |
109 | } else { | |
110 | /* check the first element only */ | |
111 | K* k; | |
112 | T* x; | |
113 | VALUE key = RARRAY(keys)->ptr[0]; | |
114 | VALUE val = rb_hash_aref($input,key); | |
115 | if (SWIG_ConvertPtr(key,(void **) &k, | |
116 | $descriptor(K *),0) != -1 && | |
117 | SWIG_ConvertPtr(val,(void **) &x, | |
118 | $descriptor(T *),0) != -1) | |
119 | $1 = 1; | |
120 | else | |
121 | $1 = 0; | |
122 | } | |
123 | } else { | |
124 | /* wrapped map? */ | |
125 | std::map<K,T >* m; | |
126 | if (SWIG_ConvertPtr($input,(void **) &m, | |
127 | $&1_descriptor,0) != -1) | |
128 | $1 = 1; | |
129 | else | |
130 | $1 = 0; | |
131 | } | |
132 | } | |
133 | %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, | |
134 | const map<K,T>* { | |
135 | /* native sequence? */ | |
136 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
137 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
138 | unsigned int size = RARRAY(keys)->len; | |
139 | if (size == 0) { | |
140 | /* an empty dictionary can be of any type */ | |
141 | $1 = 1; | |
142 | } else { | |
143 | /* check the first element only */ | |
144 | K* k; | |
145 | T* x; | |
146 | VALUE key = RARRAY(keys)->ptr[0]; | |
147 | VALUE val = rb_hash_aref($input,key); | |
148 | if (SWIG_ConvertPtr(key,(void **) &k, | |
149 | $descriptor(K *),0) != -1 && | |
150 | SWIG_ConvertPtr(val,(void **) &x, | |
151 | $descriptor(T *),0) != -1) | |
152 | $1 = 1; | |
153 | else | |
154 | $1 = 0; | |
155 | } | |
156 | } else { | |
157 | /* wrapped map? */ | |
158 | std::map<K,T >* m; | |
159 | if (SWIG_ConvertPtr($input,(void **) &m, | |
160 | $1_descriptor,0) != -1) | |
161 | $1 = 1; | |
162 | else | |
163 | $1 = 0; | |
164 | } | |
165 | } | |
166 | %rename(__len__) size; | |
167 | %rename("empty?") empty; | |
168 | %rename("delete") __delitem__; | |
169 | %rename("has_key?") has_key; | |
170 | public: | |
171 | map(); | |
172 | map(const map<K,T> &); | |
173 | ||
174 | unsigned int size() const; | |
175 | bool empty() const; | |
176 | void clear(); | |
177 | %extend { | |
178 | T& __getitem__(const K& key) throw (std::out_of_range) { | |
179 | std::map<K,T >::iterator i = self->find(key); | |
180 | if (i != self->end()) | |
181 | return i->second; | |
182 | else | |
183 | throw std::out_of_range("key not found"); | |
184 | } | |
185 | void __setitem__(const K& key, const T& x) { | |
186 | (*self)[key] = x; | |
187 | } | |
188 | T __delitem__(const K& key) throw (std::out_of_range) { | |
189 | std::map<K,T >::iterator i = self->find(key); | |
190 | if (i != self->end()) { | |
191 | T x = i->second; | |
192 | self->erase(i); | |
193 | return x; | |
194 | } else | |
195 | throw std::out_of_range("key not found"); | |
196 | } | |
197 | bool has_key(const K& key) { | |
198 | std::map<K,T >::iterator i = self->find(key); | |
199 | return i != self->end(); | |
200 | } | |
201 | VALUE keys() { | |
202 | VALUE keyList = rb_ary_new2(self->size()); | |
203 | std::map<K,T >::iterator i; | |
204 | unsigned int j; | |
205 | for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) { | |
206 | K* ptr = new K(i->first); | |
207 | rb_ary_store(keyList,j, | |
208 | SWIG_NewPointerObj((void *) ptr, | |
209 | $descriptor(K *),1)); | |
210 | } | |
211 | return keyList; | |
212 | } | |
213 | VALUE values() { | |
214 | VALUE valueList = rb_ary_new2(self->size()); | |
215 | std::map<K,T >::iterator i; | |
216 | unsigned int j; | |
217 | for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) { | |
218 | T* ptr = new T(i->second); | |
219 | rb_ary_store(valueList,j, | |
220 | SWIG_NewPointerObj((void *) ptr, | |
221 | $descriptor(T *),1)); | |
222 | } | |
223 | return valueList; | |
224 | } | |
225 | void each() { | |
226 | std::map<K,T >::iterator i; | |
227 | for (i=self->begin(); i!=self->end(); ++i) { | |
228 | K* key = new K(i->first); | |
229 | T* val = &(i->second); | |
230 | VALUE entry = rb_ary_new2(2); | |
231 | VALUE k = SWIG_NewPointerObj((void *) key, | |
232 | $descriptor(K *),1); | |
233 | VALUE x = SWIG_NewPointerObj((void *) val, | |
234 | $descriptor(T *),0); | |
235 | rb_ary_store(entry,0,k); | |
236 | rb_ary_store(entry,1,x); | |
237 | rb_yield(entry); | |
238 | } | |
239 | } | |
240 | } | |
241 | }; | |
242 | ||
243 | ||
244 | // specializations for built-ins | |
245 | ||
246 | %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO) | |
247 | ||
248 | %mixin map<K,T> "Enumerable"; | |
249 | ||
250 | template<class T> class map<K,T> { | |
251 | %typemap(in) map<K,T> (std::map<K,T>* m) { | |
252 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
253 | $1 = std::map<K,T >(); | |
254 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
255 | unsigned int size = RARRAY(keys)->len; | |
256 | for (unsigned int i=0; i<size; i++) { | |
257 | T* x; | |
258 | VALUE key = RARRAY(keys)->ptr[i]; | |
259 | VALUE val = rb_hash_aref($input,key); | |
260 | if (!CHECK(key)) | |
261 | rb_raise(rb_eTypeError, | |
262 | "wrong argument type" | |
263 | " (expected map<" #K "," #T ">)"); | |
264 | SWIG_ConvertPtr(val,(void **) &x, | |
265 | $descriptor(T *),1); | |
266 | (($1_type &)$1)[CONVERT_FROM(key)] = *x; | |
267 | } | |
268 | } else { | |
269 | SWIG_ConvertPtr($input,(void **) &m, $&1_descriptor,1); | |
270 | $1 = *m; | |
271 | } | |
272 | } | |
273 | %typemap(in) const map<K,T>& (std::map<K,T> temp, | |
274 | std::map<K,T>* m), | |
275 | const map<K,T>* (std::map<K,T> temp, | |
276 | std::map<K,T>* m) { | |
277 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
278 | temp = std::map<K,T >(); | |
279 | $1 = &temp; | |
280 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
281 | unsigned int size = RARRAY(keys)->len; | |
282 | for (unsigned int i=0; i<size; i++) { | |
283 | T* x; | |
284 | VALUE key = RARRAY(keys)->ptr[i]; | |
285 | VALUE val = rb_hash_aref($input,key); | |
286 | if (!CHECK(key)) | |
287 | rb_raise(rb_eTypeError, | |
288 | "wrong argument type" | |
289 | " (expected map<" #K "," #T ">)"); | |
290 | SWIG_ConvertPtr(val,(void **) &x, | |
291 | $descriptor(T *),1); | |
292 | temp[CONVERT_FROM(key)] = *x; | |
293 | } | |
294 | } else { | |
295 | SWIG_ConvertPtr($input,(void **) &m,$1_descriptor,1); | |
296 | $1 = m; | |
297 | } | |
298 | } | |
299 | %typemap(out) map<K,T> { | |
300 | $result = rb_hash_new(); | |
301 | for (std::map<K,T >::iterator i=$1.begin(); i!=$1.end(); ++i) { | |
302 | T* obj = new T(i->second); | |
303 | rb_hash_aset($result, | |
304 | CONVERT_TO(i->first), | |
305 | SWIG_NewPointerObj((void *) obj, | |
306 | $descriptor(T *), 1)); | |
307 | } | |
308 | } | |
309 | %typecheck(SWIG_TYPECHECK_MAP) map<K,T> { | |
310 | // native sequence? | |
311 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
312 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
313 | unsigned int size = RARRAY(keys)->len; | |
314 | if (size == 0) { | |
315 | // an empty dictionary can be of any type | |
316 | $1 = 1; | |
317 | } else { | |
318 | // check the first element only | |
319 | T* x; | |
320 | VALUE key = RARRAY(keys)->ptr[0]; | |
321 | VALUE val = rb_hash_aref($input,key); | |
322 | if (CHECK(key) && | |
323 | SWIG_ConvertPtr(val,(void **) &x, | |
324 | $descriptor(T *),0) != -1) | |
325 | $1 = 1; | |
326 | else | |
327 | $1 = 0; | |
328 | } | |
329 | } else { | |
330 | // wrapped map? | |
331 | std::map<K,T >* m; | |
332 | if (SWIG_ConvertPtr($input,(void **) &m, | |
333 | $&1_descriptor,0) != -1) | |
334 | $1 = 1; | |
335 | else | |
336 | $1 = 0; | |
337 | } | |
338 | } | |
339 | %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, | |
340 | const map<K,T>* { | |
341 | // native sequence? | |
342 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
343 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
344 | unsigned int size = RARRAY(keys)->len; | |
345 | if (size == 0) { | |
346 | // an empty dictionary can be of any type | |
347 | $1 = 1; | |
348 | } else { | |
349 | // check the first element only | |
350 | T* x; | |
351 | VALUE key = RARRAY(keys)->ptr[0]; | |
352 | VALUE val = rb_hash_aref($input,key); | |
353 | if (CHECK(key) && | |
354 | SWIG_ConvertPtr(val,(void **) &x, | |
355 | $descriptor(T *),0) != -1) | |
356 | $1 = 1; | |
357 | else | |
358 | $1 = 0; | |
359 | } | |
360 | } else { | |
361 | // wrapped map? | |
362 | std::map<K,T >* m; | |
363 | if (SWIG_ConvertPtr($input,(void **) &m, | |
364 | $1_descriptor,0) != -1) | |
365 | $1 = 1; | |
366 | else | |
367 | $1 = 0; | |
368 | } | |
369 | } | |
370 | %rename(__len__) size; | |
371 | %rename("empty?") empty; | |
372 | %rename("delete") __delitem__; | |
373 | %rename("has_key?") has_key; | |
374 | public: | |
375 | map(); | |
376 | map(const map<K,T> &); | |
377 | ||
378 | unsigned int size() const; | |
379 | bool empty() const; | |
380 | void clear(); | |
381 | %extend { | |
382 | T& __getitem__(K key) throw (std::out_of_range) { | |
383 | std::map<K,T >::iterator i = self->find(key); | |
384 | if (i != self->end()) | |
385 | return i->second; | |
386 | else | |
387 | throw std::out_of_range("key not found"); | |
388 | } | |
389 | void __setitem__(K key, const T& x) { | |
390 | (*self)[key] = x; | |
391 | } | |
392 | T __delitem__(K key) throw (std::out_of_range) { | |
393 | std::map<K,T >::iterator i = self->find(key); | |
394 | if (i != self->end()) { | |
395 | T x = i->second; | |
396 | self->erase(i); | |
397 | return x; | |
398 | } else | |
399 | throw std::out_of_range("key not found"); | |
400 | } | |
401 | bool has_key(K key) { | |
402 | std::map<K,T >::iterator i = self->find(key); | |
403 | return i != self->end(); | |
404 | } | |
405 | VALUE keys() { | |
406 | VALUE keyList = rb_ary_new2(self->size()); | |
407 | std::map<K,T >::iterator i; | |
408 | unsigned int j; | |
409 | for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) { | |
410 | rb_ary_store(keyList,j, | |
411 | CONVERT_TO(i->first)); | |
412 | } | |
413 | return keyList; | |
414 | } | |
415 | VALUE values() { | |
416 | VALUE valueList = rb_ary_new2(self->size()); | |
417 | std::map<K,T >::iterator i; | |
418 | unsigned int j; | |
419 | for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) { | |
420 | T* ptr = new T(i->second); | |
421 | rb_ary_store(valueList,j, | |
422 | SWIG_NewPointerObj((void *) ptr, | |
423 | $descriptor(T *),1)); | |
424 | } | |
425 | return valueList; | |
426 | } | |
427 | void each() { | |
428 | std::map<K,T >::iterator i; | |
429 | for (i=self->begin(); i!=self->end(); ++i) { | |
430 | T* val = &(i->second); | |
431 | VALUE entry = rb_ary_new2(2); | |
432 | VALUE k = CONVERT_TO(i->first); | |
433 | VALUE x = SWIG_NewPointerObj((void *) val, | |
434 | $descriptor(T *),0); | |
435 | rb_ary_store(entry,0,k); | |
436 | rb_ary_store(entry,1,x); | |
437 | rb_yield(entry); | |
438 | } | |
439 | } | |
440 | } | |
441 | }; | |
442 | %enddef | |
443 | ||
444 | %define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO) | |
445 | ||
446 | %mixin map<K,T> "Enumerable"; | |
447 | ||
448 | template<class K> class map<K,T> { | |
449 | %typemap(in) map<K,T> (std::map<K,T>* m) { | |
450 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
451 | $1 = std::map<K,T >(); | |
452 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
453 | unsigned int size = RARRAY(keys)->len; | |
454 | for (unsigned int i=0; i<size; i++) { | |
455 | K* k; | |
456 | VALUE key = RARRAY(keys)->ptr[i]; | |
457 | VALUE val = rb_hash_aref($input,key); | |
458 | if (!CHECK(val)) | |
459 | rb_raise(rb_eTypeError, | |
460 | "wrong argument type" | |
461 | " (expected map<" #K "," #T ">)"); | |
462 | SWIG_ConvertPtr(key,(void **) &k, | |
463 | $descriptor(K *),1); | |
464 | (($1_type &)$1)[*k] = CONVERT_FROM(val); | |
465 | } | |
466 | } else { | |
467 | SWIG_ConvertPtr($input,(void **) &m, $&1_descriptor,1); | |
468 | $1 = *m; | |
469 | } | |
470 | } | |
471 | %typemap(in) const map<K,T>& (std::map<K,T> temp, | |
472 | std::map<K,T>* m), | |
473 | const map<K,T>* (std::map<K,T> temp, | |
474 | std::map<K,T>* m) { | |
475 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
476 | temp = std::map<K,T >(); | |
477 | $1 = &temp; | |
478 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
479 | unsigned int size = RARRAY(keys)->len; | |
480 | for (unsigned int i=0; i<size; i++) { | |
481 | K* k; | |
482 | VALUE key = RARRAY(keys)->ptr[i]; | |
483 | VALUE val = rb_hash_aref($input,key); | |
484 | if (!CHECK(val)) | |
485 | rb_raise(rb_eTypeError, | |
486 | "wrong argument type" | |
487 | " (expected map<" #K "," #T ">)"); | |
488 | SWIG_ConvertPtr(key,(void **) &k, | |
489 | $descriptor(K *),1); | |
490 | temp[*k] = CONVERT_FROM(val); | |
491 | } | |
492 | } else { | |
493 | SWIG_ConvertPtr($input,(void **) &m, $1_descriptor,1); | |
494 | $1 = m; | |
495 | } | |
496 | } | |
497 | %typemap(out) map<K,T> { | |
498 | $result = rb_hash_new(); | |
499 | for (std::map<K,T >::iterator i=$1.begin(); i!=$1.end(); ++i) { | |
500 | K* key = new K(i->first); | |
501 | rb_hash_aset($result, | |
502 | SWIG_NewPointerObj((void *) key, | |
503 | $descriptor(K *), 1), | |
504 | CONVERT_TO(i->second)); | |
505 | } | |
506 | } | |
507 | %typecheck(SWIG_TYPECHECK_MAP) map<K,T> { | |
508 | // native sequence? | |
509 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
510 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
511 | unsigned int size = RARRAY(keys)->len; | |
512 | if (size == 0) { | |
513 | // an empty dictionary can be of any type | |
514 | $1 = 1; | |
515 | } else { | |
516 | // check the first element only | |
517 | K* k; | |
518 | VALUE key = RARRAY(keys)->ptr[0]; | |
519 | VALUE val = rb_hash_aref($input,key); | |
520 | if (SWIG_ConvertPtr(val,(void **) &k, | |
521 | $descriptor(K *),0) != -1 && | |
522 | CHECK(val)) | |
523 | $1 = 1; | |
524 | else | |
525 | $1 = 0; | |
526 | } | |
527 | } else { | |
528 | // wrapped map? | |
529 | std::map<K,T >* m; | |
530 | if (SWIG_ConvertPtr($input,(void **) &m, | |
531 | $&1_descriptor,0) != -1) | |
532 | $1 = 1; | |
533 | else | |
534 | $1 = 0; | |
535 | } | |
536 | } | |
537 | %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, | |
538 | const map<K,T>* { | |
539 | // native sequence? | |
540 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
541 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
542 | unsigned int size = RARRAY(keys)->len; | |
543 | if (size == 0) { | |
544 | // an empty dictionary can be of any type | |
545 | $1 = 1; | |
546 | } else { | |
547 | // check the first element only | |
548 | K* k; | |
549 | VALUE key = RARRAY(keys)->ptr[0]; | |
550 | VALUE val = rb_hash_aref($input,key); | |
551 | if (SWIG_ConvertPtr(val,(void **) &k, | |
552 | $descriptor(K *),0) != -1 && | |
553 | CHECK(val)) | |
554 | $1 = 1; | |
555 | else | |
556 | $1 = 0; | |
557 | } | |
558 | } else { | |
559 | // wrapped map? | |
560 | std::map<K,T >* m; | |
561 | if (SWIG_ConvertPtr($input,(void **) &m, | |
562 | $1_descriptor,0) != -1) | |
563 | $1 = 1; | |
564 | else | |
565 | $1 = 0; | |
566 | } | |
567 | } | |
568 | %rename(__len__) size; | |
569 | %rename("empty?") empty; | |
570 | %rename("delete") __delitem__; | |
571 | %rename("has_key?") has_key; | |
572 | public: | |
573 | map(); | |
574 | map(const map<K,T> &); | |
575 | ||
576 | unsigned int size() const; | |
577 | bool empty() const; | |
578 | void clear(); | |
579 | %extend { | |
580 | T __getitem__(const K& key) throw (std::out_of_range) { | |
581 | std::map<K,T >::iterator i = self->find(key); | |
582 | if (i != self->end()) | |
583 | return i->second; | |
584 | else | |
585 | throw std::out_of_range("key not found"); | |
586 | } | |
587 | void __setitem__(const K& key, T x) { | |
588 | (*self)[key] = x; | |
589 | } | |
590 | T __delitem__(const K& key) throw (std::out_of_range) { | |
591 | std::map<K,T >::iterator i = self->find(key); | |
592 | if (i != self->end()) { | |
593 | T x = i->second; | |
594 | self->erase(i); | |
595 | return x; | |
596 | } else | |
597 | throw std::out_of_range("key not found"); | |
598 | } | |
599 | bool has_key(const K& key) { | |
600 | std::map<K,T >::iterator i = self->find(key); | |
601 | return i != self->end(); | |
602 | } | |
603 | VALUE keys() { | |
604 | VALUE keyList = rb_ary_new2(self->size()); | |
605 | std::map<K,T >::iterator i; | |
606 | unsigned int j; | |
607 | for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) { | |
608 | K* ptr = new K(i->first); | |
609 | rb_ary_store(keyList,j, | |
610 | SWIG_NewPointerObj((void *) ptr, | |
611 | $descriptor(K *),1)); | |
612 | } | |
613 | return keyList; | |
614 | } | |
615 | VALUE values() { | |
616 | VALUE valueList = rb_ary_new2(self->size()); | |
617 | std::map<K,T >::iterator i; | |
618 | unsigned int j; | |
619 | for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) { | |
620 | rb_ary_store(valueList,j, | |
621 | CONVERT_TO(i->second)); | |
622 | } | |
623 | return valueList; | |
624 | } | |
625 | void each() { | |
626 | std::map<K,T >::iterator i; | |
627 | for (i=self->begin(); i!=self->end(); ++i) { | |
628 | K* key = new K(i->first); | |
629 | VALUE entry = rb_ary_new2(2); | |
630 | VALUE k = SWIG_NewPointerObj((void *) key, | |
631 | $descriptor(K *),1); | |
632 | VALUE x = CONVERT_TO(i->second); | |
633 | rb_ary_store(entry,0,k); | |
634 | rb_ary_store(entry,1,x); | |
635 | rb_yield(entry); | |
636 | } | |
637 | } | |
638 | } | |
639 | }; | |
640 | %enddef | |
641 | ||
642 | %define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO, | |
643 | T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO) | |
644 | %mixin map<K,T> "Enumerable"; | |
645 | ||
646 | template<> class map<K,T> { | |
647 | %typemap(in) map<K,T> (std::map<K,T>* m) { | |
648 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
649 | $1 = std::map<K,T >(); | |
650 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
651 | unsigned int size = RARRAY(keys)->len; | |
652 | for (unsigned int i=0; i<size; i++) { | |
653 | VALUE key = RARRAY(keys)->ptr[i]; | |
654 | VALUE val = rb_hash_aref($input,key); | |
655 | if (!(CHECK_K(key) && CHECK_T(val))) | |
656 | rb_raise(rb_eTypeError, | |
657 | "wrong argument type" | |
658 | " (expected map<" #K "," #T ">)"); | |
659 | (($1_type &)$1)[CONVERT_K_FROM(key)] = | |
660 | CONVERT_T_FROM(val); | |
661 | } | |
662 | } else { | |
663 | SWIG_ConvertPtr($input,(void **) &m, $&1_descriptor,1); | |
664 | $1 = *m; | |
665 | } | |
666 | } | |
667 | %typemap(in) const map<K,T>& (std::map<K,T> temp, | |
668 | std::map<K,T>* m), | |
669 | const map<K,T>* (std::map<K,T> temp, | |
670 | std::map<K,T>* m) { | |
671 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
672 | temp = std::map<K,T >(); | |
673 | $1 = &temp; | |
674 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
675 | unsigned int size = RARRAY(keys)->len; | |
676 | for (unsigned int i=0; i<size; i++) { | |
677 | VALUE key = RARRAY(keys)->ptr[i]; | |
678 | VALUE val = rb_hash_aref($input,key); | |
679 | if (!(CHECK_K(key) && CHECK_T(val))) | |
680 | rb_raise(rb_eTypeError, | |
681 | "wrong argument type" | |
682 | " (expected map<" #K "," #T ">)"); | |
683 | temp[CONVERT_K_FROM(key)] = CONVERT_T_FROM(val); | |
684 | } | |
685 | } else { | |
686 | SWIG_ConvertPtr($input,(void **) &m, $1_descriptor,1); | |
687 | $1 = m; | |
688 | } | |
689 | } | |
690 | %typemap(out) map<K,T> { | |
691 | $result = rb_hash_new(); | |
692 | for (std::map<K,T >::iterator i=$1.begin(); i!=$1.end(); ++i) { | |
693 | rb_hash_aset($result, | |
694 | CONVERT_K_TO(i->first), | |
695 | CONVERT_T_TO(i->second)); | |
696 | } | |
697 | } | |
698 | %typecheck(SWIG_TYPECHECK_MAP) map<K,T> { | |
699 | // native sequence? | |
700 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
701 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
702 | unsigned int size = RARRAY(keys)->len; | |
703 | if (size == 0) { | |
704 | // an empty dictionary can be of any type | |
705 | $1 = 1; | |
706 | } else { | |
707 | // check the first element only | |
708 | VALUE key = RARRAY(keys)->ptr[0]; | |
709 | VALUE val = rb_hash_aref($input,key); | |
710 | if (CHECK_K(key) && CHECK_T(val)) | |
711 | $1 = 1; | |
712 | else | |
713 | $1 = 0; | |
714 | } | |
715 | } else { | |
716 | // wrapped map? | |
717 | std::map<K,T >* m; | |
718 | if (SWIG_ConvertPtr($input,(void **) &m, | |
719 | $&1_descriptor,0) != -1) | |
720 | $1 = 1; | |
721 | else | |
722 | $1 = 0; | |
723 | } | |
724 | } | |
725 | %typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, | |
726 | const map<K,T>* { | |
727 | // native sequence? | |
728 | if (rb_obj_is_kind_of($input,rb_cHash)) { | |
729 | VALUE keys = rb_funcall($input,rb_intern("keys"),0); | |
730 | unsigned int size = RARRAY(keys)->len; | |
731 | if (size == 0) { | |
732 | // an empty dictionary can be of any type | |
733 | $1 = 1; | |
734 | } else { | |
735 | // check the first element only | |
736 | VALUE key = RARRAY(keys)->ptr[0]; | |
737 | VALUE val = rb_hash_aref($input,key); | |
738 | if (CHECK_K(key) && CHECK_T(val)) | |
739 | $1 = 1; | |
740 | else | |
741 | $1 = 0; | |
742 | } | |
743 | } else { | |
744 | // wrapped map? | |
745 | std::map<K,T >* m; | |
746 | if (SWIG_ConvertPtr($input,(void **) &m, | |
747 | $1_descriptor,0) != -1) | |
748 | $1 = 1; | |
749 | else | |
750 | $1 = 0; | |
751 | } | |
752 | } | |
753 | %rename(__len__) size; | |
754 | %rename("empty?") empty; | |
755 | %rename("delete") __delitem__; | |
756 | %rename("has_key?") has_key; | |
757 | public: | |
758 | map(); | |
759 | map(const map<K,T> &); | |
760 | ||
761 | unsigned int size() const; | |
762 | bool empty() const; | |
763 | void clear(); | |
764 | %extend { | |
765 | T __getitem__(K key) throw (std::out_of_range) { | |
766 | std::map<K,T >::iterator i = self->find(key); | |
767 | if (i != self->end()) | |
768 | return i->second; | |
769 | else | |
770 | throw std::out_of_range("key not found"); | |
771 | } | |
772 | void __setitem__(K key, T x) { | |
773 | (*self)[key] = x; | |
774 | } | |
775 | T __delitem__(K key) throw (std::out_of_range) { | |
776 | std::map<K,T >::iterator i = self->find(key); | |
777 | if (i != self->end()) { | |
778 | T x = i->second; | |
779 | self->erase(i); | |
780 | return x; | |
781 | } else | |
782 | throw std::out_of_range("key not found"); | |
783 | } | |
784 | bool has_key(K key) { | |
785 | std::map<K,T >::iterator i = self->find(key); | |
786 | return i != self->end(); | |
787 | } | |
788 | VALUE keys() { | |
789 | VALUE keyList = rb_ary_new2(self->size()); | |
790 | std::map<K,T >::iterator i; | |
791 | unsigned int j; | |
792 | for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) { | |
793 | rb_ary_store(keyList,j, | |
794 | CONVERT_K_TO(i->first)); | |
795 | } | |
796 | return keyList; | |
797 | } | |
798 | VALUE values() { | |
799 | VALUE valueList = rb_ary_new2(self->size()); | |
800 | std::map<K,T >::iterator i; | |
801 | unsigned int j; | |
802 | for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) { | |
803 | rb_ary_store(valueList,j, | |
804 | CONVERT_T_TO(i->second)); | |
805 | } | |
806 | return valueList; | |
807 | } | |
808 | void each() { | |
809 | std::map<K,T >::iterator i; | |
810 | for (i=self->begin(); i!=self->end(); ++i) { | |
811 | VALUE entry = rb_ary_new2(2); | |
812 | rb_ary_store(entry,0,CONVERT_K_TO(i->first)); | |
813 | rb_ary_store(entry,1,CONVERT_T_TO(i->second)); | |
814 | rb_yield(entry); | |
815 | } | |
816 | } | |
817 | } | |
818 | }; | |
819 | %enddef | |
820 | ||
821 | ||
822 | specialize_std_map_on_key(bool,SWIG_BOOL_P, | |
823 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
824 | specialize_std_map_on_key(int,FIXNUM_P, | |
825 | FIX2INT,INT2NUM); | |
826 | specialize_std_map_on_key(short,FIXNUM_P, | |
827 | FIX2INT,INT2NUM); | |
828 | specialize_std_map_on_key(long,FIXNUM_P, | |
829 | FIX2INT,INT2NUM); | |
830 | specialize_std_map_on_key(unsigned int,FIXNUM_P, | |
831 | FIX2INT,INT2NUM); | |
832 | specialize_std_map_on_key(unsigned short,FIXNUM_P, | |
833 | FIX2INT,INT2NUM); | |
834 | specialize_std_map_on_key(unsigned long,FIXNUM_P, | |
835 | FIX2INT,INT2NUM); | |
836 | specialize_std_map_on_key(double,SWIG_FLOAT_P, | |
837 | SWIG_NUM2DBL,rb_float_new); | |
838 | specialize_std_map_on_key(float,SWIG_FLOAT_P, | |
839 | SWIG_NUM2DBL,rb_float_new); | |
840 | specialize_std_map_on_key(std::string,SWIG_STRING_P, | |
841 | SWIG_RB2STR,SWIG_STR2RB); | |
842 | ||
843 | specialize_std_map_on_value(bool,SWIG_BOOL_P, | |
844 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
845 | specialize_std_map_on_value(int,FIXNUM_P, | |
846 | FIX2INT,INT2NUM); | |
847 | specialize_std_map_on_value(short,FIXNUM_P, | |
848 | FIX2INT,INT2NUM); | |
849 | specialize_std_map_on_value(long,FIXNUM_P, | |
850 | FIX2INT,INT2NUM); | |
851 | specialize_std_map_on_value(unsigned int,FIXNUM_P, | |
852 | FIX2INT,INT2NUM); | |
853 | specialize_std_map_on_value(unsigned short,FIXNUM_P, | |
854 | FIX2INT,INT2NUM); | |
855 | specialize_std_map_on_value(unsigned long,FIXNUM_P, | |
856 | FIX2INT,INT2NUM); | |
857 | specialize_std_map_on_value(double,SWIG_FLOAT_P, | |
858 | SWIG_NUM2DBL,rb_float_new); | |
859 | specialize_std_map_on_value(float,SWIG_FLOAT_P, | |
860 | SWIG_NUM2DBL,rb_float_new); | |
861 | specialize_std_map_on_value(std::string,SWIG_STRING_P, | |
862 | SWIG_RB2STR,SWIG_STR2RB); | |
863 | ||
864 | specialize_std_map_on_both(bool,SWIG_BOOL_P, | |
865 | SWIG_RB2BOOL,SWIG_BOOL2RB, | |
866 | bool,SWIG_BOOL_P, | |
867 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
868 | specialize_std_map_on_both(bool,SWIG_BOOL_P, | |
869 | SWIG_RB2BOOL,SWIG_BOOL2RB, | |
870 | int,FIXNUM_P, | |
871 | FIX2INT,INT2NUM); | |
872 | specialize_std_map_on_both(bool,SWIG_BOOL_P, | |
873 | SWIG_RB2BOOL,SWIG_BOOL2RB, | |
874 | short,FIXNUM_P, | |
875 | FIX2INT,INT2NUM); | |
876 | specialize_std_map_on_both(bool,SWIG_BOOL_P, | |
877 | SWIG_RB2BOOL,SWIG_BOOL2RB, | |
878 | long,FIXNUM_P, | |
879 | FIX2INT,INT2NUM); | |
880 | specialize_std_map_on_both(bool,SWIG_BOOL_P, | |
881 | SWIG_RB2BOOL,SWIG_BOOL2RB, | |
882 | unsigned int,FIXNUM_P, | |
883 | FIX2INT,INT2NUM); | |
884 | specialize_std_map_on_both(bool,SWIG_BOOL_P, | |
885 | SWIG_RB2BOOL,SWIG_BOOL2RB, | |
886 | unsigned short,FIXNUM_P, | |
887 | FIX2INT,INT2NUM); | |
888 | specialize_std_map_on_both(bool,SWIG_BOOL_P, | |
889 | SWIG_RB2BOOL,SWIG_BOOL2RB, | |
890 | unsigned long,FIXNUM_P, | |
891 | FIX2INT,INT2NUM); | |
892 | specialize_std_map_on_both(bool,SWIG_BOOL_P, | |
893 | SWIG_RB2BOOL,SWIG_BOOL2RB, | |
894 | double,SWIG_FLOAT_P, | |
895 | SWIG_NUM2DBL,rb_float_new); | |
896 | specialize_std_map_on_both(bool,SWIG_BOOL_P, | |
897 | SWIG_RB2BOOL,SWIG_BOOL2RB, | |
898 | float,SWIG_FLOAT_P, | |
899 | SWIG_NUM2DBL,rb_float_new); | |
900 | specialize_std_map_on_both(bool,SWIG_BOOL_P, | |
901 | SWIG_RB2BOOL,SWIG_BOOL2RB, | |
902 | std::string,SWIG_STRING_P, | |
903 | SWIG_RB2STR,SWIG_STR2RB); | |
904 | specialize_std_map_on_both(int,FIXNUM_P, | |
905 | FIX2INT,INT2NUM, | |
906 | bool,SWIG_BOOL_P, | |
907 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
908 | specialize_std_map_on_both(int,FIXNUM_P, | |
909 | FIX2INT,INT2NUM, | |
910 | int,FIXNUM_P, | |
911 | FIX2INT,INT2NUM); | |
912 | specialize_std_map_on_both(int,FIXNUM_P, | |
913 | FIX2INT,INT2NUM, | |
914 | short,FIXNUM_P, | |
915 | FIX2INT,INT2NUM); | |
916 | specialize_std_map_on_both(int,FIXNUM_P, | |
917 | FIX2INT,INT2NUM, | |
918 | long,FIXNUM_P, | |
919 | FIX2INT,INT2NUM); | |
920 | specialize_std_map_on_both(int,FIXNUM_P, | |
921 | FIX2INT,INT2NUM, | |
922 | unsigned int,FIXNUM_P, | |
923 | FIX2INT,INT2NUM); | |
924 | specialize_std_map_on_both(int,FIXNUM_P, | |
925 | FIX2INT,INT2NUM, | |
926 | unsigned short,FIXNUM_P, | |
927 | FIX2INT,INT2NUM); | |
928 | specialize_std_map_on_both(int,FIXNUM_P, | |
929 | FIX2INT,INT2NUM, | |
930 | unsigned long,FIXNUM_P, | |
931 | FIX2INT,INT2NUM); | |
932 | specialize_std_map_on_both(int,FIXNUM_P, | |
933 | FIX2INT,INT2NUM, | |
934 | double,SWIG_FLOAT_P, | |
935 | SWIG_NUM2DBL,rb_float_new); | |
936 | specialize_std_map_on_both(int,FIXNUM_P, | |
937 | FIX2INT,INT2NUM, | |
938 | float,SWIG_FLOAT_P, | |
939 | SWIG_NUM2DBL,rb_float_new); | |
940 | specialize_std_map_on_both(int,FIXNUM_P, | |
941 | FIX2INT,INT2NUM, | |
942 | std::string,SWIG_STRING_P, | |
943 | SWIG_RB2STR,SWIG_STR2RB); | |
944 | specialize_std_map_on_both(short,FIXNUM_P, | |
945 | FIX2INT,INT2NUM, | |
946 | bool,SWIG_BOOL_P, | |
947 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
948 | specialize_std_map_on_both(short,FIXNUM_P, | |
949 | FIX2INT,INT2NUM, | |
950 | int,FIXNUM_P, | |
951 | FIX2INT,INT2NUM); | |
952 | specialize_std_map_on_both(short,FIXNUM_P, | |
953 | FIX2INT,INT2NUM, | |
954 | short,FIXNUM_P, | |
955 | FIX2INT,INT2NUM); | |
956 | specialize_std_map_on_both(short,FIXNUM_P, | |
957 | FIX2INT,INT2NUM, | |
958 | long,FIXNUM_P, | |
959 | FIX2INT,INT2NUM); | |
960 | specialize_std_map_on_both(short,FIXNUM_P, | |
961 | FIX2INT,INT2NUM, | |
962 | unsigned int,FIXNUM_P, | |
963 | FIX2INT,INT2NUM); | |
964 | specialize_std_map_on_both(short,FIXNUM_P, | |
965 | FIX2INT,INT2NUM, | |
966 | unsigned short,FIXNUM_P, | |
967 | FIX2INT,INT2NUM); | |
968 | specialize_std_map_on_both(short,FIXNUM_P, | |
969 | FIX2INT,INT2NUM, | |
970 | unsigned long,FIXNUM_P, | |
971 | FIX2INT,INT2NUM); | |
972 | specialize_std_map_on_both(short,FIXNUM_P, | |
973 | FIX2INT,INT2NUM, | |
974 | double,SWIG_FLOAT_P, | |
975 | SWIG_NUM2DBL,rb_float_new); | |
976 | specialize_std_map_on_both(short,FIXNUM_P, | |
977 | FIX2INT,INT2NUM, | |
978 | float,SWIG_FLOAT_P, | |
979 | SWIG_NUM2DBL,rb_float_new); | |
980 | specialize_std_map_on_both(short,FIXNUM_P, | |
981 | FIX2INT,INT2NUM, | |
982 | std::string,SWIG_STRING_P, | |
983 | SWIG_RB2STR,SWIG_STR2RB); | |
984 | specialize_std_map_on_both(long,FIXNUM_P, | |
985 | FIX2INT,INT2NUM, | |
986 | bool,SWIG_BOOL_P, | |
987 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
988 | specialize_std_map_on_both(long,FIXNUM_P, | |
989 | FIX2INT,INT2NUM, | |
990 | int,FIXNUM_P, | |
991 | FIX2INT,INT2NUM); | |
992 | specialize_std_map_on_both(long,FIXNUM_P, | |
993 | FIX2INT,INT2NUM, | |
994 | short,FIXNUM_P, | |
995 | FIX2INT,INT2NUM); | |
996 | specialize_std_map_on_both(long,FIXNUM_P, | |
997 | FIX2INT,INT2NUM, | |
998 | long,FIXNUM_P, | |
999 | FIX2INT,INT2NUM); | |
1000 | specialize_std_map_on_both(long,FIXNUM_P, | |
1001 | FIX2INT,INT2NUM, | |
1002 | unsigned int,FIXNUM_P, | |
1003 | FIX2INT,INT2NUM); | |
1004 | specialize_std_map_on_both(long,FIXNUM_P, | |
1005 | FIX2INT,INT2NUM, | |
1006 | unsigned short,FIXNUM_P, | |
1007 | FIX2INT,INT2NUM); | |
1008 | specialize_std_map_on_both(long,FIXNUM_P, | |
1009 | FIX2INT,INT2NUM, | |
1010 | unsigned long,FIXNUM_P, | |
1011 | FIX2INT,INT2NUM); | |
1012 | specialize_std_map_on_both(long,FIXNUM_P, | |
1013 | FIX2INT,INT2NUM, | |
1014 | double,SWIG_FLOAT_P, | |
1015 | SWIG_NUM2DBL,rb_float_new); | |
1016 | specialize_std_map_on_both(long,FIXNUM_P, | |
1017 | FIX2INT,INT2NUM, | |
1018 | float,SWIG_FLOAT_P, | |
1019 | SWIG_NUM2DBL,rb_float_new); | |
1020 | specialize_std_map_on_both(long,FIXNUM_P, | |
1021 | FIX2INT,INT2NUM, | |
1022 | std::string,SWIG_STRING_P, | |
1023 | SWIG_RB2STR,SWIG_STR2RB); | |
1024 | specialize_std_map_on_both(unsigned int,FIXNUM_P, | |
1025 | FIX2INT,INT2NUM, | |
1026 | bool,SWIG_BOOL_P, | |
1027 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
1028 | specialize_std_map_on_both(unsigned int,FIXNUM_P, | |
1029 | FIX2INT,INT2NUM, | |
1030 | int,FIXNUM_P, | |
1031 | FIX2INT,INT2NUM); | |
1032 | specialize_std_map_on_both(unsigned int,FIXNUM_P, | |
1033 | FIX2INT,INT2NUM, | |
1034 | short,FIXNUM_P, | |
1035 | FIX2INT,INT2NUM); | |
1036 | specialize_std_map_on_both(unsigned int,FIXNUM_P, | |
1037 | FIX2INT,INT2NUM, | |
1038 | long,FIXNUM_P, | |
1039 | FIX2INT,INT2NUM); | |
1040 | specialize_std_map_on_both(unsigned int,FIXNUM_P, | |
1041 | FIX2INT,INT2NUM, | |
1042 | unsigned int,FIXNUM_P, | |
1043 | FIX2INT,INT2NUM); | |
1044 | specialize_std_map_on_both(unsigned int,FIXNUM_P, | |
1045 | FIX2INT,INT2NUM, | |
1046 | unsigned short,FIXNUM_P, | |
1047 | FIX2INT,INT2NUM); | |
1048 | specialize_std_map_on_both(unsigned int,FIXNUM_P, | |
1049 | FIX2INT,INT2NUM, | |
1050 | unsigned long,FIXNUM_P, | |
1051 | FIX2INT,INT2NUM); | |
1052 | specialize_std_map_on_both(unsigned int,FIXNUM_P, | |
1053 | FIX2INT,INT2NUM, | |
1054 | double,SWIG_FLOAT_P, | |
1055 | SWIG_NUM2DBL,rb_float_new); | |
1056 | specialize_std_map_on_both(unsigned int,FIXNUM_P, | |
1057 | FIX2INT,INT2NUM, | |
1058 | float,SWIG_FLOAT_P, | |
1059 | SWIG_NUM2DBL,rb_float_new); | |
1060 | specialize_std_map_on_both(unsigned int,FIXNUM_P, | |
1061 | FIX2INT,INT2NUM, | |
1062 | std::string,SWIG_STRING_P, | |
1063 | SWIG_RB2STR,SWIG_STR2RB); | |
1064 | specialize_std_map_on_both(unsigned short,FIXNUM_P, | |
1065 | FIX2INT,INT2NUM, | |
1066 | bool,SWIG_BOOL_P, | |
1067 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
1068 | specialize_std_map_on_both(unsigned short,FIXNUM_P, | |
1069 | FIX2INT,INT2NUM, | |
1070 | int,FIXNUM_P, | |
1071 | FIX2INT,INT2NUM); | |
1072 | specialize_std_map_on_both(unsigned short,FIXNUM_P, | |
1073 | FIX2INT,INT2NUM, | |
1074 | short,FIXNUM_P, | |
1075 | FIX2INT,INT2NUM); | |
1076 | specialize_std_map_on_both(unsigned short,FIXNUM_P, | |
1077 | FIX2INT,INT2NUM, | |
1078 | long,FIXNUM_P, | |
1079 | FIX2INT,INT2NUM); | |
1080 | specialize_std_map_on_both(unsigned short,FIXNUM_P, | |
1081 | FIX2INT,INT2NUM, | |
1082 | unsigned int,FIXNUM_P, | |
1083 | FIX2INT,INT2NUM); | |
1084 | specialize_std_map_on_both(unsigned short,FIXNUM_P, | |
1085 | FIX2INT,INT2NUM, | |
1086 | unsigned short,FIXNUM_P, | |
1087 | FIX2INT,INT2NUM); | |
1088 | specialize_std_map_on_both(unsigned short,FIXNUM_P, | |
1089 | FIX2INT,INT2NUM, | |
1090 | unsigned long,FIXNUM_P, | |
1091 | FIX2INT,INT2NUM); | |
1092 | specialize_std_map_on_both(unsigned short,FIXNUM_P, | |
1093 | FIX2INT,INT2NUM, | |
1094 | double,SWIG_FLOAT_P, | |
1095 | SWIG_NUM2DBL,rb_float_new); | |
1096 | specialize_std_map_on_both(unsigned short,FIXNUM_P, | |
1097 | FIX2INT,INT2NUM, | |
1098 | float,SWIG_FLOAT_P, | |
1099 | SWIG_NUM2DBL,rb_float_new); | |
1100 | specialize_std_map_on_both(unsigned short,FIXNUM_P, | |
1101 | FIX2INT,INT2NUM, | |
1102 | std::string,SWIG_STRING_P, | |
1103 | SWIG_RB2STR,SWIG_STR2RB); | |
1104 | specialize_std_map_on_both(unsigned long,FIXNUM_P, | |
1105 | FIX2INT,INT2NUM, | |
1106 | bool,SWIG_BOOL_P, | |
1107 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
1108 | specialize_std_map_on_both(unsigned long,FIXNUM_P, | |
1109 | FIX2INT,INT2NUM, | |
1110 | int,FIXNUM_P, | |
1111 | FIX2INT,INT2NUM); | |
1112 | specialize_std_map_on_both(unsigned long,FIXNUM_P, | |
1113 | FIX2INT,INT2NUM, | |
1114 | short,FIXNUM_P, | |
1115 | FIX2INT,INT2NUM); | |
1116 | specialize_std_map_on_both(unsigned long,FIXNUM_P, | |
1117 | FIX2INT,INT2NUM, | |
1118 | long,FIXNUM_P, | |
1119 | FIX2INT,INT2NUM); | |
1120 | specialize_std_map_on_both(unsigned long,FIXNUM_P, | |
1121 | FIX2INT,INT2NUM, | |
1122 | unsigned int,FIXNUM_P, | |
1123 | FIX2INT,INT2NUM); | |
1124 | specialize_std_map_on_both(unsigned long,FIXNUM_P, | |
1125 | FIX2INT,INT2NUM, | |
1126 | unsigned short,FIXNUM_P, | |
1127 | FIX2INT,INT2NUM); | |
1128 | specialize_std_map_on_both(unsigned long,FIXNUM_P, | |
1129 | FIX2INT,INT2NUM, | |
1130 | unsigned long,FIXNUM_P, | |
1131 | FIX2INT,INT2NUM); | |
1132 | specialize_std_map_on_both(unsigned long,FIXNUM_P, | |
1133 | FIX2INT,INT2NUM, | |
1134 | double,SWIG_FLOAT_P, | |
1135 | SWIG_NUM2DBL,rb_float_new); | |
1136 | specialize_std_map_on_both(unsigned long,FIXNUM_P, | |
1137 | FIX2INT,INT2NUM, | |
1138 | float,SWIG_FLOAT_P, | |
1139 | SWIG_NUM2DBL,rb_float_new); | |
1140 | specialize_std_map_on_both(unsigned long,FIXNUM_P, | |
1141 | FIX2INT,INT2NUM, | |
1142 | std::string,SWIG_STRING_P, | |
1143 | SWIG_RB2STR,SWIG_STR2RB); | |
1144 | specialize_std_map_on_both(double,SWIG_FLOAT_P, | |
1145 | SWIG_NUM2DBL,rb_float_new, | |
1146 | bool,SWIG_BOOL_P, | |
1147 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
1148 | specialize_std_map_on_both(double,SWIG_FLOAT_P, | |
1149 | SWIG_NUM2DBL,rb_float_new, | |
1150 | int,FIXNUM_P, | |
1151 | FIX2INT,INT2NUM); | |
1152 | specialize_std_map_on_both(double,SWIG_FLOAT_P, | |
1153 | SWIG_NUM2DBL,rb_float_new, | |
1154 | short,FIXNUM_P, | |
1155 | FIX2INT,INT2NUM); | |
1156 | specialize_std_map_on_both(double,SWIG_FLOAT_P, | |
1157 | SWIG_NUM2DBL,rb_float_new, | |
1158 | long,FIXNUM_P, | |
1159 | FIX2INT,INT2NUM); | |
1160 | specialize_std_map_on_both(double,SWIG_FLOAT_P, | |
1161 | SWIG_NUM2DBL,rb_float_new, | |
1162 | unsigned int,FIXNUM_P, | |
1163 | FIX2INT,INT2NUM); | |
1164 | specialize_std_map_on_both(double,SWIG_FLOAT_P, | |
1165 | SWIG_NUM2DBL,rb_float_new, | |
1166 | unsigned short,FIXNUM_P, | |
1167 | FIX2INT,INT2NUM); | |
1168 | specialize_std_map_on_both(double,SWIG_FLOAT_P, | |
1169 | SWIG_NUM2DBL,rb_float_new, | |
1170 | unsigned long,FIXNUM_P, | |
1171 | FIX2INT,INT2NUM); | |
1172 | specialize_std_map_on_both(double,SWIG_FLOAT_P, | |
1173 | SWIG_NUM2DBL,rb_float_new, | |
1174 | double,SWIG_FLOAT_P, | |
1175 | SWIG_NUM2DBL,rb_float_new); | |
1176 | specialize_std_map_on_both(double,SWIG_FLOAT_P, | |
1177 | SWIG_NUM2DBL,rb_float_new, | |
1178 | float,SWIG_FLOAT_P, | |
1179 | SWIG_NUM2DBL,rb_float_new); | |
1180 | specialize_std_map_on_both(double,SWIG_FLOAT_P, | |
1181 | SWIG_NUM2DBL,rb_float_new, | |
1182 | std::string,SWIG_STRING_P, | |
1183 | SWIG_RB2STR,SWIG_STR2RB); | |
1184 | specialize_std_map_on_both(float,SWIG_FLOAT_P, | |
1185 | SWIG_NUM2DBL,rb_float_new, | |
1186 | bool,SWIG_BOOL_P, | |
1187 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
1188 | specialize_std_map_on_both(float,SWIG_FLOAT_P, | |
1189 | SWIG_NUM2DBL,rb_float_new, | |
1190 | int,FIXNUM_P, | |
1191 | FIX2INT,INT2NUM); | |
1192 | specialize_std_map_on_both(float,SWIG_FLOAT_P, | |
1193 | SWIG_NUM2DBL,rb_float_new, | |
1194 | short,FIXNUM_P, | |
1195 | FIX2INT,INT2NUM); | |
1196 | specialize_std_map_on_both(float,SWIG_FLOAT_P, | |
1197 | SWIG_NUM2DBL,rb_float_new, | |
1198 | long,FIXNUM_P, | |
1199 | FIX2INT,INT2NUM); | |
1200 | specialize_std_map_on_both(float,SWIG_FLOAT_P, | |
1201 | SWIG_NUM2DBL,rb_float_new, | |
1202 | unsigned int,FIXNUM_P, | |
1203 | FIX2INT,INT2NUM); | |
1204 | specialize_std_map_on_both(float,SWIG_FLOAT_P, | |
1205 | SWIG_NUM2DBL,rb_float_new, | |
1206 | unsigned short,FIXNUM_P, | |
1207 | FIX2INT,INT2NUM); | |
1208 | specialize_std_map_on_both(float,SWIG_FLOAT_P, | |
1209 | SWIG_NUM2DBL,rb_float_new, | |
1210 | unsigned long,FIXNUM_P, | |
1211 | FIX2INT,INT2NUM); | |
1212 | specialize_std_map_on_both(float,SWIG_FLOAT_P, | |
1213 | SWIG_NUM2DBL,rb_float_new, | |
1214 | double,SWIG_FLOAT_P, | |
1215 | SWIG_NUM2DBL,rb_float_new); | |
1216 | specialize_std_map_on_both(float,SWIG_FLOAT_P, | |
1217 | SWIG_NUM2DBL,rb_float_new, | |
1218 | float,SWIG_FLOAT_P, | |
1219 | SWIG_NUM2DBL,rb_float_new); | |
1220 | specialize_std_map_on_both(float,SWIG_FLOAT_P, | |
1221 | SWIG_NUM2DBL,rb_float_new, | |
1222 | std::string,SWIG_STRING_P, | |
1223 | SWIG_RB2STR,SWIG_STR2RB); | |
1224 | specialize_std_map_on_both(std::string,SWIG_STRING_P, | |
1225 | SWIG_RB2STR,SWIG_STR2RB, | |
1226 | bool,SWIG_BOOL_P, | |
1227 | SWIG_RB2BOOL,SWIG_BOOL2RB); | |
1228 | specialize_std_map_on_both(std::string,SWIG_STRING_P, | |
1229 | SWIG_RB2STR,SWIG_STR2RB, | |
1230 | int,FIXNUM_P, | |
1231 | FIX2INT,INT2NUM); | |
1232 | specialize_std_map_on_both(std::string,SWIG_STRING_P, | |
1233 | SWIG_RB2STR,SWIG_STR2RB, | |
1234 | short,FIXNUM_P, | |
1235 | FIX2INT,INT2NUM); | |
1236 | specialize_std_map_on_both(std::string,SWIG_STRING_P, | |
1237 | SWIG_RB2STR,SWIG_STR2RB, | |
1238 | long,FIXNUM_P, | |
1239 | FIX2INT,INT2NUM); | |
1240 | specialize_std_map_on_both(std::string,SWIG_STRING_P, | |
1241 | SWIG_RB2STR,SWIG_STR2RB, | |
1242 | unsigned int,FIXNUM_P, | |
1243 | FIX2INT,INT2NUM); | |
1244 | specialize_std_map_on_both(std::string,SWIG_STRING_P, | |
1245 | SWIG_RB2STR,SWIG_STR2RB, | |
1246 | unsigned short,FIXNUM_P, | |
1247 | FIX2INT,INT2NUM); | |
1248 | specialize_std_map_on_both(std::string,SWIG_STRING_P, | |
1249 | SWIG_RB2STR,SWIG_STR2RB, | |
1250 | unsigned long,FIXNUM_P, | |
1251 | FIX2INT,INT2NUM); | |
1252 | specialize_std_map_on_both(std::string,SWIG_STRING_P, | |
1253 | SWIG_RB2STR,SWIG_STR2RB, | |
1254 | double,SWIG_FLOAT_P, | |
1255 | SWIG_NUM2DBL,rb_float_new); | |
1256 | specialize_std_map_on_both(std::string,SWIG_STRING_P, | |
1257 | SWIG_RB2STR,SWIG_STR2RB, | |
1258 | float,SWIG_FLOAT_P, | |
1259 | SWIG_NUM2DBL,rb_float_new); | |
1260 | specialize_std_map_on_both(std::string,SWIG_STRING_P, | |
1261 | SWIG_RB2STR,SWIG_STR2RB, | |
1262 | std::string,SWIG_STRING_P, | |
1263 | SWIG_RB2STR,SWIG_STR2RB); | |
1264 | } |