File: //usr/share/swig4.0/guile/std_map.i
/* -----------------------------------------------------------------------------
* std_map.i
*
* SWIG typemaps for std::map
* ----------------------------------------------------------------------------- */
%include <std_common.i>
%include <exception.i>
// ------------------------------------------------------------------------
// std::map
//
// The aim of all that follows would be to integrate std::map with
// Guile 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 C = std::less<K> > class map {
%typemap(in) map< K, T, C > {
if (scm_is_null($input)) {
$1 = std::map< K, T, C >();
} else if (scm_is_pair($input)) {
$1 = std::map< K, T, C >();
SCM alist = $input;
while (!scm_is_null(alist)) {
K* k;
T* x;
SCM entry, key, val;
entry = SCM_CAR(alist);
if (!scm_is_pair(entry))
SWIG_exception(SWIG_TypeError,"alist expected");
key = SCM_CAR(entry);
val = SCM_CDR(entry);
k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != 0) {
if (!scm_is_pair(val))
SWIG_exception(SWIG_TypeError,"alist expected");
val = SCM_CAR(val);
x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
}
%#ifdef __cpp_lib_map_try_emplace
(($1_type &)$1).insert_or_assign(*k, *x);
%#else
(($1_type &)$1)[*k] = *x;
%#endif
alist = SCM_CDR(alist);
}
} else {
$1 = *(($&1_type)
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
}
}
%typemap(in) const map< K, T, C >& (std::map< K, T, C > temp),
const map< K, T, C >* (std::map< K, T, C > temp) {
if (scm_is_null($input)) {
temp = std::map< K, T, C >();
$1 = &temp;
} else if (scm_is_pair($input)) {
temp = std::map< K, T, C >();
$1 = &temp;
SCM alist = $input;
while (!scm_is_null(alist)) {
K* k;
T* x;
SCM entry, key, val;
entry = SCM_CAR(alist);
if (!scm_is_pair(entry))
SWIG_exception(SWIG_TypeError,"alist expected");
key = SCM_CAR(entry);
val = SCM_CDR(entry);
k = (K*) SWIG_MustGetPtr(key,$descriptor(K *),$argnum, 0);
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != 0) {
if (!scm_is_pair(val))
SWIG_exception(SWIG_TypeError,"alist expected");
val = SCM_CAR(val);
x = (T*) SWIG_MustGetPtr(val,$descriptor(T *),$argnum, 0);
}
%#ifdef __cpp_lib_map_try_emplace
temp.insert_or_assign(*k, *x);
%#else
temp[*k] = *x;
%#endif
alist = SCM_CDR(alist);
}
} else {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
}
}
%typemap(out) map< K, T, C > {
SCM alist = SCM_EOL;
for (std::map< K, T, C >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) {
K* key = new K(i->first);
T* val = new T(i->second);
SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
SCM x = SWIG_NewPointerObj(val,$descriptor(T *), 1);
SCM entry = scm_cons(k,x);
alist = scm_cons(entry,alist);
}
$result = alist;
}
%typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
/* native sequence? */
if (scm_is_null($input)) {
/* an empty sequence can be of any type */
$1 = 1;
} else if (scm_is_pair($input)) {
/* check the first element only */
K* k;
T* x;
SCM head = SCM_CAR($input);
if (scm_is_pair(head)) {
SCM key = SCM_CAR(head);
SCM val = SCM_CDR(head);
if (SWIG_ConvertPtr(key,(void**) &k,
$descriptor(K *), 0) != 0) {
$1 = 0;
} else {
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) == 0) {
$1 = 1;
} else if (scm_is_pair(val)) {
val = SCM_CAR(val);
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) == 0)
$1 = 1;
else
$1 = 0;
} else {
$1 = 0;
}
}
} else {
$1 = 0;
}
} else {
/* wrapped map? */
std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0)
$1 = 1;
else
$1 = 0;
}
}
%typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
const map< K, T, C >* {
/* native sequence? */
if (scm_is_null($input)) {
/* an empty sequence can be of any type */
$1 = 1;
} else if (scm_is_pair($input)) {
/* check the first element only */
K* k;
T* x;
SCM head = SCM_CAR($input);
if (scm_is_pair(head)) {
SCM key = SCM_CAR(head);
SCM val = SCM_CDR(head);
if (SWIG_ConvertPtr(key,(void**) &k,
$descriptor(K *), 0) != 0) {
$1 = 0;
} else {
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) == 0) {
$1 = 1;
} else if (scm_is_pair(val)) {
val = SCM_CAR(val);
if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) == 0)
$1 = 1;
else
$1 = 0;
} else {
$1 = 0;
}
}
} else {
$1 = 0;
}
} else {
/* wrapped map? */
std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0)
$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:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef K key_type;
typedef T mapped_type;
typedef std::pair< const K, T > value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
map();
map(const map& other);
unsigned int size() const;
bool empty() const;
void clear();
%extend {
const T& __getitem__(const K& key) throw (std::out_of_range) {
std::map< K, T, C >::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) {
%#ifdef __cpp_lib_map_try_emplace
(*self).insert_or_assign(key, x);
%#else
(*self)[key] = x;
%#endif
}
void __delitem__(const K& key) throw (std::out_of_range) {
std::map< K, T, C >::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, C >::iterator i = self->find(key);
return i != self->end();
}
SCM keys() {
SCM result = SCM_EOL;
for (std::map< K, T, C >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
K* key = new K(i->first);
SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
result = scm_cons(k,result);
}
return result;
}
}
};
}