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

Merge branch 'stl-vector-ptrs'

Browse source 
* stl-vector-ptrs:
  Test case warning fixes for nodejs
  Fix testcase causing nodejs test failure
  UTL STL container descriptor checks
  Fix std::vector of pointers which failed if a pointer to a pointer of the container element type existed (Python)
  Remove unused traits.swg
This commit is contained in:
William S Fulton 2016-08-01 06:55:01 +01:00
commit 4ab3af90cb
32 changed files with 235 additions and 362 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Examples/test-suite/common.mk
View file

@ -87,7 +87,6 @@ CPP_TEST_BROKEN += \
director_nested_class \
exception_partial_info \
extend_variable \
li_std_vector_ptr \
li_boost_shared_ptr_template \
nested_private \
overload_complicated \
@ -588,6 +587,7 @@ CPP_STD_TEST_CASES += \
li_std_vector \
li_std_vector_enum \
li_std_vector_member_var\
li_std_vector_ptr \
smart_pointer_inherit \
template_typedef_fnc \
template_type_namespace \

6
Examples/test-suite/cpp_enum.i
View file

@ -6,6 +6,12 @@ The primary purpose of this testcase is to ensure that enums used along with the
%inline %{
#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
/* for anonymous enums */
/* dereferencing type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing] */
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
enum SOME_ENUM {ENUM_ONE, ENUM_TWO};
struct StructWithEnums {

6
Examples/test-suite/enum_thorough.i
View file

@ -47,6 +47,12 @@
%inline %{
#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
/* for anonymous enums */
/* dereferencing type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing] */
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
enum { AnonEnum1, AnonEnum2 = 100 };
enum { ReallyAnInteger = 200 };
//enum { AnonEnum3, AnonEnum4 } instance;

6
Examples/test-suite/enums.i
View file

@ -12,6 +12,12 @@
%inline %{
#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
/* for anonymous enums */
/* dereferencing type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing] */
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
typedef enum {
CSP_ITERATION_FWD,
CSP_ITERATION_BWD = 11

9
Examples/test-suite/go/li_std_vector_ptr_runme.go
View file

@ -1,12 +1,19 @@
package main
import . "./li_std_vector_ptr"
import "fmt"
func check(val1 int, val2 int) {
if val1 != val2 {
panic(fmt.Sprintf("Values are not the same %d %d", val1, val2))
}
}
func main() {
ip1 := MakeIntPtr(11)
ip2 := MakeIntPtr(22)
vi := NewIntPtrVector()
vi.Add(ip1)
vi.Add(ip2)
DisplayVector(vi)
check(GetValueFromVector(vi, 0), 11)
check(GetValueFromVector(vi, 1), 22)
}

68
Examples/test-suite/li_std_vector_ptr.i
View file

@ -1,4 +1,4 @@
// Bug 2359417
// SF Bug 2359417
%module li_std_vector_ptr
%include "std_vector.i"
@ -15,16 +15,76 @@ double* makeDoublePtr(double v) {
return new double(v);
}
#if 1
// pointer to pointer in the wrappers was preventing a vector of pointers from working
int** makeIntPtrPtr(int* v) {
return new int*(v);
}
#endif
void displayVector(std::vector<int *> vpi) {
cout << "displayVector..." << endl;
for (int i=0; i<vpi.size(); ++i)
for (size_t i=0; i<vpi.size(); ++i)
cout << *vpi[i] << endl;
}
int getValueFromVector(std::vector<int *> vpi, size_t index) {
return *vpi[index];
}
%}
// A not exposed to wrappers
%{
struct A {
int val;
A(int val) : val(val) {}
};
%}
%template(APtrVector) std::vector<A *>;
%inline %{
A *makeA(int val) { return new A(val); }
int getVal(A* a) { return a->val; }
int getVectorValueA(std::vector<A *> vpi, size_t index) {
return vpi[index]->val;
}
%}
// B is fully exposed to wrappers
%inline %{
struct B {
int val;
B(int val = 0) : val(val) {}
};
%}
%template(BPtrVector) std::vector<B *>;
%inline %{
B *makeB(int val) { return new B(val); }
int getVal(B* b) { return b->val; }
int getVectorValueB(std::vector<B *> vpi, size_t index) {
return vpi[index]->val;
}
%}
// C is fully exposed to wrappers (includes code using B **)
%inline %{
struct C {
int val;
C(int val = 0) : val(val) {}
};
%}
%template(CPtrVector) std::vector<C *>;
%inline %{
// pointer to pointer in the wrappers was preventing a vector of pointers from working
C** makeCIntPtrPtr(C* v) {
return new C*(v);
}
C *makeC(int val) { return new C(val); }
int getVal(C* b) { return b->val; }
int getVectorValueC(std::vector<C *> vpi, size_t index) {
return vpi[index]->val;
}
%}

12
Examples/test-suite/nested.i
View file

@ -13,6 +13,18 @@ Also tests reported error when a #define placed in a deeply embedded struct/unio
%rename(InUnNamed) OuterStructNamed::Inner_union_named;
#endif
#if defined(SWIG_JAVASCRIPT_V8)
%inline %{
#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
/* for nested C class wrappers compiled as C++ code */
/* dereferencing type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing] */
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
%}
#endif
%inline %{
struct TestStruct {

12
Examples/test-suite/nested_extend_c.i
View file

@ -1,5 +1,17 @@
%module nested_extend_c
#if defined(SWIG_JAVASCRIPT_V8)
%inline %{
#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
/* for nested C class wrappers compiled as C++ code */
/* dereferencing type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing] */
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
%}
#endif
#if !defined(SWIGOCTAVE) && !defined(SWIG_JAVASCRIPT_V8)
%extend hiA {
hiA() {

12
Examples/test-suite/nested_structs.i
View file

@ -1,5 +1,17 @@
%module nested_structs
#if defined(SWIG_JAVASCRIPT_V8)
%inline %{
#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
/* for nested C class wrappers compiled as C++ code */
/* dereferencing type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing] */
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
%}
#endif
// bug #491476
%inline %{
struct Outer {

33
Examples/test-suite/python/li_std_vector_ptr_runme.py
View file

@ -1,7 +1,38 @@
from li_std_vector_ptr import *
def check(val1, val2):
if val1 != val2:
raise RuntimeError("Values are not the same %s %s" % (val1, val2))
ip1 = makeIntPtr(11)
ip2 = makeIntPtr(22)
vi = IntPtrVector((ip1, ip2))
displayVector(vi)
check(getValueFromVector(vi, 0), 11)
check(getValueFromVector(vi, 1), 22)
vA = APtrVector([makeA(33), makeA(34)])
check(getVectorValueA(vA, 0), 33)
vB = BPtrVector([makeB(133), makeB(134)])
check(getVectorValueB(vB, 0), 133)
vC = CPtrVector([makeC(1133), makeC(1134)])
check(getVectorValueC(vC, 0), 1133)
vA = [makeA(233), makeA(234)]
check(getVectorValueA(vA, 0), 233)
vB = [makeB(333), makeB(334)]
check(getVectorValueB(vB, 0), 333)
vC = [makeC(3333), makeC(3334)]
check(getVectorValueC(vC, 0), 3333)
# mixed A and B should not be accepted
vAB = [makeA(999), makeB(999)]
try:
check(getVectorValueA(vAB, 0), 999)
raise RuntimeError("missed exception")
except TypeError:
pass

6
Examples/test-suite/traits.i
View file

@ -1,6 +0,0 @@
%module traits
%include typemaps/traits.swg
%fragment("Traits");

7
Examples/test-suite/typedef_struct.i
View file

@ -1,6 +1,13 @@
%module typedef_struct
%inline %{
#if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
/* for anonymous enums */
/* dereferencing type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing] */
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
typedef struct {
int numpoints;
} LineObj;

4
Lib/octave/octcontainer.swg
View file

@ -562,8 +562,8 @@ namespace swig {
static int asptr(const octave_value& obj, sequence **seq) {
if (!obj.is_defined() || Swig::swig_value_deref(obj)) {
sequence *p;
if (SWIG_ConvertPtr(obj,(void**)&p,
swig::type_info<sequence>(),0) == SWIG_OK) {
swig_type_info *descriptor = swig::type_info<sequence>();
if (descriptor && SWIG_IsOK(SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
if (seq) *seq = p;
return SWIG_OLDOBJ;
}

3
Lib/octave/octstdcommon.swg
View file

@ -42,7 +42,8 @@ namespace swig {
struct traits_asptr {
static int asptr(const octave_value& obj, Type **val) {
Type *p;
int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
swig_type_info *descriptor = type_info<Type>();
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res)) {
if (val) *val = p;
}

3
Lib/octave/std_map.i
View file

@ -98,7 +98,8 @@
res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
} else {
map_type *p;
res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
swig_type_info *descriptor = swig::type_info<map_type>();
res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val) *val = p;
}
return res;

6
Lib/octave/std_pair.i
View file

@ -47,7 +47,8 @@
return get_pair(c(0),c(1),val);
} else {
value_type *p;
int res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
swig_type_info *descriptor = swig::type_info<value_type>();
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val)
*val = *p;
return res;
@ -100,7 +101,8 @@
return get_pair(c(0),c(1),val);
} else {
value_type *p;
int res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
swig_type_info *descriptor = swig::type_info<value_type>();
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val)
*val = p;
return res;

4
Lib/python/pycontainer.swg
View file

@ -968,8 +968,8 @@ namespace swig {
static int asptr(PyObject *obj, sequence **seq) {
if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
sequence *p;
if (::SWIG_ConvertPtr(obj,(void**)&p,
swig::type_info<sequence>(),0) == SWIG_OK) {
swig_type_info *descriptor = swig::type_info<sequence>();
if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
if (seq) *seq = p;
return SWIG_OLDOBJ;
}

3
Lib/python/pystdcommon.swg
View file

@ -46,7 +46,8 @@ namespace swig {
struct traits_asptr {
static int asptr(PyObject *obj, Type **val) {
Type *p;
int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
swig_type_info *descriptor = type_info<Type>();
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res)) {
if (val) *val = p;
}

3
Lib/python/std_map.i
View file

@ -102,7 +102,8 @@
res = traits_asptr_stdseq<map_type, std::pair<K, T> >::asptr(items, val);
} else {
map_type *p;
res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
swig_type_info *descriptor = swig::type_info<map_type>();
res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val) *val = p;
}
SWIG_PYTHON_THREAD_END_BLOCK;

3
Lib/python/std_multimap.i
View file

@ -26,7 +26,8 @@
return traits_asptr_stdseq<std::multimap<K,T>, std::pair<K, T> >::asptr(items, val);
} else {
multimap_type *p;
res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<multimap_type>(),0);
swig_type_info *descriptor = swig::type_info<multimap_type>();
res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val) *val = p;
}
return res;

6
Lib/python/std_pair.i
View file

@ -48,7 +48,8 @@
}
} else {
value_type *p;
res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
swig_type_info *descriptor = swig::type_info<value_type>();
res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val) *val = *p;
}
return res;
@ -98,7 +99,8 @@
}
} else {
value_type *p;
res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
swig_type_info *descriptor = swig::type_info<value_type>();
res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val) *val = p;
}
return res;

3
Lib/python/std_unordered_map.i
View file

@ -29,7 +29,8 @@
res = traits_asptr_stdseq<std::unordered_map<K,T>, std::pair<K, T> >::asptr(items, val);
} else {
unordered_map_type *p;
res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<unordered_map_type>(),0);
swig_type_info *descriptor = swig::type_info<unordered_map_type>();
res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val) *val = p;
}
return res;

3
Lib/python/std_unordered_multimap.i
View file

@ -26,7 +26,8 @@
return traits_asptr_stdseq<std::unordered_multimap<K,T>, std::pair<K, T> >::asptr(items, val);
} else {
unordered_multimap_type *p;
res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<unordered_multimap_type>(),0);
swig_type_info *descriptor = swig::type_info<unordered_multimap_type>();
res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val) *val = p;
}
return res;

3
Lib/r/rstdcommon.swg
View file

@ -40,7 +40,8 @@ namespace swig {
struct traits_asptr {
static int asptr(SWIG_Object obj, Type **val) {
Type *p;
int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
swig_type_info *descriptor = type_info<Type>();
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res)) {
if (val) *val = p;
}

17
Lib/ruby/rubycontainer.swg
View file

@ -464,8 +464,7 @@ namespace swig
%typemap(in,noblock=1,fragment="RubySequence_Cont")
const_iterator(swig::ConstIterator *iter = 0, int res),
const_reverse_iterator(swig::ConstIterator *iter = 0, int res) {
res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter),
swig::ConstIterator::descriptor(), 0);
res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::ConstIterator::descriptor(), 0);
if (!SWIG_IsOK(res) || !iter) {
%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
} else {
@ -497,16 +496,14 @@ namespace swig
%typecheck(%checkcode(ITERATOR),noblock=1,fragment="RubySequence_Cont")
const_iterator, const_reverse_iterator {
swig::ConstIterator *iter = 0;
int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter),
swig::ConstIterator::descriptor(), 0);
int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::ConstIterator::descriptor(), 0);
$1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::ConstIterator_T<$type > *>(iter) != 0));
}
%typecheck(%checkcode(ITERATOR),noblock=1,fragment="RubySequence_Cont")
iterator, reverse_iterator {
swig::ConstIterator *iter = 0;
int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter),
swig::Iterator::descriptor(), 0);
int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
$1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<$type > *>(iter) != 0));
}
@ -1037,8 +1034,8 @@ namespace swig {
}
} else {
sequence *p;
if (SWIG_ConvertPtr(obj,(void**)&p,
swig::type_info<sequence>(),0) == SWIG_OK) {
swig_type_info *descriptor = swig::type_info<sequence>();
if (descriptor && SWIG_IsOK(SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
if (seq) *seq = p;
return SWIG_OLDOBJ;
}
@ -1077,8 +1074,8 @@ namespace swig {
}
} else {
sequence *p;
if (SWIG_ConvertPtr(obj,(void**)&p,
swig::type_info<sequence>(),0) == SWIG_OK) {
swig_type_info *descriptor = swig::type_info<sequence>();
if (descriptor && SWIG_IsOK(SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
if (seq) *seq = p;
return SWIG_OLDOBJ;
}

3
Lib/ruby/rubystdcommon.swg
View file

@ -53,7 +53,8 @@ namespace swig {
struct traits_asptr {
static int asptr(VALUE obj, Type **val) {
Type *p;
int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
swig_type_info *descriptor = type_info<Type>();
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res)) {
if (val) *val = p;
}

3
Lib/ruby/std_map.i
View file

@ -100,7 +100,8 @@
res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
} else {
map_type *p;
res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
swig_type_info *descriptor = swig::type_info<map_type>();
res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val) *val = p;
}
return res;

8
Lib/ruby/std_pair.i
View file

@ -44,8 +44,8 @@
}
} else {
value_type *p;
res = SWIG_ConvertPtr(obj,(void**)&p,
swig::type_info<value_type>(),0);
swig_type_info *descriptor = swig::type_info<value_type>();
res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val) *val = *p;
}
return res;
@ -90,8 +90,8 @@
}
} else {
value_type *p;
res = SWIG_ConvertPtr(obj,(void**)&p,
swig::type_info<value_type>(),0);
swig_type_info *descriptor = swig::type_info<value_type>();
res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res) && val) *val = p;
}
return res;

3
Lib/scilab/scistdcommon.swg
View file

@ -42,7 +42,8 @@ namespace swig {
struct traits_asptr {
static int asptr(const SwigSciObject& obj, Type **val) {
Type *p;
int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
swig_type_info *descriptor = type_info<Type>();
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res)) {
if (val) *val = p;
}

19
Lib/std/std_common.i
View file

@ -99,8 +99,21 @@ namespace swig {
return traits<typename noconst_traits<Type >::noconst_type >::type_name();
}
template <class Type>
struct traits_info {
template <class Type> struct traits_info {
static swig_type_info *type_query(std::string name) {
name += " *";
return SWIG_TypeQuery(name.c_str());
}
static swig_type_info *type_info() {
static swig_type_info *info = type_query(type_name<Type>());
return info;
}
};
/*
Partial specialization for pointers (traits_info)
*/
template <class Type> struct traits_info<Type *> {
static swig_type_info *type_query(std::string name) {
name += " *";
return SWIG_TypeQuery(name.c_str());
@ -117,7 +130,7 @@ namespace swig {
}
/*
Partial specialization for pointers
Partial specialization for pointers (traits)
*/
template <class Type> struct traits <Type *> {
typedef pointer_category category;

16
Lib/typemaps/implicit.swg
View file

@ -73,8 +73,8 @@ namespace swig {
typedef Type value_type;
static int asptr(SWIG_Object obj, value_type **val) {
Type *vptr;
static swig_type_info* desc = SWIG_TypeQuery("Type *");
int res = SWIG_ConvertPtr(obj, (void **)&vptr, desc, 0);
static swig_type_info* descriptor = SWIG_TypeQuery("Type *");
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&vptr, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res)) {
if (val) *val = vptr;
return res;
@ -109,8 +109,8 @@ namespace swig {
typedef Type value_type;
static int asptr(SWIG_Object obj, value_type **val) {
Type *vptr;
static swig_type_info* desc = SWIG_TypeQuery("Type *");
int res = SWIG_ConvertPtr(obj, (void **)&vptr, desc, 0);
static swig_type_info* descriptor = SWIG_TypeQuery("Type *");
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&vptr, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res)) {
if (val) *val = vptr;
return res;
@ -147,8 +147,8 @@ namespace swig {
typedef Type value_type;
static int asptr(SWIG_Object obj, value_type **val) {
Type *vptr;
static swig_type_info* desc = SWIG_TypeQuery("Type *");
int res = SWIG_ConvertPtr(obj, (void **)&vptr, desc, 0);
static swig_type_info* descriptor = SWIG_TypeQuery("Type *");
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&vptr, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res)) {
if (val) *val = vptr;
return SWIG_OLDOBJ;
@ -188,8 +188,8 @@ namespace swig {
typedef Type value_type;
static int asptr(SWIG_Object obj, value_type **val) {
Type *vptr;
static swig_type_info* desc = SWIG_TypeQuery("Type *");
int res = SWIG_ConvertPtr(obj, (void **)&vptr, desc, 0);
static swig_type_info* descriptor = SWIG_TypeQuery("Type *");
int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&vptr, descriptor, 0) : SWIG_ERROR;
if (SWIG_IsOK(res)) {
if (val) *val = vptr;
return res;

305
Lib/typemaps/traits.swg
View file

@ -1,305 +0,0 @@
//
// Use the following macro with modern STL implementations
//
//#define SWIG_STD_MODERN_STL
//
// Use this to deactive the previous definition, when using gcc-2.95
// or similar old compilers.
//
//#define SWIG_STD_NOMODERN_STL
// Here, we identify compilers we now have problems with STL.
%{
#if defined(__GNUC__)
# if __GNUC__ == 2 && __GNUC_MINOR <= 96
# define SWIG_STD_NOMODERN_STL
# endif
#endif
%}
//
// Common code for supporting the STD C++ namespace
//
%fragment("<string>");
%fragment("<stdexcept>");
%fragment("Traits","header",fragment="<string>")
{
namespace swig {
/*
type categories
*/
struct pointer_category { };
struct value_category { };
/*
General traits that provides type_name and type_info
*/
template <class Type> struct traits { };
template <class Type>
inline const char* type_name() {
return traits<Type>::type_name();
}
template <class Type>
struct traits_info {
static swig_type_info *type_query(std::string name) {
name += " *";
return SWIG_TypeQuery(name.c_str());
}
static swig_type_info *type_info() {
static swig_type_info *info = type_query(type_name<Type>());
return info;
}
};
template <class Type>
inline swig_type_info *type_info() {
return traits_info<Type>::type_info();
}
/*
Partial specialization for pointers
*/
template <class Type> struct traits <Type *> {
typedef pointer_category category;
static std::string make_ptr_name(const char* name) {
std::string ptrname = name;
ptrname += " *";
return ptrname;
}
static const char* type_name() {
static std::string name = make_ptr_name(swig::type_name<Type>());
return name.c_str();
}
};
template <class Type, class Category = typename traits<Type>::category >
struct traits_check { };
/*
Traits that provides the from method for an unknown type
*/
template <int flags, class Type> struct traits_from_ptr {
static SWIG_Object from SWIG_FROM_DECL_ARGS(Type *val) {
return SWIG_NewPointerObj(val, type_info<Type>(), flags);
}
};
template <class Type> struct traits_from {
static SWIG_Object from SWIG_FROM_DECL_ARGS(const Type& val) {
return traits_from_ptr<SWIG_POINTER_OWN, Type>::from(new Type(val));
}
};
template <class Type> struct traits_from<Type *> {
static SWIG_Object from SWIG_FROM_DECL_ARGS(Type* val) {
return traits_from_ptr<0, Type>::from(val);
}
};
template <class Type>
inline SWIG_Object from SWIG_FROM_DECL_ARGS(const Type& val) {
return traits_from<Type>::from(val);
}
/*
Traits that provides the asptr/asval method for an unknown type
*/
template <class Type>
struct traits_asptr {
static int asptr SWIG_AS_DECL_ARGS (SWIG_Object obj, Type **val) {
Type *p;
int res = SWIG_ConvertPtr(obj, %as_voidptrptr(&p), type_info<Type>(), 0);
if (SWIG_IsOK(res) && val) *val = p;
return res;
}
};
template <class Type>
inline int asptr SWIG_AS_DECL_ARGS(SWIG_Object obj, Type **vptr) {
return traits_asptr<Type>::asptr SWIG_AS_CALL_ARGS(obj, vptr);
}
template <class Type>
struct traits_asval {
static int asval SWIG_AS_DECL_ARGS(SWIG_Object obj, Type *val) {
if (val) {
Type *p = 0;
int res = traits_asptr<Type>::asptr SWIG_AS_CALL_ARGS(obj, &p);
if (SWIG_IsOK(res) && p) {
*val = *p;
if (SWIG_IsNewObj(res)) {
%delete(p);
res = SWIG_DelNewMask(res);
}
}
return res;
} else {
return traits_asptr<Type>::asptr SWIG_AS_CALL_ARGS(obj, (Type **)(0));
}
}
};
template <class Type>
inline int asval SWIG_AS_DECL_ARGS (SWIG_Object obj, Type *val) {
return traits_asval<Type>::asval SWIG_AS_CALL_ARGS(obj, val);
}
/*
Traits that provides the check method for an unknown type
*/
#define SWIG_CHECK_DECL_ARGS(obj) SWIG_AS_DECL_ARGS(obj, void * = 0)
#define SWIG_CHECK_CALL_ARGS(obj) SWIG_AS_CALL_ARGS(obj, 0)
template <class Type>
struct traits_checkval {
static int check SWIG_CHECK_DECL_ARGS(SWIG_Object obj) {
if (obj) {
int res = asval SWIG_AS_CALL_ARGS(obj, (Type *)(0));
return SWIG_CheckState(res);
} else {
return 0;
}
}
};
template <class Type>
struct traits_checkptr {
static int check SWIG_CHECK_DECL_ARGS(SWIG_Object obj) {
if (obj) {
int res = asptr SWIG_AS_CALL_ARGS(obj, (Type **)(0));
return SWIG_CheckState(res);
} else {
return 0;
}
}
};
template <class Type>
struct traits_check<Type, value_category> : traits_checkval<Type> {
};
template <class Type>
struct traits_check<Type, pointer_category> : traits_checkptr<Type> {
};
template <class Type>
inline int check SWIG_CHECK_DECL_ARGS(SWIG_Object obj) {
return traits_check<Type>::check SWIG_CHECK_CALL_ARGS(obj);
}
}
}
/*
Generate the traits for an unknown SWIGTYPE
*/
%define %traits_swigtype(Type...)
%fragment(SWIG_Traits_frag(Type),"header",fragment="Traits") {
namespace swig {
template <> struct traits<Type > {
typedef pointer_category category;
static const char* type_name() { return #Type; }
};
}
}
%enddef
/*
Generate the traits for a 'value' type, such as 'double',
for which the SWIG_AsVal and SWIG_From methods are already defined.
*/
%define %traits_value(Type...)
%fragment(SWIG_Traits_frag(Type),"header",
fragment=SWIG_AsVal_frag(Type),
fragment=SWIG_From_frag(Type),
fragment="Traits") {
namespace swig {
template <> struct traits<Type > {
typedef value_category category;
static const char* type_name() { return #Type; }
};
template <> struct traits_asval<Type > {
typedef Type value_type;
static int asval SWIG_AS_DECL_ARGS (SWIG_Object obj, value_type *val) {
return SWIG_AsVal(Type)(obj, val);
}
};
template <> struct traits_from<Type > {
typedef Type value_type;
static SWIG_Object from SWIG_FROM_DECL_ARGS (const value_type& val) {
return SWIG_From(Type)(val);
}
};
}
}
%enddef
/*
Generate the traits for a 'pointer' type, such as 'std::string',
for which the SWIG_AsPtr and SWIG_From methods are already defined.
*/
%define %traits_pointer(Type...)
%fragment(SWIG_Traits_frag(Type),"header",
fragment=SWIG_AsVal_frag(Type),
fragment=SWIG_From_frag(Type),
fragment="Traits") {
namespace swig {
template <> struct traits<Type > {
typedef pointer_category category;
static const char* type_name() { return #Type; }
};
template <> struct traits_asptr<Type > {
typedef Type value_type;
static int asptr SWIG_AS_DECL_ARGS (SWIG_Object obj, value_type **val) {
return SWIG_AsPtr(Type)(obj, val);
}
};
template <> struct traits_from<Type > {
typedef Type value_type;
static SWIG_Object from SWIG_FROM_DECL_ARGS (const value_type& val) {
return SWIG_From(Type)(val);
}
};
}
}
%enddef
/*
Generate the typemaps for a class that has 'value' traits
*/
%define %typemap_traits_value(Code,Type...)
%typemaps_asvalfrom(%arg(Code),
%arg(swig::asval),
%arg(swig::from),
%arg(SWIG_Traits_frag(Type)),
%arg(SWIG_Traits_frag(Type)),
Type);
%enddef
/*
Generate the typemaps for a class that has 'pointer' traits
*/
%define %typemap_traits_pointer(Code,Type...)
%typemaps_asptrfrom(%arg(Code),
%arg(swig::asptr),
%arg(swig::from),
%arg(SWIG_Traits_frag(Type)),
%arg(SWIG_Traits_frag(Type)),
Type);
%enddef