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