diff options
Diffstat (limited to 'devtools/swigwin-1.3.34/Lib/mzscheme/std_vector.i')
| -rw-r--r-- | devtools/swigwin-1.3.34/Lib/mzscheme/std_vector.i | 436 |
1 files changed, 436 insertions, 0 deletions
diff --git a/devtools/swigwin-1.3.34/Lib/mzscheme/std_vector.i b/devtools/swigwin-1.3.34/Lib/mzscheme/std_vector.i new file mode 100644 index 0000000..90a52fc --- /dev/null +++ b/devtools/swigwin-1.3.34/Lib/mzscheme/std_vector.i @@ -0,0 +1,436 @@ +/* ----------------------------------------------------------------------------- + * 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_vector.i + * + * SWIG typemaps for std::vector + * ----------------------------------------------------------------------------- */ + +%include <std_common.i> + +// ------------------------------------------------------------------------ +// std::vector +// +// The aim of all that follows would be to integrate std::vector with +// MzScheme as much as possible, namely, to allow the user to pass and +// be returned MzScheme vectors or lists. +// const declarations are used to guess the intent of the function being +// exported; therefore, the following rationale is applied: +// +// -- f(std::vector<T>), f(const std::vector<T>&), f(const std::vector<T>*): +// the parameter being read-only, either a MzScheme sequence or a +// previously wrapped std::vector<T> can be passed. +// -- f(std::vector<T>&), f(std::vector<T>*): +// the parameter must be modified; therefore, only a wrapped std::vector +// can be passed. +// -- std::vector<T> f(): +// the vector is returned by copy; therefore, a MzScheme vector of T:s +// is returned which is most easily used in other MzScheme functions +// -- std::vector<T>& f(), std::vector<T>* f(), const std::vector<T>& f(), +// const std::vector<T>* f(): +// the vector is returned by reference; therefore, a wrapped std::vector +// is returned +// ------------------------------------------------------------------------ + +%{ +#include <vector> +#include <algorithm> +#include <stdexcept> +%} + +// exported class + +namespace std { + + template<class T> class vector { + %typemap(in) vector<T> { + if (SCHEME_VECTORP($input)) { + unsigned int size = SCHEME_VEC_SIZE($input); + $1 = std::vector<T >(size); + Scheme_Object** items = SCHEME_VEC_ELS($input); + for (unsigned int i=0; i<size; i++) { + (($1_type &)$1)[i] = + *((T*) SWIG_MustGetPtr(items[i], + $descriptor(T *), + $argnum, 0)); + } + } else if (SCHEME_NULLP($input)) { + $1 = std::vector<T >(); + } else if (SCHEME_PAIRP($input)) { + Scheme_Object *head, *tail; + $1 = std::vector<T >(); + tail = $input; + while (!SCHEME_NULLP(tail)) { + head = scheme_car(tail); + tail = scheme_cdr(tail); + $1.push_back(*((T*)SWIG_MustGetPtr(head, + $descriptor(T *), + $argnum, 0))); + } + } else { + $1 = *(($&1_type) + SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0)); + } + } + %typemap(in) const vector<T>& (std::vector<T> temp), + const vector<T>* (std::vector<T> temp) { + if (SCHEME_VECTORP($input)) { + unsigned int size = SCHEME_VEC_SIZE($input); + temp = std::vector<T >(size); + $1 = &temp; + Scheme_Object** items = SCHEME_VEC_ELS($input); + for (unsigned int i=0; i<size; i++) { + temp[i] = *((T*) SWIG_MustGetPtr(items[i], + $descriptor(T *), + $argnum, 0)); + } + } else if (SCHEME_NULLP($input)) { + temp = std::vector<T >(); + $1 = &temp; + } else if (SCHEME_PAIRP($input)) { + temp = std::vector<T >(); + $1 = &temp; + Scheme_Object *head, *tail; + tail = $input; + while (!SCHEME_NULLP(tail)) { + head = scheme_car(tail); + tail = scheme_cdr(tail); + temp.push_back(*((T*) SWIG_MustGetPtr(head, + $descriptor(T *), + $argnum, 0))); + } + } else { + $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum, 0); + } + } + %typemap(out) vector<T> { + $result = scheme_make_vector($1.size(),scheme_undefined); + Scheme_Object** els = SCHEME_VEC_ELS($result); + for (unsigned int i=0; i<$1.size(); i++) { + T* x = new T((($1_type &)$1)[i]); + els[i] = SWIG_NewPointerObj(x,$descriptor(T *), 1); + } + } + %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> { + /* native sequence? */ + if (SCHEME_VECTORP($input)) { + unsigned int size = SCHEME_VEC_SIZE($input); + if (size == 0) { + /* an empty sequence can be of any type */ + $1 = 1; + } else { + /* check the first element only */ + T* x; + Scheme_Object** items = SCHEME_VEC_ELS($input); + if (SWIG_ConvertPtr(items[0],(void**) &x, + $descriptor(T *), 0) != -1) + $1 = 1; + else + $1 = 0; + } + } else if (SCHEME_NULLP($input)) { + /* again, 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 (SWIG_ConvertPtr(head,(void**) &x, + $descriptor(T *), 0) != -1) + $1 = 1; + else + $1 = 0; + } else { + /* wrapped vector? */ + std::vector<T >* v; + if (SWIG_ConvertPtr($input,(void **) &v, + $&1_descriptor, 0) != -1) + $1 = 1; + else + $1 = 0; + } + } + %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T>&, + const vector<T>* { + /* native sequence? */ + if (SCHEME_VECTORP($input)) { + unsigned int size = SCHEME_VEC_SIZE($input); + if (size == 0) { + /* an empty sequence can be of any type */ + $1 = 1; + } else { + /* check the first element only */ + T* x; + Scheme_Object** items = SCHEME_VEC_ELS($input); + if (SWIG_ConvertPtr(items[0],(void**) &x, + $descriptor(T *), 0) != -1) + $1 = 1; + else + $1 = 0; + } + } else if (SCHEME_NULLP($input)) { + /* again, 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 (SWIG_ConvertPtr(head,(void**) &x, + $descriptor(T *), 0) != -1) + $1 = 1; + else + $1 = 0; + } else { + /* wrapped vector? */ + std::vector<T >* v; + if (SWIG_ConvertPtr($input,(void **) &v, + $1_descriptor, 0) != -1) + $1 = 1; + else + $1 = 0; + } + } + public: + vector(unsigned int size = 0); + vector(unsigned int size, const T& value); + vector(const vector<T>&); + %rename(length) size; + unsigned int size() const; + %rename("empty?") empty; + bool empty() const; + %rename("clear!") clear; + void clear(); + %rename("set!") set; + %rename("pop!") pop; + %rename("push!") push_back; + void push_back(const T& x); + %extend { + T pop() throw (std::out_of_range) { + if (self->size() == 0) + throw std::out_of_range("pop from empty vector"); + T x = self->back(); + self->pop_back(); + return x; + } + T& ref(int i) throw (std::out_of_range) { + int size = int(self->size()); + if (i>=0 && i<size) + return (*self)[i]; + else + throw std::out_of_range("vector index out of range"); + } + void set(int i, const T& x) throw (std::out_of_range) { + int size = int(self->size()); + if (i>=0 && i<size) + (*self)[i] = x; + else + throw std::out_of_range("vector index out of range"); + } + } + }; + + + // specializations for built-ins + + %define specialize_std_vector(T,CHECK,CONVERT_FROM,CONVERT_TO) + template<> class vector<T> { + %typemap(in) vector<T> { + if (SCHEME_VECTORP($input)) { + unsigned int size = SCHEME_VEC_SIZE($input); + $1 = std::vector<T >(size); + Scheme_Object** items = SCHEME_VEC_ELS($input); + for (unsigned int i=0; i<size; i++) { + Scheme_Object* o = items[i]; + if (CHECK(o)) + (($1_type &)$1)[i] = (T)(CONVERT_FROM(o)); + else + scheme_wrong_type(FUNC_NAME, "vector<" #T ">", + $argnum - 1, argc, argv); + } + } else if (SCHEME_NULLP($input)) { + $1 = std::vector<T >(); + } else if (SCHEME_PAIRP($input)) { + Scheme_Object *head, *tail; + $1 = std::vector<T >(); + tail = $input; + while (!SCHEME_NULLP(tail)) { + head = scheme_car(tail); + tail = scheme_cdr(tail); + if (CHECK(head)) + $1.push_back((T)(CONVERT_FROM(head))); + else + scheme_wrong_type(FUNC_NAME, "vector<" #T ">", + $argnum - 1, argc, argv); + } + } else { + $1 = *(($&1_type) + SWIG_MustGetPtr($input,$&1_descriptor,$argnum, 0)); + } + } + %typemap(in) const vector<T>& (std::vector<T> temp), + const vector<T>* (std::vector<T> temp) { + if (SCHEME_VECTORP($input)) { + unsigned int size = SCHEME_VEC_SIZE($input); + temp = std::vector<T >(size); + $1 = &temp; + Scheme_Object** items = SCHEME_VEC_ELS($input); + for (unsigned int i=0; i<size; i++) { + Scheme_Object* o = items[i]; + if (CHECK(o)) + temp[i] = (T)(CONVERT_FROM(o)); + else + scheme_wrong_type(FUNC_NAME, "vector<" #T ">", + $argnum - 1, argc, argv); + } + } else if (SCHEME_NULLP($input)) { + temp = std::vector<T >(); + $1 = &temp; + } else if (SCHEME_PAIRP($input)) { + temp = std::vector<T >(); + $1 = &temp; + Scheme_Object *head, *tail; + tail = $input; + while (!SCHEME_NULLP(tail)) { + head = scheme_car(tail); + tail = scheme_cdr(tail); + if (CHECK(head)) + temp.push_back((T)(CONVERT_FROM(head))); + else + scheme_wrong_type(FUNC_NAME, "vector<" #T ">", + $argnum - 1, argc, argv); + } + } else { + $1 = ($1_ltype) SWIG_MustGetPtr($input,$1_descriptor,$argnum - 1, 0); + } + } + %typemap(out) vector<T> { + $result = scheme_make_vector($1.size(),scheme_undefined); + Scheme_Object** els = SCHEME_VEC_ELS($result); + for (unsigned int i=0; i<$1.size(); i++) + els[i] = CONVERT_TO((($1_type &)$1)[i]); + } + %typecheck(SWIG_TYPECHECK_VECTOR) vector<T> { + /* native sequence? */ + if (SCHEME_VECTORP($input)) { + unsigned int size = SCHEME_VEC_SIZE($input); + if (size == 0) { + /* an empty sequence can be of any type */ + $1 = 1; + } else { + /* check the first element only */ + T* x; + Scheme_Object** items = SCHEME_VEC_ELS($input); + $1 = CHECK(items[0]) ? 1 : 0; + } + } else if (SCHEME_NULLP($input)) { + /* again, 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); + $1 = CHECK(head) ? 1 : 0; + } else { + /* wrapped vector? */ + std::vector<T >* v; + $1 = (SWIG_ConvertPtr($input,(void **) &v, + $&1_descriptor, 0) != -1) ? 1 : 0; + } + } + %typecheck(SWIG_TYPECHECK_VECTOR) const vector<T>&, + const vector<T>* { + /* native sequence? */ + if (SCHEME_VECTORP($input)) { + unsigned int size = SCHEME_VEC_SIZE($input); + if (size == 0) { + /* an empty sequence can be of any type */ + $1 = 1; + } else { + /* check the first element only */ + T* x; + Scheme_Object** items = SCHEME_VEC_ELS($input); + $1 = CHECK(items[0]) ? 1 : 0; + } + } else if (SCHEME_NULLP($input)) { + /* again, 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); + $1 = CHECK(head) ? 1 : 0; + } else { + /* wrapped vector? */ + std::vector<T >* v; + $1 = (SWIG_ConvertPtr($input,(void **) &v, + $1_descriptor, 0) != -1) ? 1 : 0; + } + } + public: + vector(unsigned int size = 0); + vector(unsigned int size, const T& value); + vector(const vector<T>&); + %rename(length) size; + unsigned int size() const; + %rename("empty?") empty; + bool empty() const; + %rename("clear!") clear; + void clear(); + %rename("set!") set; + %rename("pop!") pop; + %rename("push!") push_back; + void push_back(T x); + %extend { + T pop() throw (std::out_of_range) { + if (self->size() == 0) + throw std::out_of_range("pop from empty vector"); + T x = self->back(); + self->pop_back(); + return x; + } + T ref(int i) throw (std::out_of_range) { + int size = int(self->size()); + if (i>=0 && i<size) + return (*self)[i]; + else + throw std::out_of_range("vector index out of range"); + } + void set(int i, T x) throw (std::out_of_range) { + int size = int(self->size()); + if (i>=0 && i<size) + (*self)[i] = x; + else + throw std::out_of_range("vector index out of range"); + } + } + }; + %enddef + + specialize_std_vector(bool,SCHEME_BOOLP,SCHEME_TRUEP,\ + swig_make_boolean); + specialize_std_vector(char,SCHEME_INTP,SCHEME_INT_VAL,\ + scheme_make_integer_value); + specialize_std_vector(int,SCHEME_INTP,SCHEME_INT_VAL,\ + scheme_make_integer_value); + specialize_std_vector(short,SCHEME_INTP,SCHEME_INT_VAL,\ + scheme_make_integer_value); + specialize_std_vector(long,SCHEME_INTP,SCHEME_INT_VAL,\ + scheme_make_integer_value); + specialize_std_vector(unsigned char,SCHEME_INTP,SCHEME_INT_VAL,\ + scheme_make_integer_value); + specialize_std_vector(unsigned int,SCHEME_INTP,SCHEME_INT_VAL,\ + scheme_make_integer_value); + specialize_std_vector(unsigned short,SCHEME_INTP,SCHEME_INT_VAL,\ + scheme_make_integer_value); + specialize_std_vector(unsigned long,SCHEME_INTP,SCHEME_INT_VAL,\ + scheme_make_integer_value); + specialize_std_vector(float,SCHEME_REALP,scheme_real_to_double,\ + scheme_make_double); + specialize_std_vector(double,SCHEME_REALP,scheme_real_to_double,\ + scheme_make_double); + specialize_std_vector(std::string,SCHEME_STRINGP,swig_scm_to_string,\ + swig_make_string); + +} + |