summaryrefslogtreecommitdiff
path: root/devtools/swigwin-1.3.34/Lib/perl5/std_list.i
diff options
context:
space:
mode:
Diffstat (limited to 'devtools/swigwin-1.3.34/Lib/perl5/std_list.i')
-rw-r--r--devtools/swigwin-1.3.34/Lib/perl5/std_list.i368
1 files changed, 368 insertions, 0 deletions
diff --git a/devtools/swigwin-1.3.34/Lib/perl5/std_list.i b/devtools/swigwin-1.3.34/Lib/perl5/std_list.i
new file mode 100644
index 0000000..633e40d
--- /dev/null
+++ b/devtools/swigwin-1.3.34/Lib/perl5/std_list.i
@@ -0,0 +1,368 @@
+/* -----------------------------------------------------------------------------
+ * 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_list.i
+ *
+ * SWIG typemaps for std::list types
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+%include <exception.i>
+
+// containers
+
+
+// ------------------------------------------------------------------------
+// std::list
+//
+// The aim of all that follows would be to integrate std::list with
+// Perl as much as possible, namely, to allow the user to pass and
+// be returned Perl arrays.
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+//
+// -- f(std::list<T>), f(const std::list<T>&), f(const std::list<T>*):
+// the parameter being read-only, either a Perl sequence or a
+// previously wrapped std::list<T> can be passed.
+// -- f(std::list<T>&), f(std::list<T>*):
+// the parameter must be modified; therefore, only a wrapped std::list
+// can be passed.
+// -- std::list<T> f():
+// the list is returned by copy; therefore, a Perl sequence of T:s
+// is returned which is most easily used in other Perl functions
+// -- std::list<T>& f(), std::list<T>* f(), const std::list<T>& f(),
+// const std::list<T>* f():
+// the list is returned by reference; therefore, a wrapped std::list
+// is returned
+// ------------------------------------------------------------------------
+
+%{
+#include <list>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+// exported class
+
+namespace std {
+
+ template<class T> class list {
+ %typemap(in) list<T> (std::list<T>* v) {
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $&1_descriptor,1) != -1) {
+ $1 = *v;
+ } else if (SvROK($input)) {
+ AV *av = (AV *)SvRV($input);
+ if (SvTYPE(av) != SVt_PVAV)
+ SWIG_croak("Type error in argument $argnum of $symname. "
+ "Expected an array of " #T);
+ SV **tv;
+ I32 len = av_len(av) + 1;
+ T* obj;
+ for (int i=0; i<len; i++) {
+ tv = av_fetch(av, i, 0);
+ if (SWIG_ConvertPtr(*tv, (void **)&obj,
+ $descriptor(T *),0) != -1) {
+ $1.push_back(*obj);
+ } else {
+ SWIG_croak("Type error in argument $argnum of "
+ "$symname. "
+ "Expected an array of " #T);
+ }
+ }
+ } else {
+ SWIG_croak("Type error in argument $argnum of $symname. "
+ "Expected an array of " #T);
+ }
+ }
+ %typemap(in) const list<T>& (std::list<T> temp,
+ std::list<T>* v),
+ const list<T>* (std::list<T> temp,
+ std::list<T>* v) {
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_descriptor,1) != -1) {
+ $1 = v;
+ } else if (SvROK($input)) {
+ AV *av = (AV *)SvRV($input);
+ if (SvTYPE(av) != SVt_PVAV)
+ SWIG_croak("Type error in argument $argnum of $symname. "
+ "Expected an array of " #T);
+ SV **tv;
+ I32 len = av_len(av) + 1;
+ T* obj;
+ for (int i=0; i<len; i++) {
+ tv = av_fetch(av, i, 0);
+ if (SWIG_ConvertPtr(*tv, (void **)&obj,
+ $descriptor(T *),0) != -1) {
+ temp.push_back(*obj);
+ } else {
+ SWIG_croak("Type error in argument $argnum of "
+ "$symname. "
+ "Expected an array of " #T);
+ }
+ }
+ $1 = &temp;
+ } else {
+ SWIG_croak("Type error in argument $argnum of $symname. "
+ "Expected an array of " #T);
+ }
+ }
+ %typemap(out) list<T> {
+ std::list<T>::const_iterator i;
+ unsigned int j;
+ int len = $1.size();
+ SV **svs = new SV*[len];
+ for (i=$1.begin(), j=0; i!=$1.end(); i++, j++) {
+ T* ptr = new T(*i);
+ svs[j] = sv_newmortal();
+ SWIG_MakePtr(svs[j], (void*) ptr,
+ $descriptor(T *), $shadow|$owner);
+ }
+ AV *myav = av_make(len, svs);
+ delete[] svs;
+ $result = newRV_noinc((SV*) myav);
+ sv_2mortal($result);
+ argvi++;
+ }
+ %typecheck(SWIG_TYPECHECK_LIST) list<T> {
+ {
+ /* wrapped list? */
+ std::list<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_&descriptor,0) != -1) {
+ $1 = 1;
+ } else if (SvROK($input)) {
+ /* native sequence? */
+ AV *av = (AV *)SvRV($input);
+ if (SvTYPE(av) == SVt_PVAV) {
+ SV **tv;
+ I32 len = av_len(av) + 1;
+ if (len == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ T* obj;
+ tv = av_fetch(av, 0, 0);
+ if (SWIG_ConvertPtr(*tv, (void **)&obj,
+ $descriptor(T *),0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ } else {
+ $1 = 0;
+ }
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_LIST) const list<T>&,
+ const list<T>* {
+ {
+ /* wrapped list? */
+ std::list<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_descriptor,0) != -1) {
+ $1 = 1;
+ } else if (SvROK($input)) {
+ /* native sequence? */
+ AV *av = (AV *)SvRV($input);
+ if (SvTYPE(av) == SVt_PVAV) {
+ SV **tv;
+ I32 len = av_len(av) + 1;
+ if (len == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ T* obj;
+ tv = av_fetch(av, 0, 0);
+ if (SWIG_ConvertPtr(*tv, (void **)&obj,
+ $descriptor(T *),0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ } else {
+ $1 = 0;
+ }
+ }
+ }
+ public:
+ list();
+ list(const list<T> &);
+
+ unsigned int size() const;
+ bool empty() const;
+ void clear();
+ %rename(push) push_back;
+ void push_back(const T& x);
+ };
+
+
+ // specializations for built-ins
+
+ %define specialize_std_list(T,CHECK_T,TO_T,FROM_T)
+ template<> class list<T> {
+ %typemap(in) list<T> (std::list<T>* v) {
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $&1_descriptor,1) != -1){
+ $1 = *v;
+ } else if (SvROK($input)) {
+ AV *av = (AV *)SvRV($input);
+ if (SvTYPE(av) != SVt_PVAV)
+ SWIG_croak("Type error in argument $argnum of $symname. "
+ "Expected an array of " #T);
+ SV **tv;
+ I32 len = av_len(av) + 1;
+ for (int i=0; i<len; i++) {
+ tv = av_fetch(av, i, 0);
+ if (CHECK_T(*tv)) {
+ $1.push_back(TO_T(*tv));
+ } else {
+ SWIG_croak("Type error in argument $argnum of "
+ "$symname. "
+ "Expected an array of " #T);
+ }
+ }
+ } else {
+ SWIG_croak("Type error in argument $argnum of $symname. "
+ "Expected an array of " #T);
+ }
+ }
+ %typemap(in) const list<T>& (std::list<T> temp,
+ std::list<T>* v),
+ const list<T>* (std::list<T> temp,
+ std::list<T>* v) {
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_descriptor,1) != -1) {
+ $1 = v;
+ } else if (SvROK($input)) {
+ AV *av = (AV *)SvRV($input);
+ if (SvTYPE(av) != SVt_PVAV)
+ SWIG_croak("Type error in argument $argnum of $symname. "
+ "Expected an array of " #T);
+ SV **tv;
+ I32 len = av_len(av) + 1;
+ T* obj;
+ for (int i=0; i<len; i++) {
+ tv = av_fetch(av, i, 0);
+ if (CHECK_T(*tv)) {
+ temp.push_back(TO_T(*tv));
+ } else {
+ SWIG_croak("Type error in argument $argnum of "
+ "$symname. "
+ "Expected an array of " #T);
+ }
+ }
+ $1 = &temp;
+ } else {
+ SWIG_croak("Type error in argument $argnum of $symname. "
+ "Expected an array of " #T);
+ }
+ }
+ %typemap(out) list<T> {
+ std::list<T>::const_iterator i;
+ unsigned int j;
+ int len = $1.size();
+ SV **svs = new SV*[len];
+ for (i=$1.begin(), j=0; i!=$1.end(); i++, j++) {
+ svs[j] = sv_newmortal();
+ FROM_T(svs[j], *i);
+ }
+ AV *myav = av_make(len, svs);
+ delete[] svs;
+ $result = newRV_noinc((SV*) myav);
+ sv_2mortal($result);
+ argvi++;
+ }
+ %typecheck(SWIG_TYPECHECK_LIST) list<T> {
+ {
+ /* wrapped list? */
+ std::list<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_&descriptor,0) != -1) {
+ $1 = 1;
+ } else if (SvROK($input)) {
+ /* native sequence? */
+ AV *av = (AV *)SvRV($input);
+ if (SvTYPE(av) == SVt_PVAV) {
+ SV **tv;
+ I32 len = av_len(av) + 1;
+ if (len == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ tv = av_fetch(av, 0, 0);
+ if (CHECK_T(*tv))
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ } else {
+ $1 = 0;
+ }
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_LIST) const list<T>&,
+ const list<T>* {
+ {
+ /* wrapped list? */
+ std::list<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_descriptor,0) != -1) {
+ $1 = 1;
+ } else if (SvROK($input)) {
+ /* native sequence? */
+ AV *av = (AV *)SvRV($input);
+ if (SvTYPE(av) == SVt_PVAV) {
+ SV **tv;
+ I32 len = av_len(av) + 1;
+ if (len == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ tv = av_fetch(av, 0, 0);
+ if (CHECK_T(*tv))
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ } else {
+ $1 = 0;
+ }
+ }
+ }
+ public:
+ list();
+ list(const list<T> &);
+
+ unsigned int size() const;
+ bool empty() const;
+ void clear();
+ %rename(push) push_back;
+ void push_back(T x);
+ };
+ %enddef
+
+ specialize_std_list(bool,SvIOK,SvIVX,sv_setiv);
+ specialize_std_list(char,SvIOK,SvIVX,sv_setiv);
+ specialize_std_list(int,SvIOK,SvIVX,sv_setiv);
+ specialize_std_list(short,SvIOK,SvIVX,sv_setiv);
+ specialize_std_list(long,SvIOK,SvIVX,sv_setiv);
+ specialize_std_list(unsigned char,SvIOK,SvIVX,sv_setiv);
+ specialize_std_list(unsigned int,SvIOK,SvIVX,sv_setiv);
+ specialize_std_list(unsigned short,SvIOK,SvIVX,sv_setiv);
+ specialize_std_list(unsigned long,SvIOK,SvIVX,sv_setiv);
+ specialize_std_list(float,SvNIOK,SwigSvToNumber,sv_setnv);
+ specialize_std_list(double,SvNIOK,SwigSvToNumber,sv_setnv);
+ specialize_std_list(std::string,SvPOK,SvPVX,SwigSvFromString);
+
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-06 23:24:39 +0000