d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
221 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 4464eef24d
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '4464eef24d'
${ noResults }
source-engine/devtools/swigwin-1.3.34/Lib/mzscheme/std_map.i

1351 lines
63 KiB
Raw Blame History

/* -----------------------------------------------------------------------------
* See the LICENSE file for information on copyright, usage and redistribution
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
*
* std_map.i
*
* SWIG typemaps for std::map
* ----------------------------------------------------------------------------- */
%include <std_common.i>
// ------------------------------------------------------------------------
// std::map
//
// The aim of all that follows would be to integrate std::map with
// MzScheme as much as possible, namely, to allow the user to pass and
// be returned Scheme association lists.
// const declarations are used to guess the intent of the function being
// exported; therefore, the following rationale is applied:
//
// -- f(std::map<T>), f(const std::map<T>&), f(const std::map<T>*):
// the parameter being read-only, either a Scheme alist or a
// previously wrapped std::map<T> can be passed.
// -- f(std::map<T>&), f(std::map<T>*):
// the parameter must be modified; therefore, only a wrapped std::map
// can be passed.
// -- std::map<T> f():
// the map is returned by copy; therefore, a Scheme alist
// is returned which is most easily used in other Scheme functions
// -- std::map<T>& f(), std::map<T>* f(), const std::map<T>& f(),
// const std::map<T>* f():
// the map is returned by reference; therefore, a wrapped std::map
// is returned
// ------------------------------------------------------------------------
%{
#include <map>
#include <algorithm>
#include <stdexcept>
%}
// exported class
namespace std {
template<class K, class T> class map {
%typemap(in) map<K,T> (std::map<K,T>* m) {
if (SCHEME_NULLP($input)) {
$1 = std::map<K,T >();
} else if (SCHEME_PAIRP($input)) {
$1 = std::map<K,T >();
Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) {
K* k;
T* x;
Scheme_Object *entry, *key, *val;
entry = scheme_car(alist);
if (!SCHEME_PAIRP(entry))
SWIG_exception(SWIG_TypeError,"alist expected");
key = scheme_car(entry);
val = scheme_cdr(entry);
k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) == -1) {
if (!SCHEME_PAIRP(val))
SWIG_exception(SWIG_TypeError,"alist expected");
val = scheme_car(val);
x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
}
(($1_type &)$1)[*k] = *x;
alist = scheme_cdr(alist);
}
} else {
$1 = *(($&1_type)
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
}
}
%typemap(in) const map<K,T>& (std::map<K,T> temp,
std::map<K,T>* m),
const map<K,T>* (std::map<K,T> temp,
std::map<K,T>* m) {
if (SCHEME_NULLP($input)) {
temp = std::map<K,T >();
$1 = &temp;
} else if (SCHEME_PAIRP($input)) {
temp = std::map<K,T >();
$1 = &temp;
Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) {
K* k;
T* x;
Scheme_Object *entry, *key, *val;
entry = scheme_car(alist);
if (!SCHEME_PAIRP(entry))
SWIG_exception(SWIG_TypeError,"alist expected");
key = scheme_car(entry);
val = scheme_cdr(entry);
k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) == -1) {
if (!SCHEME_PAIRP(val))
SWIG_exception(SWIG_TypeError,"alist expected");
val = scheme_car(val);
x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
}
temp[*k] = *x;
alist = scheme_cdr(alist);
}
} else {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
}
}
%typemap(out) map<K,T> {
Scheme_Object* alist = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) {
K* key = new K(i->first);
T* val = new T(i->second);
Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
Scheme_Object* x = SWIG_NewPointerObj(val,$descriptor(T *), 1);
Scheme_Object* entry = scheme_make_pair(k,x);
alist = scheme_make_pair(entry,alist);
}
$result = alist;
}
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
/* native sequence? */
if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */
$1 = 1;
} else if (SCHEME_PAIRP($input)) {
/* check the first element only */
K* k;
T* x;
Scheme_Object* head = scheme_car($input);
if (SCHEME_PAIRP(head)) {
Scheme_Object* key = scheme_car(head);
Scheme_Object* val = scheme_cdr(head);
if (SWIG_ConvertPtr(key,(void**) &k,
$descriptor(K *), 0) == -1) {
$1 = 0;
} else {
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != -1) {
$1 = 1;
} else if (SCHEME_PAIRP(val)) {
val = scheme_car(val);
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != -1)
$1 = 1;
else
$1 = 0;
} else {
$1 = 0;
}
}
} else {
$1 = 0;
}
} else {
/* wrapped map? */
std::map<K,T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) != -1)
$1 = 1;
else
$1 = 0;
}
}
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
const map<K,T>* {
/* native sequence? */
if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */
$1 = 1;
} else if (SCHEME_PAIRP($input)) {
/* check the first element only */
K* k;
T* x;
Scheme_Object* head = scheme_car($input);
if (SCHEME_PAIRP(head)) {
Scheme_Object* key = scheme_car(head);
Scheme_Object* val = scheme_cdr(head);
if (SWIG_ConvertPtr(key,(void**) &k,
$descriptor(K *), 0) == -1) {
$1 = 0;
} else {
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != -1) {
$1 = 1;
} else if (SCHEME_PAIRP(val)) {
val = scheme_car(val);
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != -1)
$1 = 1;
else
$1 = 0;
} else {
$1 = 0;
}
}
} else {
$1 = 0;
}
} else {
/* wrapped map? */
std::map<K,T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) != -1)
$1 = 1;
else
$1 = 0;
}
}
%rename("length") size;
%rename("null?") empty;
%rename("clear!") clear;
%rename("ref") __getitem__;
%rename("set!") __setitem__;
%rename("delete!") __delitem__;
%rename("has-key?") has_key;
public:
map();
map(const map<K,T> &);
unsigned int size() const;
bool empty() const;
void clear();
%extend {
T& __getitem__(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key);
if (i != self->end())
return i->second;
else
throw std::out_of_range("key not found");
}
void __setitem__(const K& key, const T& x) {
(*self)[key] = x;
}
void __delitem__(const K& key) throw (std::out_of_range) {
std::map<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::map<K,T >::iterator i = self->find(key);
return i != self->end();
}
Scheme_Object* keys() {
Scheme_Object* result = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) {
K* key = new K(i->first);
Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
result = scheme_make_pair(k,result);
}
return result;
}
}
};
// specializations for built-ins
%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
template<class T> class map<K,T> {
%typemap(in) map<K,T> (std::map<K,T>* m) {
if (SCHEME_NULLP($input)) {
$1 = std::map<K,T >();
} else if (SCHEME_PAIRP($input)) {
$1 = std::map<K,T >();
Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) {
T* x;
Scheme_Object *entry, *key, *val;
entry = scheme_car(alist);
if (!SCHEME_PAIRP(entry))
SWIG_exception(SWIG_TypeError,"alist expected");
key = scheme_car(entry);
val = scheme_cdr(entry);
if (!CHECK(key))
SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected");
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) == -1) {
if (!SCHEME_PAIRP(val))
SWIG_exception(SWIG_TypeError,"alist expected");
val = scheme_car(val);
x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
}
(($1_type &)$1)[CONVERT_FROM(key)] = *x;
alist = scheme_cdr(alist);
}
} else {
$1 = *(($&1_type)
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
}
}
%typemap(in) const map<K,T>& (std::map<K,T> temp,
std::map<K,T>* m),
const map<K,T>* (std::map<K,T> temp,
std::map<K,T>* m) {
if (SCHEME_NULLP($input)) {
temp = std::map<K,T >();
$1 = &temp;
} else if (SCHEME_PAIRP($input)) {
temp = std::map<K,T >();
$1 = &temp;
Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) {
T* x;
Scheme_Object *entry, *key, *val;
entry = scheme_car(alist);
if (!SCHEME_PAIRP(entry))
SWIG_exception(SWIG_TypeError,"alist expected");
key = scheme_car(entry);
val = scheme_cdr(entry);
if (!CHECK(key))
SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected");
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) == -1) {
if (!SCHEME_PAIRP(val))
SWIG_exception(SWIG_TypeError,"alist expected");
val = scheme_car(val);
x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
}
temp[CONVERT_FROM(key)] = *x;
alist = scheme_cdr(alist);
}
} else {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
}
}
%typemap(out) map<K,T> {
Scheme_Object* alist = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) {
T* val = new T(i->second);
Scheme_Object* k = CONVERT_TO(i->first);
Scheme_Object* x = SWIG_NewPointerObj(val,$descriptor(T *), 1);
Scheme_Object* entry = scheme_make_pair(k,x);
alist = scheme_make_pair(entry,alist);
}
$result = alist;
}
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
// native sequence?
if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */
$1 = 1;
} else if (SCHEME_PAIRP($input)) {
// check the first element only
T* x;
Scheme_Object* head = scheme_car($input);
if (SCHEME_PAIRP(head)) {
Scheme_Object* key = scheme_car(head);
Scheme_Object* val = scheme_cdr(head);
if (!CHECK(key)) {
$1 = 0;
} else {
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != -1) {
$1 = 1;
} else if (SCHEME_PAIRP(val)) {
val = scheme_car(val);
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != -1)
$1 = 1;
else
$1 = 0;
} else {
$1 = 0;
}
}
} else {
$1 = 0;
}
} else {
// wrapped map?
std::map<K,T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) != -1)
$1 = 1;
else
$1 = 0;
}
}
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
const map<K,T>* {
// native sequence?
if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */
$1 = 1;
} else if (SCHEME_PAIRP($input)) {
// check the first element only
T* x;
Scheme_Object* head = scheme_car($input);
if (SCHEME_PAIRP(head)) {
Scheme_Object* key = scheme_car(head);
Scheme_Object* val = scheme_cdr(head);
if (!CHECK(key)) {
$1 = 0;
} else {
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != -1) {
$1 = 1;
} else if (SCHEME_PAIRP(val)) {
val = scheme_car(val);
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != -1)
$1 = 1;
else
$1 = 0;
} else {
$1 = 0;
}
}
} else {
$1 = 0;
}
} else {
// wrapped map?
std::map<K,T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) != -1)
$1 = 1;
else
$1 = 0;
}
}
%rename("length") size;
%rename("null?") empty;
%rename("clear!") clear;
%rename("ref") __getitem__;
%rename("set!") __setitem__;
%rename("delete!") __delitem__;
%rename("has-key?") has_key;
public:
map();
map(const map<K,T> &);
unsigned int size() const;
bool empty() const;
void clear();
%extend {
T& __getitem__(K key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key);
if (i != self->end())
return i->second;
else
throw std::out_of_range("key not found");
}
void __setitem__(K key, const T& x) {
(*self)[key] = x;
}
void __delitem__(K key) throw (std::out_of_range) {
std::map<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::map<K,T >::iterator i = self->find(key);
return i != self->end();
}
Scheme_Object* keys() {
Scheme_Object* result = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) {
Scheme_Object* k = CONVERT_TO(i->first);
result = scheme_make_pair(k,result);
}
return result;
}
}
};
%enddef
%define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
template<class K> class map<K,T> {
%typemap(in) map<K,T> (std::map<K,T>* m) {
if (SCHEME_NULLP($input)) {
$1 = std::map<K,T >();
} else if (SCHEME_PAIRP($input)) {
$1 = std::map<K,T >();
Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) {
K* k;
Scheme_Object *entry, *key, *val;
entry = scheme_car(alist);
if (!SCHEME_PAIRP(entry))
SWIG_exception(SWIG_TypeError,"alist expected");
key = scheme_car(entry);
val = scheme_cdr(entry);
k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
if (!CHECK(val)) {
if (!SCHEME_PAIRP(val))
SWIG_exception(SWIG_TypeError,"alist expected");
val = scheme_car(val);
if (!CHECK(val))
SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected");
}
(($1_type &)$1)[*k] = CONVERT_FROM(val);
alist = scheme_cdr(alist);
}
} else {
$1 = *(($&1_type)
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
}
}
%typemap(in) const map<K,T>& (std::map<K,T> temp,
std::map<K,T>* m),
const map<K,T>* (std::map<K,T> temp,
std::map<K,T>* m) {
if (SCHEME_NULLP($input)) {
temp = std::map<K,T >();
$1 = &temp;
} else if (SCHEME_PAIRP($input)) {
temp = std::map<K,T >();
$1 = &temp;
Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) {
K* k;
Scheme_Object *entry, *key, *val;
entry = scheme_car(alist);
if (!SCHEME_PAIRP(entry))
SWIG_exception(SWIG_TypeError,"alist expected");
key = scheme_car(entry);
val = scheme_cdr(entry);
k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
if (!CHECK(val)) {
if (!SCHEME_PAIRP(val))
SWIG_exception(SWIG_TypeError,"alist expected");
val = scheme_car(val);
if (!CHECK(val))
SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected");
}
temp[*k] = CONVERT_FROM(val);
alist = scheme_cdr(alist);
}
} else {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
}
}
%typemap(out) map<K,T> {
Scheme_Object* alist = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) {
K* key = new K(i->first);
Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
Scheme_Object* x = CONVERT_TO(i->second);
Scheme_Object* entry = scheme_make_pair(k,x);
alist = scheme_make_pair(entry,alist);
}
$result = alist;
}
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
// native sequence?
if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */
$1 = 1;
} else if (SCHEME_PAIRP($input)) {
// check the first element only
K* k;
Scheme_Object* head = scheme_car($input);
if (SCHEME_PAIRP(head)) {
Scheme_Object* key = scheme_car(head);
Scheme_Object* val = scheme_cdr(head);
if (SWIG_ConvertPtr(val,(void **) &k,
$descriptor(K *), 0) == -1) {
$1 = 0;
} else {
if (CHECK(val)) {
$1 = 1;
} else if (SCHEME_PAIRP(val)) {
val = scheme_car(val);
if (CHECK(val))
$1 = 1;
else
$1 = 0;
} else {
$1 = 0;
}
}
} else {
$1 = 0;
}
} else {
// wrapped map?
std::map<K,T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) != -1)
$1 = 1;
else
$1 = 0;
}
}
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
const map<K,T>* {
// native sequence?
if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */
$1 = 1;
} else if (SCHEME_PAIRP($input)) {
// check the first element only
K* k;
Scheme_Object* head = scheme_car($input);
if (SCHEME_PAIRP(head)) {
Scheme_Object* key = scheme_car(head);
Scheme_Object* val = scheme_cdr(head);
if (SWIG_ConvertPtr(val,(void **) &k,
$descriptor(K *), 0) == -1) {
$1 = 0;
} else {
if (CHECK(val)) {
$1 = 1;
} else if (SCHEME_PAIRP(val)) {
val = scheme_car(val);
if (CHECK(val))
$1 = 1;
else
$1 = 0;
} else {
$1 = 0;
}
}
} else {
$1 = 0;
}
} else {
// wrapped map?
std::map<K,T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) != -1)
$1 = 1;
else
$1 = 0;
}
}
%rename("length") size;
%rename("null?") empty;
%rename("clear!") clear;
%rename("ref") __getitem__;
%rename("set!") __setitem__;
%rename("delete!") __delitem__;
%rename("has-key?") has_key;
public:
map();
map(const map<K,T> &);
unsigned int size() const;
bool empty() const;
void clear();
%extend {
T __getitem__(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key);
if (i != self->end())
return i->second;
else
throw std::out_of_range("key not found");
}
void __setitem__(const K& key, T x) {
(*self)[key] = x;
}
void __delitem__(const K& key) throw (std::out_of_range) {
std::map<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::map<K,T >::iterator i = self->find(key);
return i != self->end();
}
Scheme_Object* keys() {
Scheme_Object* result = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) {
K* key = new K(i->first);
Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
result = scheme_make_pair(k,result);
}
return result;
}
}
};
%enddef
%define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO,
T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
template<> class map<K,T> {
%typemap(in) map<K,T> (std::map<K,T>* m) {
if (SCHEME_NULLP($input)) {
$1 = std::map<K,T >();
} else if (SCHEME_PAIRP($input)) {
$1 = std::map<K,T >();
Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) {
Scheme_Object *entry, *key, *val;
entry = scheme_car(alist);
if (!SCHEME_PAIRP(entry))
SWIG_exception(SWIG_TypeError,"alist expected");
key = scheme_car(entry);
val = scheme_cdr(entry);
if (!CHECK_K(key))
SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected");
if (!CHECK_T(val)) {
if (!SCHEME_PAIRP(val))
SWIG_exception(SWIG_TypeError,"alist expected");
val = scheme_car(val);
if (!CHECK_T(val))
SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected");
}
(($1_type &)$1)[CONVERT_K_FROM(key)] =
CONVERT_T_FROM(val);
alist = scheme_cdr(alist);
}
} else {
$1 = *(($&1_type)
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
}
}
%typemap(in) const map<K,T>& (std::map<K,T> temp,
std::map<K,T>* m),
const map<K,T>* (std::map<K,T> temp,
std::map<K,T>* m) {
if (SCHEME_NULLP($input)) {
temp = std::map<K,T >();
$1 = &temp;
} else if (SCHEME_PAIRP($input)) {
temp = std::map<K,T >();
$1 = &temp;
Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) {
Scheme_Object *entry, *key, *val;
entry = scheme_car(alist);
if (!SCHEME_PAIRP(entry))
SWIG_exception(SWIG_TypeError,"alist expected");
key = scheme_car(entry);
val = scheme_cdr(entry);
if (!CHECK_K(key))
SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected");
if (!CHECK_T(val)) {
if (!SCHEME_PAIRP(val))
SWIG_exception(SWIG_TypeError,"alist expected");
val = scheme_car(val);
if (!CHECK_T(val))
SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected");
}
temp[CONVERT_K_FROM(key)] = CONVERT_T_FROM(val);
alist = scheme_cdr(alist);
}
} else {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
}
}
%typemap(out) map<K,T> {
Scheme_Object* alist = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) {
Scheme_Object* k = CONVERT_K_TO(i->first);
Scheme_Object* x = CONVERT_T_TO(i->second);
Scheme_Object* entry = scheme_make_pair(k,x);
alist = scheme_make_pair(entry,alist);
}
$result = alist;
}
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> {
// native sequence?
if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */
$1 = 1;
} else if (SCHEME_PAIRP($input)) {
// check the first element only
Scheme_Object* head = scheme_car($input);
if (SCHEME_PAIRP(head)) {
Scheme_Object* key = scheme_car(head);
Scheme_Object* val = scheme_cdr(head);
if (!CHECK_K(key)) {
$1 = 0;
} else {
if (CHECK_T(val)) {
$1 = 1;
} else if (SCHEME_PAIRP(val)) {
val = scheme_car(val);
if (CHECK_T(val))
$1 = 1;
else
$1 = 0;
} else {
$1 = 0;
}
}
} else {
$1 = 0;
}
} else {
// wrapped map?
std::map<K,T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) != -1)
$1 = 1;
else
$1 = 0;
}
}
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&,
const map<K,T>* {
// native sequence?
if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */
$1 = 1;
} else if (SCHEME_PAIRP($input)) {
// check the first element only
Scheme_Object* head = scheme_car($input);
if (SCHEME_PAIRP(head)) {
Scheme_Object* key = scheme_car(head);
Scheme_Object* val = scheme_cdr(head);
if (!CHECK_K(key)) {
$1 = 0;
} else {
if (CHECK_T(val)) {
$1 = 1;
} else if (SCHEME_PAIRP(val)) {
val = scheme_car(val);
if (CHECK_T(val))
$1 = 1;
else
$1 = 0;
} else {
$1 = 0;
}
}
} else {
$1 = 0;
}
} else {
// wrapped map?
std::map<K,T >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) != -1)
$1 = 1;
else
$1 = 0;
}
}
%rename("length") size;
%rename("null?") empty;
%rename("clear!") clear;
%rename("ref") __getitem__;
%rename("set!") __setitem__;
%rename("delete!") __delitem__;
%rename("has-key?") has_key;
public:
map();
map(const map<K,T> &);
unsigned int size() const;
bool empty() const;
void clear();
%extend {
T __getitem__(K key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key);
if (i != self->end())
return i->second;
else
throw std::out_of_range("key not found");
}
void __setitem__(K key, T x) {
(*self)[key] = x;
}
void __delitem__(K key) throw (std::out_of_range) {
std::map<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::map<K,T >::iterator i = self->find(key);
return i != self->end();
}
Scheme_Object* keys() {
Scheme_Object* result = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) {
Scheme_Object* k = CONVERT_K_TO(i->first);
result = scheme_make_pair(k,result);
}
return result;
}
}
};
%enddef
specialize_std_map_on_key(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_key(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_key(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_key(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_key(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_key(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_key(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_key(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_key(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_key(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
specialize_std_map_on_value(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_value(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_value(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_value(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_value(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_value(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_value(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_value(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_value(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_value(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
specialize_std_map_on_both(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean,
bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_both(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean,
int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean,
short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean,
long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean,
unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean,
unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean,
unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean,
double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean,
float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean,
std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
specialize_std_map_on_both(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_both(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
specialize_std_map_on_both(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_both(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
specialize_std_map_on_both(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_both(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
specialize_std_map_on_both(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_both(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
specialize_std_map_on_both(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_both(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
specialize_std_map_on_both(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_both(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value,
std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
specialize_std_map_on_both(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_both(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
specialize_std_map_on_both(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_both(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double,
std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
specialize_std_map_on_both(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string,
bool,SCHEME_BOOLP,
SCHEME_TRUEP,swig_make_boolean);
specialize_std_map_on_both(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string,
int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string,
short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string,
long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string,
unsigned int,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string,
unsigned short,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string,
unsigned long,SCHEME_INTP,
SCHEME_INT_VAL,scheme_make_integer_value);
specialize_std_map_on_both(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string,
double,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string,
float,SCHEME_REALP,
scheme_real_to_double,scheme_make_double);
specialize_std_map_on_both(std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string,
std::string,SCHEME_STRINGP,
swig_scm_to_string,swig_make_string);
}