jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add support for non-default compare template argument in std::map wrappers

Browse source
This commit is contained in:
William S Fulton 2018-10-09 19:44:00 +01:00
commit ca287ae13b
12 changed files with 234 additions and 230 deletions
Download patch file Download diff file Expand all files Collapse all files

8
CHANGES.current
View file

@ -7,8 +7,12 @@ the issue number to the end of the URL: https://github.com/swig/swig/issues/
Version 4.0.0 (in progress) Version 4.0.0 (in progress)
=========================== ===========================
2018-06-09: vadz 2018-10-09: wsfulton
[Java] #1274 Allow exporting std::map using non-default comparison function. [D, Go, Guile, Lua, Mzscheme, Ocaml, Perl5, Php, Scilab, Tcl]
Allow wrapping of std::map using non-default comparison function.
2018-10-09: vadz
[Java] #1274 Allow wrapping of std::map using non-default comparison function.
2018-10-04: wsfulton 2018-10-04: wsfulton
[Python] #1126 Fix C default arguments with -builtin and -fastunpack and -modernargs. [Python] #1126 Fix C default arguments with -builtin and -fastunpack and -modernargs.

10
Lib/d/std_map.i
View file

@ -17,21 +17,21 @@
%} %}
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T, class C = std::less<K> > class map {
public: public:
typedef size_t size_type; typedef size_t size_type;
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef K key_type; typedef K key_type;
typedef T mapped_type; typedef T mapped_type;
map(); map();
map(const map<K,T> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
const T& get(const K& key) throw (std::out_of_range) { const T& get(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -41,14 +41,14 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void del(const K& key) throw (std::out_of_range) { void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
} }

10
Lib/go/std_map.i
View file

@ -20,7 +20,7 @@
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T, class C = std::less<K> > class map {
// add typemaps here // add typemaps here
public: public:
typedef size_t size_type; typedef size_t size_type;
@ -28,14 +28,14 @@ namespace std {
typedef K key_type; typedef K key_type;
typedef T mapped_type; typedef T mapped_type;
map(); map();
map(const map<K,T> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
const T& get(const K& key) throw (std::out_of_range) { const T& get(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -45,14 +45,14 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void del(const K& key) throw (std::out_of_range) { void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
} }

176
Lib/guile/std_map.i
View file

@ -40,12 +40,12 @@
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T, class C = std::less<K> > class map {
%typemap(in) map<K,T> { %typemap(in) map< K, T, C > {
if (scm_is_null($input)) { if (scm_is_null($input)) {
$1 = std::map< K, T >(); $1 = std::map< K, T, C >();
} else if (scm_is_pair($input)) { } else if (scm_is_pair($input)) {
$1 = std::map< K, T >(); $1 = std::map< K, T, C >();
SCM alist = $input; SCM alist = $input;
while (!scm_is_null(alist)) { while (!scm_is_null(alist)) {
K* k; K* k;
@ -72,13 +72,13 @@ namespace std {
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0)); SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
} }
} }
%typemap(in) const map<K,T>& (std::map<K,T> temp), %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp),
const map<K,T>* (std::map<K,T> temp) { const map< K, T, C >* (std::map< K, T, C > temp) {
if (scm_is_null($input)) { if (scm_is_null($input)) {
temp = std::map< K, T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
} else if (scm_is_pair($input)) { } else if (scm_is_pair($input)) {
temp = std::map< K, T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
SCM alist = $input; SCM alist = $input;
while (!scm_is_null(alist)) { while (!scm_is_null(alist)) {
@ -105,9 +105,9 @@ namespace std {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0); $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
} }
} }
%typemap(out) map<K,T> { %typemap(out) map< K, T, C > {
SCM alist = SCM_EOL; SCM alist = SCM_EOL;
for (std::map< K, T >::reverse_iterator i=$i.rbegin(); i!=$i.rend(); ++i) { for (std::map< K, T, C >::reverse_iterator i=$i.rbegin(); i!=$i.rend(); ++i) {
K* key = new K(i->first); K* key = new K(i->first);
T* val = new T(i->second); T* val = new T(i->second);
SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1); SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
@ -117,7 +117,7 @@ namespace std {
} }
$result = alist; $result = alist;
} }
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> { %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
/* native sequence? */ /* native sequence? */
if (scm_is_null($input)) { if (scm_is_null($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -153,7 +153,7 @@ namespace std {
} }
} else { } else {
/* wrapped map? */ /* wrapped map? */
std::map< K, T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0) $&1_descriptor, 0) == 0)
$1 = 1; $1 = 1;
@ -161,8 +161,8 @@ namespace std {
$1 = 0; $1 = 0;
} }
} }
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
const map<K,T>* { const map< K, T, C >* {
/* native sequence? */ /* native sequence? */
if (scm_is_null($input)) { if (scm_is_null($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -198,7 +198,7 @@ namespace std {
} }
} else { } else {
/* wrapped map? */ /* wrapped map? */
std::map< K, T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0) $1_descriptor, 0) == 0)
$1 = 1; $1 = 1;
@ -219,14 +219,14 @@ namespace std {
typedef K key_type; typedef K key_type;
typedef T mapped_type; typedef T mapped_type;
map(); map();
map(const map< K, T> &); map(const map< K, T, C> &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
const T& __getitem__(const K& key) throw (std::out_of_range) { const T& __getitem__(const K& key) throw (std::out_of_range) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -236,19 +236,19 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void __delitem__(const K& key) throw (std::out_of_range) { void __delitem__(const K& key) throw (std::out_of_range) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
SCM keys() { SCM keys() {
SCM result = SCM_EOL; SCM result = SCM_EOL;
for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) { for (std::map< K, T, C >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
K* key = new K(i->first); K* key = new K(i->first);
SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1); SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
result = scm_cons(k,result); result = scm_cons(k,result);
@ -263,12 +263,12 @@ namespace std {
%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO) %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
template<class T> class map<K,T> { template<class T> class map< K, T, C > {
%typemap(in) map<K,T> { %typemap(in) map< K, T, C > {
if (scm_is_null($input)) { if (scm_is_null($input)) {
$1 = std::map< K, T >(); $1 = std::map< K, T, C >();
} else if (scm_is_pair($input)) { } else if (scm_is_pair($input)) {
$1 = std::map< K, T >(); $1 = std::map< K, T, C >();
SCM alist = $input; SCM alist = $input;
while (!scm_is_null(alist)) { while (!scm_is_null(alist)) {
T* x; T* x;
@ -280,7 +280,7 @@ namespace std {
val = SCM_CDR(entry); val = SCM_CDR(entry);
if (!CHECK(key)) if (!CHECK(key))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
if (SWIG_ConvertPtr(val,(void**) &x, if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != 0) { $descriptor(T *), 0) != 0) {
if (!scm_is_pair(val)) if (!scm_is_pair(val))
@ -296,13 +296,13 @@ namespace std {
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0)); SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
} }
} }
%typemap(in) const map<K,T>& (std::map<K,T> temp), %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp),
const map<K,T>* (std::map<K,T> temp) { const map< K, T, C >* (std::map< K, T, C > temp) {
if (scm_is_null($input)) { if (scm_is_null($input)) {
temp = std::map< K, T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
} else if (scm_is_pair($input)) { } else if (scm_is_pair($input)) {
temp = std::map< K, T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
SCM alist = $input; SCM alist = $input;
while (!scm_is_null(alist)) { while (!scm_is_null(alist)) {
@ -315,7 +315,7 @@ namespace std {
val = SCM_CDR(entry); val = SCM_CDR(entry);
if (!CHECK(key)) if (!CHECK(key))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
if (SWIG_ConvertPtr(val,(void**) &x, if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) != 0) { $descriptor(T *), 0) != 0) {
if (!scm_is_pair(val)) if (!scm_is_pair(val))
@ -330,9 +330,9 @@ namespace std {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0); $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
} }
} }
%typemap(out) map<K,T> { %typemap(out) map< K, T, C > {
SCM alist = SCM_EOL; SCM alist = SCM_EOL;
for (std::map< K, T >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) { for (std::map< K, T, C >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) {
T* val = new T(i->second); T* val = new T(i->second);
SCM k = CONVERT_TO(i->first); SCM k = CONVERT_TO(i->first);
SCM x = SWIG_NewPointerObj(val,$descriptor(T *), 1); SCM x = SWIG_NewPointerObj(val,$descriptor(T *), 1);
@ -341,7 +341,7 @@ namespace std {
} }
$result = alist; $result = alist;
} }
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> { %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
// native sequence? // native sequence?
if (scm_is_null($input)) { if (scm_is_null($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -375,7 +375,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map< K, T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0) $&1_descriptor, 0) == 0)
$1 = 1; $1 = 1;
@ -383,8 +383,8 @@ namespace std {
$1 = 0; $1 = 0;
} }
} }
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
const map<K,T>* { const map< K, T, C >* {
// native sequence? // native sequence?
if (scm_is_null($input)) { if (scm_is_null($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -418,7 +418,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map< K, T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0) $1_descriptor, 0) == 0)
$1 = 1; $1 = 1;
@ -435,14 +435,14 @@ namespace std {
%rename("has-key?") has_key; %rename("has-key?") has_key;
public: public:
map(); map();
map(const map< K, T > &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
T& __getitem__(K key) throw (std::out_of_range) { T& __getitem__(K key) throw (std::out_of_range) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -452,19 +452,19 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void __delitem__(K key) throw (std::out_of_range) { void __delitem__(K key) throw (std::out_of_range) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(K key) { bool has_key(K key) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
SCM keys() { SCM keys() {
SCM result = SCM_EOL; SCM result = SCM_EOL;
for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) { for (std::map< K, T, C >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
SCM k = CONVERT_TO(i->first); SCM k = CONVERT_TO(i->first);
result = scm_cons(k,result); result = scm_cons(k,result);
} }
@ -475,12 +475,12 @@ namespace std {
%enddef %enddef
%define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO) %define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
template<class K> class map<K,T> { template<class K> class map< K, T, C > {
%typemap(in) map<K,T> { %typemap(in) map< K, T, C > {
if (scm_is_null($input)) { if (scm_is_null($input)) {
$1 = std::map< K, T >(); $1 = std::map< K, T, C >();
} else if (scm_is_pair($input)) { } else if (scm_is_pair($input)) {
$1 = std::map< K, T >(); $1 = std::map< K, T, C >();
SCM alist = $input; SCM alist = $input;
while (!scm_is_null(alist)) { while (!scm_is_null(alist)) {
K* k; K* k;
@ -497,7 +497,7 @@ namespace std {
val = SCM_CAR(val); val = SCM_CAR(val);
if (!CHECK(val)) if (!CHECK(val))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
} }
(($1_type &)$1)[*k] = CONVERT_FROM(val); (($1_type &)$1)[*k] = CONVERT_FROM(val);
alist = SCM_CDR(alist); alist = SCM_CDR(alist);
@ -507,13 +507,13 @@ namespace std {
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0)); SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
} }
} }
%typemap(in) const map<K,T>& (std::map<K,T> temp), %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp),
const map<K,T>* (std::map<K,T> temp) { const map< K, T, C >* (std::map< K, T, C > temp) {
if (scm_is_null($input)) { if (scm_is_null($input)) {
temp = std::map< K, T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
} else if (scm_is_pair($input)) { } else if (scm_is_pair($input)) {
temp = std::map< K, T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
SCM alist = $input; SCM alist = $input;
while (!scm_is_null(alist)) { while (!scm_is_null(alist)) {
@ -531,7 +531,7 @@ namespace std {
val = SCM_CAR(val); val = SCM_CAR(val);
if (!CHECK(val)) if (!CHECK(val))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
} }
temp[*k] = CONVERT_FROM(val); temp[*k] = CONVERT_FROM(val);
alist = SCM_CDR(alist); alist = SCM_CDR(alist);
@ -540,9 +540,9 @@ namespace std {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0); $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
} }
} }
%typemap(out) map<K,T> { %typemap(out) map< K, T, C > {
SCM alist = SCM_EOL; SCM alist = SCM_EOL;
for (std::map< K, T >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) { for (std::map< K, T, C >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) {
K* key = new K(i->first); K* key = new K(i->first);
SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1); SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
SCM x = CONVERT_TO(i->second); SCM x = CONVERT_TO(i->second);
@ -551,7 +551,7 @@ namespace std {
} }
$result = alist; $result = alist;
} }
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> { %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
// native sequence? // native sequence?
if (scm_is_null($input)) { if (scm_is_null($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -583,7 +583,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map< K, T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0) $&1_descriptor, 0) == 0)
$1 = 1; $1 = 1;
@ -591,8 +591,8 @@ namespace std {
$1 = 0; $1 = 0;
} }
} }
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
const map<K,T>* { const map< K, T, C >* {
// native sequence? // native sequence?
if (scm_is_null($input)) { if (scm_is_null($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -624,7 +624,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map< K, T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0) $1_descriptor, 0) == 0)
$1 = 1; $1 = 1;
@ -641,14 +641,14 @@ namespace std {
%rename("has-key?") has_key; %rename("has-key?") has_key;
public: public:
map(); map();
map(const map< K, T > &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
T __getitem__(const K& key) throw (std::out_of_range) { T __getitem__(const K& key) throw (std::out_of_range) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -658,19 +658,19 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void __delitem__(const K& key) throw (std::out_of_range) { void __delitem__(const K& key) throw (std::out_of_range) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
SCM keys() { SCM keys() {
SCM result = SCM_EOL; SCM result = SCM_EOL;
for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) { for (std::map< K, T, C >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
K* key = new K(i->first); K* key = new K(i->first);
SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1); SCM k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
result = scm_cons(k,result); result = scm_cons(k,result);
@ -683,12 +683,12 @@ namespace std {
%define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO, %define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO,
T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO) T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
template<> class map<K,T> { template<> class map< K, T, C > {
%typemap(in) map<K,T> { %typemap(in) map< K, T, C > {
if (scm_is_null($input)) { if (scm_is_null($input)) {
$1 = std::map< K, T >(); $1 = std::map< K, T, C >();
} else if (scm_is_pair($input)) { } else if (scm_is_pair($input)) {
$1 = std::map< K, T >(); $1 = std::map< K, T, C >();
SCM alist = $input; SCM alist = $input;
while (!scm_is_null(alist)) { while (!scm_is_null(alist)) {
SCM entry, key, val; SCM entry, key, val;
@ -699,14 +699,14 @@ namespace std {
val = SCM_CDR(entry); val = SCM_CDR(entry);
if (!CHECK_K(key)) if (!CHECK_K(key))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
if (!CHECK_T(val)) { if (!CHECK_T(val)) {
if (!scm_is_pair(val)) if (!scm_is_pair(val))
SWIG_exception(SWIG_TypeError,"alist expected"); SWIG_exception(SWIG_TypeError,"alist expected");
val = SCM_CAR(val); val = SCM_CAR(val);
if (!CHECK_T(val)) if (!CHECK_T(val))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
} }
(($1_type &)$1)[CONVERT_K_FROM(key)] = (($1_type &)$1)[CONVERT_K_FROM(key)] =
CONVERT_T_FROM(val); CONVERT_T_FROM(val);
@ -717,13 +717,13 @@ namespace std {
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0)); SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
} }
} }
%typemap(in) const map<K,T>& (std::map<K,T> temp), %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp),
const map<K,T>* (std::map<K,T> temp) { const map< K, T, C >* (std::map< K, T, C > temp) {
if (scm_is_null($input)) { if (scm_is_null($input)) {
temp = std::map< K, T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
} else if (scm_is_pair($input)) { } else if (scm_is_pair($input)) {
temp = std::map< K, T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
SCM alist = $input; SCM alist = $input;
while (!scm_is_null(alist)) { while (!scm_is_null(alist)) {
@ -735,14 +735,14 @@ namespace std {
val = SCM_CDR(entry); val = SCM_CDR(entry);
if (!CHECK_K(key)) if (!CHECK_K(key))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
if (!CHECK_T(val)) { if (!CHECK_T(val)) {
if (!scm_is_pair(val)) if (!scm_is_pair(val))
SWIG_exception(SWIG_TypeError,"alist expected"); SWIG_exception(SWIG_TypeError,"alist expected");
val = SCM_CAR(val); val = SCM_CAR(val);
if (!CHECK_T(val)) if (!CHECK_T(val))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
} }
temp[CONVERT_K_FROM(key)] = CONVERT_T_FROM(val); temp[CONVERT_K_FROM(key)] = CONVERT_T_FROM(val);
alist = SCM_CDR(alist); alist = SCM_CDR(alist);
@ -751,9 +751,9 @@ namespace std {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0); $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
} }
} }
%typemap(out) map<K,T> { %typemap(out) map< K, T, C > {
SCM alist = SCM_EOL; SCM alist = SCM_EOL;
for (std::map< K, T >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) { for (std::map< K, T, C >::reverse_iterator i=$1.rbegin(); i!=$1.rend(); ++i) {
SCM k = CONVERT_K_TO(i->first); SCM k = CONVERT_K_TO(i->first);
SCM x = CONVERT_T_TO(i->second); SCM x = CONVERT_T_TO(i->second);
SCM entry = scm_cons(k,x); SCM entry = scm_cons(k,x);
@ -761,7 +761,7 @@ namespace std {
} }
$result = alist; $result = alist;
} }
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> { %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
// native sequence? // native sequence?
if (scm_is_null($input)) { if (scm_is_null($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -792,7 +792,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map< K, T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) == 0) $&1_descriptor, 0) == 0)
$1 = 1; $1 = 1;
@ -800,8 +800,8 @@ namespace std {
$1 = 0; $1 = 0;
} }
} }
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
const map<K,T>* { const map< K, T, C >* {
// native sequence? // native sequence?
if (scm_is_null($input)) { if (scm_is_null($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -832,7 +832,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map< K, T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) == 0) $1_descriptor, 0) == 0)
$1 = 1; $1 = 1;
@ -849,14 +849,14 @@ namespace std {
%rename("has-key?") has_key; %rename("has-key?") has_key;
public: public:
map(); map();
map(const map< K, T> &); map(const map< K, T, C> &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
T __getitem__(K key) throw (std::out_of_range) { T __getitem__(K key) throw (std::out_of_range) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -866,19 +866,19 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void __delitem__(K key) throw (std::out_of_range) { void __delitem__(K key) throw (std::out_of_range) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(K key) { bool has_key(K key) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
SCM keys() { SCM keys() {
SCM result = SCM_EOL; SCM result = SCM_EOL;
for (std::map< K, T >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) { for (std::map< K, T, C >::reverse_iterator i=self->rbegin(); i!=self->rend(); ++i) {
SCM k = CONVERT_K_TO(i->first); SCM k = CONVERT_K_TO(i->first);
result = scm_cons(k,result); result = scm_cons(k,result);
} }

8
Lib/java/std_map.i
View file

@ -25,14 +25,14 @@ namespace std {
typedef K key_type; typedef K key_type;
typedef T mapped_type; typedef T mapped_type;
map(); map();
map(const map<K,T,C> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
const T& get(const K& key) throw (std::out_of_range) { const T& get(const K& key) throw (std::out_of_range) {
std::map<K,T,C >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -42,14 +42,14 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void del(const K& key) throw (std::out_of_range) { void del(const K& key) throw (std::out_of_range) {
std::map<K,T,C >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map<K,T,C >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
} }

10
Lib/lua/std_map.i
View file

@ -20,7 +20,7 @@
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T, class C = std::less<K> > class map {
// add typemaps here // add typemaps here
public: public:
typedef size_t size_type; typedef size_t size_type;
@ -28,14 +28,14 @@ namespace std {
typedef K key_type; typedef K key_type;
typedef T mapped_type; typedef T mapped_type;
map(); map();
map(const map<K,T> &); map(const map< K, T, C> &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
const T& get(const K& key) throw (std::out_of_range) { const T& get(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -45,14 +45,14 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void del(const K& key) throw (std::out_of_range) { void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
} }

192
Lib/mzscheme/std_map.i
View file

@ -40,12 +40,12 @@
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T, class C = std::less<K> > class map {
%typemap(in) map<K,T> (std::map<K,T>* m) { %typemap(in) map< K, T, C > (std::map< K, T, C >* m) {
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
$1 = std::map<K,T >(); $1 = std::map< K, T, C >();
} else if (SCHEME_PAIRP($input)) { } else if (SCHEME_PAIRP($input)) {
$1 = std::map<K,T >(); $1 = std::map< K, T, C >();
Scheme_Object* alist = $input; Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) { while (!SCHEME_NULLP(alist)) {
K* k; K* k;
@ -72,15 +72,15 @@ namespace std {
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0)); SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
} }
} }
%typemap(in) const map<K,T>& (std::map<K,T> temp, %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp,
std::map<K,T>* m), std::map< K, T, C >* m),
const map<K,T>* (std::map<K,T> temp, const map< K, T, C >* (std::map< K, T, C > temp,
std::map<K,T>* m) { std::map< K, T, C >* m) {
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
temp = std::map<K,T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
} else if (SCHEME_PAIRP($input)) { } else if (SCHEME_PAIRP($input)) {
temp = std::map<K,T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
Scheme_Object* alist = $input; Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) { while (!SCHEME_NULLP(alist)) {
@ -107,9 +107,9 @@ namespace std {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0); $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
} }
} }
%typemap(out) map<K,T> { %typemap(out) map< K, T, C > {
Scheme_Object* alist = scheme_null; Scheme_Object* alist = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin(); for (std::map< K, T, C >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) { i!=$1.rend(); ++i) {
K* key = new K(i->first); K* key = new K(i->first);
T* val = new T(i->second); T* val = new T(i->second);
@ -120,7 +120,7 @@ namespace std {
} }
$result = alist; $result = alist;
} }
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> { %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
/* native sequence? */ /* native sequence? */
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -156,7 +156,7 @@ namespace std {
} }
} else { } else {
/* wrapped map? */ /* wrapped map? */
std::map<K,T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) != -1) $&1_descriptor, 0) != -1)
$1 = 1; $1 = 1;
@ -164,8 +164,8 @@ namespace std {
$1 = 0; $1 = 0;
} }
} }
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
const map<K,T>* { const map< K, T, C >* {
/* native sequence? */ /* native sequence? */
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -201,7 +201,7 @@ namespace std {
} }
} else { } else {
/* wrapped map? */ /* wrapped map? */
std::map<K,T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) != -1) $1_descriptor, 0) != -1)
$1 = 1; $1 = 1;
@ -222,14 +222,14 @@ namespace std {
typedef K key_type; typedef K key_type;
typedef T mapped_type; typedef T mapped_type;
map(); map();
map(const map<K,T> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
T& __getitem__(const K& key) throw (std::out_of_range) { T& __getitem__(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -239,19 +239,19 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void __delitem__(const K& key) throw (std::out_of_range) { void __delitem__(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
Scheme_Object* keys() { Scheme_Object* keys() {
Scheme_Object* result = scheme_null; Scheme_Object* result = scheme_null;
for (std::map<K,T >::reverse_iterator i=self->rbegin(); for (std::map< K, T, C >::reverse_iterator i=self->rbegin();
i!=self->rend(); ++i) { i!=self->rend(); ++i) {
K* key = new K(i->first); K* key = new K(i->first);
Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1); Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
@ -267,12 +267,12 @@ namespace std {
%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO) %define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
template<class T> class map<K,T> { template<class T> class map< K, T, C > {
%typemap(in) map<K,T> (std::map<K,T>* m) { %typemap(in) map< K, T, C > (std::map< K, T, C >* m) {
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
$1 = std::map<K,T >(); $1 = std::map< K, T, C >();
} else if (SCHEME_PAIRP($input)) { } else if (SCHEME_PAIRP($input)) {
$1 = std::map<K,T >(); $1 = std::map< K, T, C >();
Scheme_Object* alist = $input; Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) { while (!SCHEME_NULLP(alist)) {
T* x; T* x;
@ -284,7 +284,7 @@ namespace std {
val = scheme_cdr(entry); val = scheme_cdr(entry);
if (!CHECK(key)) if (!CHECK(key))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
if (SWIG_ConvertPtr(val,(void**) &x, if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) == -1) { $descriptor(T *), 0) == -1) {
if (!SCHEME_PAIRP(val)) if (!SCHEME_PAIRP(val))
@ -300,15 +300,15 @@ namespace std {
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0)); SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
} }
} }
%typemap(in) const map<K,T>& (std::map<K,T> temp, %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp,
std::map<K,T>* m), std::map< K, T, C >* m),
const map<K,T>* (std::map<K,T> temp, const map< K, T, C >* (std::map< K, T, C > temp,
std::map<K,T>* m) { std::map< K, T, C >* m) {
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
temp = std::map<K,T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
} else if (SCHEME_PAIRP($input)) { } else if (SCHEME_PAIRP($input)) {
temp = std::map<K,T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
Scheme_Object* alist = $input; Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) { while (!SCHEME_NULLP(alist)) {
@ -321,7 +321,7 @@ namespace std {
val = scheme_cdr(entry); val = scheme_cdr(entry);
if (!CHECK(key)) if (!CHECK(key))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
if (SWIG_ConvertPtr(val,(void**) &x, if (SWIG_ConvertPtr(val,(void**) &x,
$descriptor(T *), 0) == -1) { $descriptor(T *), 0) == -1) {
if (!SCHEME_PAIRP(val)) if (!SCHEME_PAIRP(val))
@ -336,9 +336,9 @@ namespace std {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0); $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
} }
} }
%typemap(out) map<K,T> { %typemap(out) map< K, T, C > {
Scheme_Object* alist = scheme_null; Scheme_Object* alist = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin(); for (std::map< K, T, C >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) { i!=$1.rend(); ++i) {
T* val = new T(i->second); T* val = new T(i->second);
Scheme_Object* k = CONVERT_TO(i->first); Scheme_Object* k = CONVERT_TO(i->first);
@ -348,7 +348,7 @@ namespace std {
} }
$result = alist; $result = alist;
} }
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> { %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
// native sequence? // native sequence?
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -382,7 +382,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map<K,T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) != -1) $&1_descriptor, 0) != -1)
$1 = 1; $1 = 1;
@ -390,8 +390,8 @@ namespace std {
$1 = 0; $1 = 0;
} }
} }
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
const map<K,T>* { const map< K, T, C >* {
// native sequence? // native sequence?
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -425,7 +425,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map<K,T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) != -1) $1_descriptor, 0) != -1)
$1 = 1; $1 = 1;
@ -442,14 +442,14 @@ namespace std {
%rename("has-key?") has_key; %rename("has-key?") has_key;
public: public:
map(); map();
map(const map<K,T> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
T& __getitem__(K key) throw (std::out_of_range) { T& __getitem__(K key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -459,19 +459,19 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void __delitem__(K key) throw (std::out_of_range) { void __delitem__(K key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(K key) { bool has_key(K key) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
Scheme_Object* keys() { Scheme_Object* keys() {
Scheme_Object* result = scheme_null; Scheme_Object* result = scheme_null;
for (std::map<K,T >::reverse_iterator i=self->rbegin(); for (std::map< K, T, C >::reverse_iterator i=self->rbegin();
i!=self->rend(); ++i) { i!=self->rend(); ++i) {
Scheme_Object* k = CONVERT_TO(i->first); Scheme_Object* k = CONVERT_TO(i->first);
result = scheme_make_pair(k,result); result = scheme_make_pair(k,result);
@ -483,12 +483,12 @@ namespace std {
%enddef %enddef
%define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO) %define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
template<class K> class map<K,T> { template<class K> class map< K, T, C > {
%typemap(in) map<K,T> (std::map<K,T>* m) { %typemap(in) map< K, T, C > (std::map< K, T, C >* m) {
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
$1 = std::map<K,T >(); $1 = std::map< K, T, C >();
} else if (SCHEME_PAIRP($input)) { } else if (SCHEME_PAIRP($input)) {
$1 = std::map<K,T >(); $1 = std::map< K, T, C >();
Scheme_Object* alist = $input; Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) { while (!SCHEME_NULLP(alist)) {
K* k; K* k;
@ -505,7 +505,7 @@ namespace std {
val = scheme_car(val); val = scheme_car(val);
if (!CHECK(val)) if (!CHECK(val))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
} }
(($1_type &)$1)[*k] = CONVERT_FROM(val); (($1_type &)$1)[*k] = CONVERT_FROM(val);
alist = scheme_cdr(alist); alist = scheme_cdr(alist);
@ -515,15 +515,15 @@ namespace std {
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0)); SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
} }
} }
%typemap(in) const map<K,T>& (std::map<K,T> temp, %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp,
std::map<K,T>* m), std::map< K, T, C >* m),
const map<K,T>* (std::map<K,T> temp, const map< K, T, C >* (std::map< K, T, C > temp,
std::map<K,T>* m) { std::map< K, T, C >* m) {
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
temp = std::map<K,T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
} else if (SCHEME_PAIRP($input)) { } else if (SCHEME_PAIRP($input)) {
temp = std::map<K,T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
Scheme_Object* alist = $input; Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) { while (!SCHEME_NULLP(alist)) {
@ -541,7 +541,7 @@ namespace std {
val = scheme_car(val); val = scheme_car(val);
if (!CHECK(val)) if (!CHECK(val))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
} }
temp[*k] = CONVERT_FROM(val); temp[*k] = CONVERT_FROM(val);
alist = scheme_cdr(alist); alist = scheme_cdr(alist);
@ -550,9 +550,9 @@ namespace std {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0); $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
} }
} }
%typemap(out) map<K,T> { %typemap(out) map< K, T, C > {
Scheme_Object* alist = scheme_null; Scheme_Object* alist = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin(); for (std::map< K, T, C >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) { i!=$1.rend(); ++i) {
K* key = new K(i->first); K* key = new K(i->first);
Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1); Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
@ -562,7 +562,7 @@ namespace std {
} }
$result = alist; $result = alist;
} }
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> { %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
// native sequence? // native sequence?
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -595,7 +595,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map<K,T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) != -1) $&1_descriptor, 0) != -1)
$1 = 1; $1 = 1;
@ -603,8 +603,8 @@ namespace std {
$1 = 0; $1 = 0;
} }
} }
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
const map<K,T>* { const map< K, T, C >* {
// native sequence? // native sequence?
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -637,7 +637,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map<K,T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) != -1) $1_descriptor, 0) != -1)
$1 = 1; $1 = 1;
@ -654,14 +654,14 @@ namespace std {
%rename("has-key?") has_key; %rename("has-key?") has_key;
public: public:
map(); map();
map(const map<K,T> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
T __getitem__(const K& key) throw (std::out_of_range) { T __getitem__(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -671,19 +671,19 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void __delitem__(const K& key) throw (std::out_of_range) { void __delitem__(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
Scheme_Object* keys() { Scheme_Object* keys() {
Scheme_Object* result = scheme_null; Scheme_Object* result = scheme_null;
for (std::map<K,T >::reverse_iterator i=self->rbegin(); for (std::map< K, T, C >::reverse_iterator i=self->rbegin();
i!=self->rend(); ++i) { i!=self->rend(); ++i) {
K* key = new K(i->first); K* key = new K(i->first);
Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1); Scheme_Object* k = SWIG_NewPointerObj(key,$descriptor(K *), 1);
@ -697,12 +697,12 @@ namespace std {
%define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO, %define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO,
T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO) T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
template<> class map<K,T> { template<> class map< K, T, C > {
%typemap(in) map<K,T> (std::map<K,T>* m) { %typemap(in) map< K, T, C > (std::map< K, T, C >* m) {
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
$1 = std::map<K,T >(); $1 = std::map< K, T, C >();
} else if (SCHEME_PAIRP($input)) { } else if (SCHEME_PAIRP($input)) {
$1 = std::map<K,T >(); $1 = std::map< K, T, C >();
Scheme_Object* alist = $input; Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) { while (!SCHEME_NULLP(alist)) {
Scheme_Object *entry, *key, *val; Scheme_Object *entry, *key, *val;
@ -713,14 +713,14 @@ namespace std {
val = scheme_cdr(entry); val = scheme_cdr(entry);
if (!CHECK_K(key)) if (!CHECK_K(key))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
if (!CHECK_T(val)) { if (!CHECK_T(val)) {
if (!SCHEME_PAIRP(val)) if (!SCHEME_PAIRP(val))
SWIG_exception(SWIG_TypeError,"alist expected"); SWIG_exception(SWIG_TypeError,"alist expected");
val = scheme_car(val); val = scheme_car(val);
if (!CHECK_T(val)) if (!CHECK_T(val))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
} }
(($1_type &)$1)[CONVERT_K_FROM(key)] = (($1_type &)$1)[CONVERT_K_FROM(key)] =
CONVERT_T_FROM(val); CONVERT_T_FROM(val);
@ -731,15 +731,15 @@ namespace std {
SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0)); SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0));
} }
} }
%typemap(in) const map<K,T>& (std::map<K,T> temp, %typemap(in) const map< K, T, C >& (std::map< K, T, C > temp,
std::map<K,T>* m), std::map< K, T, C >* m),
const map<K,T>* (std::map<K,T> temp, const map< K, T, C >* (std::map< K, T, C > temp,
std::map<K,T>* m) { std::map< K, T, C >* m) {
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
temp = std::map<K,T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
} else if (SCHEME_PAIRP($input)) { } else if (SCHEME_PAIRP($input)) {
temp = std::map<K,T >(); temp = std::map< K, T, C >();
$1 = &temp; $1 = &temp;
Scheme_Object* alist = $input; Scheme_Object* alist = $input;
while (!SCHEME_NULLP(alist)) { while (!SCHEME_NULLP(alist)) {
@ -751,14 +751,14 @@ namespace std {
val = scheme_cdr(entry); val = scheme_cdr(entry);
if (!CHECK_K(key)) if (!CHECK_K(key))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
if (!CHECK_T(val)) { if (!CHECK_T(val)) {
if (!SCHEME_PAIRP(val)) if (!SCHEME_PAIRP(val))
SWIG_exception(SWIG_TypeError,"alist expected"); SWIG_exception(SWIG_TypeError,"alist expected");
val = scheme_car(val); val = scheme_car(val);
if (!CHECK_T(val)) if (!CHECK_T(val))
SWIG_exception(SWIG_TypeError, SWIG_exception(SWIG_TypeError,
"map<" #K "," #T "> expected"); "map<" #K "," #T "," #C "> expected");
} }
temp[CONVERT_K_FROM(key)] = CONVERT_T_FROM(val); temp[CONVERT_K_FROM(key)] = CONVERT_T_FROM(val);
alist = scheme_cdr(alist); alist = scheme_cdr(alist);
@ -767,9 +767,9 @@ namespace std {
$1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0); $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0);
} }
} }
%typemap(out) map<K,T> { %typemap(out) map< K, T, C > {
Scheme_Object* alist = scheme_null; Scheme_Object* alist = scheme_null;
for (std::map<K,T >::reverse_iterator i=$1.rbegin(); for (std::map< K, T, C >::reverse_iterator i=$1.rbegin();
i!=$1.rend(); ++i) { i!=$1.rend(); ++i) {
Scheme_Object* k = CONVERT_K_TO(i->first); Scheme_Object* k = CONVERT_K_TO(i->first);
Scheme_Object* x = CONVERT_T_TO(i->second); Scheme_Object* x = CONVERT_T_TO(i->second);
@ -778,7 +778,7 @@ namespace std {
} }
$result = alist; $result = alist;
} }
%typecheck(SWIG_TYPECHECK_MAP) map<K,T> { %typecheck(SWIG_TYPECHECK_MAP) map< K, T, C > {
// native sequence? // native sequence?
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -809,7 +809,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map<K,T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$&1_descriptor, 0) != -1) $&1_descriptor, 0) != -1)
$1 = 1; $1 = 1;
@ -817,8 +817,8 @@ namespace std {
$1 = 0; $1 = 0;
} }
} }
%typecheck(SWIG_TYPECHECK_MAP) const map<K,T>&, %typecheck(SWIG_TYPECHECK_MAP) const map< K, T, C >&,
const map<K,T>* { const map< K, T, C >* {
// native sequence? // native sequence?
if (SCHEME_NULLP($input)) { if (SCHEME_NULLP($input)) {
/* an empty sequence can be of any type */ /* an empty sequence can be of any type */
@ -849,7 +849,7 @@ namespace std {
} }
} else { } else {
// wrapped map? // wrapped map?
std::map<K,T >* m; std::map< K, T, C >* m;
if (SWIG_ConvertPtr($input,(void **) &m, if (SWIG_ConvertPtr($input,(void **) &m,
$1_descriptor, 0) != -1) $1_descriptor, 0) != -1)
$1 = 1; $1 = 1;
@ -866,14 +866,14 @@ namespace std {
%rename("has-key?") has_key; %rename("has-key?") has_key;
public: public:
map(); map();
map(const map<K,T> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
T __getitem__(K key) throw (std::out_of_range) { T __getitem__(K key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -883,19 +883,19 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void __delitem__(K key) throw (std::out_of_range) { void __delitem__(K key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(K key) { bool has_key(K key) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
Scheme_Object* keys() { Scheme_Object* keys() {
Scheme_Object* result = scheme_null; Scheme_Object* result = scheme_null;
for (std::map<K,T >::reverse_iterator i=self->rbegin(); for (std::map< K, T, C >::reverse_iterator i=self->rbegin();
i!=self->rend(); ++i) { i!=self->rend(); ++i) {
Scheme_Object* k = CONVERT_K_TO(i->first); Scheme_Object* k = CONVERT_K_TO(i->first);
result = scheme_make_pair(k,result); result = scheme_make_pair(k,result);

10
Lib/ocaml/std_map.i
View file

@ -19,7 +19,7 @@
// exported class // exported class
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T, class C = std::less<K> > class map {
// add typemaps here // add typemaps here
public: public:
typedef size_t size_type; typedef size_t size_type;
@ -27,14 +27,14 @@ namespace std {
typedef K key_type; typedef K key_type;
typedef T mapped_type; typedef T mapped_type;
map(); map();
map(const map<K,T> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
const T& get(const K& key) throw (std::out_of_range) { const T& get(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -44,14 +44,14 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void del(const K& key) throw (std::out_of_range) { void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
} }

10
Lib/perl5/std_map.i
View file

@ -20,7 +20,7 @@
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T, class C = std::less<K> > class map {
// add typemaps here // add typemaps here
public: public:
typedef size_t size_type; typedef size_t size_type;
@ -28,14 +28,14 @@ namespace std {
typedef K key_type; typedef K key_type;
typedef T mapped_type; typedef T mapped_type;
map(); map();
map(const map<K,T> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
const T& get(const K& key) throw (std::out_of_range) { const T& get(const K& key) throw (std::out_of_range) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -45,14 +45,14 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void del(const K& key) throw (std::out_of_range) { void del(const K& key) throw (std::out_of_range) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map< K, T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
} }

10
Lib/php/std_map.i
View file

@ -20,7 +20,7 @@
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T, class C = std::less<K> > class map {
// add typemaps here // add typemaps here
public: public:
typedef size_t size_type; typedef size_t size_type;
@ -28,13 +28,13 @@ namespace std {
typedef K key_type; typedef K key_type;
typedef T mapped_type; typedef T mapped_type;
map(); map();
map(const map<K,T> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
void clear(); void clear();
%extend { %extend {
const T& get(const K& key) throw (std::out_of_range) { const T& get(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -44,14 +44,14 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void del(const K& key) throw (std::out_of_range) { void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
bool is_empty() const { bool is_empty() const {

10
Lib/scilab/std_map.i
View file

@ -19,18 +19,18 @@
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T, class C = std::less<K> > class map {
// add typemaps here // add typemaps here
public: public:
map(); map();
map(const map<K,T> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
const T& get(const K& key) throw (std::out_of_range) { const T& get(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -40,14 +40,14 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void del(const K& key) throw (std::out_of_range) { void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
} }

10
Lib/tcl/std_map.i
View file

@ -19,7 +19,7 @@
namespace std { namespace std {
template<class K, class T> class map { template<class K, class T, class C = std::less<K> > class map {
// add typemaps here // add typemaps here
public: public:
typedef size_t size_type; typedef size_t size_type;
@ -27,14 +27,14 @@ namespace std {
typedef K key_type; typedef K key_type;
typedef T mapped_type; typedef T mapped_type;
map(); map();
map(const map<K,T> &); map(const map< K, T, C > &);
unsigned int size() const; unsigned int size() const;
bool empty() const; bool empty() const;
void clear(); void clear();
%extend { %extend {
const T& get(const K& key) throw (std::out_of_range) { const T& get(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
return i->second; return i->second;
else else
@ -44,14 +44,14 @@ namespace std {
(*self)[key] = x; (*self)[key] = x;
} }
void del(const K& key) throw (std::out_of_range) { void del(const K& key) throw (std::out_of_range) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
if (i != self->end()) if (i != self->end())
self->erase(i); self->erase(i);
else else
throw std::out_of_range("key not found"); throw std::out_of_range("key not found");
} }
bool has_key(const K& key) { bool has_key(const K& key) {
std::map<K,T >::iterator i = self->find(key); std::map< K, T, C >::iterator i = self->find(key);
return i != self->end(); return i != self->end();
} }
} }