mirror of
https://github.com/nillerusr/source-engine.git
synced 2026-08-30 22:19:19 +00:00
1
This commit is contained in:
FluorescentCIAAfricanAmerican
@@ -0,0 +1,391 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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.
|
||||
*
|
||||
* arrays_java.i
|
||||
*
|
||||
* These typemaps give more natural support for arrays. The typemaps are not efficient
|
||||
* as there is a lot of copying of the array values whenever the array is passed to C/C++
|
||||
* from Java and vice versa. The Java array is expected to be the same size as the C array.
|
||||
* An exception is thrown if they are not.
|
||||
*
|
||||
* Example usage:
|
||||
* Wrapping:
|
||||
*
|
||||
* %include <arrays_java.i>
|
||||
* %inline %{
|
||||
* short FiddleSticks[3];
|
||||
* %}
|
||||
*
|
||||
* Use from Java like this:
|
||||
*
|
||||
* short[] fs = new short[] {10, 11, 12};
|
||||
* example.setFiddleSticks(fs);
|
||||
* fs = example.getFiddleSticks();
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
/* Primitive array support is a combination of SWIG macros and functions in order to reduce
|
||||
* code bloat and aid maintainability. The SWIG preprocessor expands the macros into functions
|
||||
* for inclusion in the generated code. */
|
||||
|
||||
/* Array support functions declarations macro */
|
||||
%define JAVA_ARRAYS_DECL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)
|
||||
%{
|
||||
int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv *jenv, JNITYPE **jarr, CTYPE **carr, JNITYPE##Array input);
|
||||
void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv *jenv, JNITYPE *jarr, CTYPE *carr, JNITYPE##Array input);
|
||||
JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv *jenv, CTYPE *result, jsize sz);
|
||||
%}
|
||||
%enddef
|
||||
|
||||
/* Array support functions macro */
|
||||
%define JAVA_ARRAYS_IMPL(CTYPE, JNITYPE, JAVATYPE, JFUNCNAME)
|
||||
%{
|
||||
/* CTYPE[] support */
|
||||
int SWIG_JavaArrayIn##JFUNCNAME (JNIEnv *jenv, JNITYPE **jarr, CTYPE **carr, JNITYPE##Array input) {
|
||||
int i;
|
||||
jsize sz;
|
||||
if (!input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
|
||||
return 0;
|
||||
}
|
||||
sz = JCALL1(GetArrayLength, jenv, input);
|
||||
*jarr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, input, 0);
|
||||
if (!*jarr)
|
||||
return 0; %}
|
||||
#ifdef __cplusplus
|
||||
%{ *carr = new CTYPE[sz]; %}
|
||||
#else
|
||||
%{ *carr = (CTYPE*) calloc(sz, sizeof(CTYPE)); %}
|
||||
#endif
|
||||
%{ if (!*carr) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
|
||||
return 0;
|
||||
}
|
||||
for (i=0; i<sz; i++)
|
||||
JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE)
|
||||
return 1;
|
||||
}
|
||||
|
||||
void SWIG_JavaArrayArgout##JFUNCNAME (JNIEnv *jenv, JNITYPE *jarr, CTYPE *carr, JNITYPE##Array input) {
|
||||
int i;
|
||||
jsize sz = JCALL1(GetArrayLength, jenv, input);
|
||||
for (i=0; i<sz; i++)
|
||||
jarr[i] = (JNITYPE)carr[i];
|
||||
JCALL3(Release##JAVATYPE##ArrayElements, jenv, input, jarr, 0);
|
||||
}
|
||||
|
||||
JNITYPE##Array SWIG_JavaArrayOut##JFUNCNAME (JNIEnv *jenv, CTYPE *result, jsize sz) {
|
||||
JNITYPE *arr;
|
||||
int i;
|
||||
JNITYPE##Array jresult = JCALL1(New##JAVATYPE##Array, jenv, sz);
|
||||
if (!jresult)
|
||||
return NULL;
|
||||
arr = JCALL2(Get##JAVATYPE##ArrayElements, jenv, jresult, 0);
|
||||
if (!arr)
|
||||
return NULL;
|
||||
for (i=0; i<sz; i++)
|
||||
arr[i] = (JNITYPE)result[i];
|
||||
JCALL3(Release##JAVATYPE##ArrayElements, jenv, jresult, arr, 0);
|
||||
return jresult;
|
||||
}
|
||||
%}
|
||||
%enddef
|
||||
|
||||
%{
|
||||
#if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS)
|
||||
%}
|
||||
|
||||
#ifdef __cplusplus
|
||||
JAVA_ARRAYS_DECL(bool, jboolean, Boolean, Bool) /* bool[] */
|
||||
#endif
|
||||
|
||||
JAVA_ARRAYS_DECL(signed char, jbyte, Byte, Schar) /* signed char[] */
|
||||
JAVA_ARRAYS_DECL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */
|
||||
JAVA_ARRAYS_DECL(short, jshort, Short, Short) /* short[] */
|
||||
JAVA_ARRAYS_DECL(unsigned short, jint, Int, Ushort) /* unsigned short[] */
|
||||
JAVA_ARRAYS_DECL(int, jint, Int, Int) /* int[] */
|
||||
JAVA_ARRAYS_DECL(unsigned int, jlong, Long, Uint) /* unsigned int[] */
|
||||
JAVA_ARRAYS_DECL(long, jint, Int, Long) /* long[] */
|
||||
JAVA_ARRAYS_DECL(unsigned long, jlong, Long, Ulong) /* unsigned long[] */
|
||||
JAVA_ARRAYS_DECL(jlong, jlong, Long, Longlong) /* long long[] */
|
||||
JAVA_ARRAYS_DECL(float, jfloat, Float, Float) /* float[] */
|
||||
JAVA_ARRAYS_DECL(double, jdouble, Double, Double) /* double[] */
|
||||
|
||||
%{
|
||||
#else
|
||||
%}
|
||||
|
||||
#ifdef __cplusplus
|
||||
/* Bool array element assignment different to other types to keep Visual C++ quiet */
|
||||
#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (*carr)[i] = ((*jarr)[i] != 0);
|
||||
JAVA_ARRAYS_IMPL(bool, jboolean, Boolean, Bool) /* bool[] */
|
||||
#undef JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN
|
||||
#endif
|
||||
|
||||
#define JAVA_TYPEMAP_ARRAY_ELEMENT_ASSIGN(CTYPE) (*carr)[i] = (CTYPE)(*jarr)[i];
|
||||
JAVA_ARRAYS_IMPL(signed char, jbyte, Byte, Schar) /* signed char[] */
|
||||
JAVA_ARRAYS_IMPL(unsigned char, jshort, Short, Uchar) /* unsigned char[] */
|
||||
JAVA_ARRAYS_IMPL(short, jshort, Short, Short) /* short[] */
|
||||
JAVA_ARRAYS_IMPL(unsigned short, jint, Int, Ushort) /* unsigned short[] */
|
||||
JAVA_ARRAYS_IMPL(int, jint, Int, Int) /* int[] */
|
||||
JAVA_ARRAYS_IMPL(unsigned int, jlong, Long, Uint) /* unsigned int[] */
|
||||
JAVA_ARRAYS_IMPL(long, jint, Int, Long) /* long[] */
|
||||
JAVA_ARRAYS_IMPL(unsigned long, jlong, Long, Ulong) /* unsigned long[] */
|
||||
JAVA_ARRAYS_IMPL(jlong, jlong, Long, Longlong) /* long long[] */
|
||||
JAVA_ARRAYS_IMPL(float, jfloat, Float, Float) /* float[] */
|
||||
JAVA_ARRAYS_IMPL(double, jdouble, Double, Double) /* double[] */
|
||||
|
||||
%{
|
||||
#endif
|
||||
%}
|
||||
|
||||
|
||||
/* The rest of this file has the array typemaps */
|
||||
|
||||
/* Arrays of primitive types use the following macro. The array typemaps use support functions. */
|
||||
%define JAVA_ARRAYS_TYPEMAPS(CTYPE, JTYPE, JNITYPE, JFUNCNAME, JNIDESC)
|
||||
|
||||
%typemap(jni) CTYPE[ANY], CTYPE[] %{JNITYPE##Array%}
|
||||
%typemap(jtype) CTYPE[ANY], CTYPE[] %{JTYPE[]%}
|
||||
%typemap(jstype) CTYPE[ANY], CTYPE[] %{JTYPE[]%}
|
||||
|
||||
%typemap(in) CTYPE[] (JNITYPE *jarr)
|
||||
%{ if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, &$1, $input)) return $null; %}
|
||||
%typemap(in) CTYPE[ANY] (JNITYPE *jarr)
|
||||
%{ if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
|
||||
return $null;
|
||||
}
|
||||
if (!SWIG_JavaArrayIn##JFUNCNAME(jenv, &jarr, &$1, $input)) return $null; %}
|
||||
%typemap(argout) CTYPE[ANY], CTYPE[]
|
||||
%{ SWIG_JavaArrayArgout##JFUNCNAME(jenv, jarr$argnum, $1, $input); %}
|
||||
%typemap(out) CTYPE[ANY]
|
||||
%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, $1, $1_dim0); %}
|
||||
%typemap(out) CTYPE[]
|
||||
%{$result = SWIG_JavaArrayOut##JFUNCNAME(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); %}
|
||||
%typemap(freearg) CTYPE[ANY], CTYPE[]
|
||||
#ifdef __cplusplus
|
||||
%{ delete [] $1; %}
|
||||
#else
|
||||
%{ free($1); %}
|
||||
#endif
|
||||
|
||||
%typemap(javain) CTYPE[ANY], CTYPE[] "$javainput"
|
||||
%typemap(javaout) CTYPE[ANY], CTYPE[] {
|
||||
return $jnicall;
|
||||
}
|
||||
|
||||
%enddef
|
||||
|
||||
JAVA_ARRAYS_TYPEMAPS(bool, boolean, jboolean, Bool, "[Z") /* bool[ANY] */
|
||||
JAVA_ARRAYS_TYPEMAPS(signed char, byte, jbyte, Schar, "[B") /* signed char[ANY] */
|
||||
JAVA_ARRAYS_TYPEMAPS(unsigned char, short, jshort, Uchar, "[S") /* unsigned char[ANY] */
|
||||
JAVA_ARRAYS_TYPEMAPS(short, short, jshort, Short, "[S") /* short[ANY] */
|
||||
JAVA_ARRAYS_TYPEMAPS(unsigned short, int, jint, Ushort, "[I") /* unsigned short[ANY] */
|
||||
JAVA_ARRAYS_TYPEMAPS(int, int, jint, Int, "[I") /* int[ANY] */
|
||||
JAVA_ARRAYS_TYPEMAPS(unsigned int, long, jlong, Uint, "[J") /* unsigned int[ANY] */
|
||||
JAVA_ARRAYS_TYPEMAPS(long, int, jint, Long, "[I") /* long[ANY] */
|
||||
JAVA_ARRAYS_TYPEMAPS(unsigned long, long, jlong, Ulong, "[J") /* unsigned long[ANY] */
|
||||
JAVA_ARRAYS_TYPEMAPS(long long, long, jlong, Longlong, "[J") /* long long[ANY] */
|
||||
JAVA_ARRAYS_TYPEMAPS(float, float, jfloat, Float, "[F") /* float[ANY] */
|
||||
JAVA_ARRAYS_TYPEMAPS(double, double, jdouble, Double, "[D") /* double[ANY] */
|
||||
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_BOOL_ARRAY) /* Java boolean[] */
|
||||
bool[ANY], bool[]
|
||||
""
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_INT8_ARRAY) /* Java byte[] */
|
||||
signed char[ANY], signed char[]
|
||||
""
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_INT16_ARRAY) /* Java short[] */
|
||||
unsigned char[ANY], unsigned char[],
|
||||
short[ANY], short[]
|
||||
""
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_INT32_ARRAY) /* Java int[] */
|
||||
unsigned short[ANY], unsigned short[],
|
||||
int[ANY], int[],
|
||||
long[ANY], long[]
|
||||
""
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_INT64_ARRAY) /* Java long[] */
|
||||
unsigned int[ANY], unsigned int[],
|
||||
unsigned long[ANY], unsigned long[],
|
||||
long long[ANY], long long[]
|
||||
""
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_INT128_ARRAY) /* Java BigInteger[] */
|
||||
unsigned long long[ANY], unsigned long long[]
|
||||
""
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_FLOAT_ARRAY) /* Java float[] */
|
||||
float[ANY], float[]
|
||||
""
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY) /* Java double[] */
|
||||
double[ANY], double[]
|
||||
""
|
||||
|
||||
|
||||
/* Arrays of proxy classes. The typemaps in this macro make it possible to treat an array of
|
||||
* class/struct/unions as an array of Java classes.
|
||||
* Use the following macro to use these typemaps for an array of class/struct/unions called name:
|
||||
* JAVA_ARRAYSOFCLASSES(name)
|
||||
* Note that multiple copies of the class/struct is made when using the array as a parameter input. */
|
||||
%define JAVA_ARRAYSOFCLASSES(ARRAYSOFCLASSES)
|
||||
|
||||
%typemap(jni) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "jlongArray"
|
||||
%typemap(jtype) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "long[]"
|
||||
%typemap(jstype) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "$javaclassname[]"
|
||||
|
||||
%typemap(javain) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] "$javaclassname.cArrayUnwrap($javainput)"
|
||||
%typemap(javaout) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[] {
|
||||
return $javaclassname.cArrayWrap($jnicall, $owner);
|
||||
}
|
||||
|
||||
%typemap(in) ARRAYSOFCLASSES[] (jlong *jarr, jsize sz)
|
||||
{
|
||||
int i;
|
||||
if (!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
|
||||
return $null;
|
||||
}
|
||||
sz = JCALL1(GetArrayLength, jenv, $input);
|
||||
jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);
|
||||
if (!jarr) {
|
||||
return $null;
|
||||
}
|
||||
#ifdef __cplusplus
|
||||
$1 = new $*1_ltype[sz];
|
||||
#else
|
||||
$1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));
|
||||
#endif
|
||||
if (!$1) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
|
||||
return $null;
|
||||
}
|
||||
for (i=0; i<sz; i++) {
|
||||
$1[i] = **($&1_ltype)&jarr[i];
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(in) ARRAYSOFCLASSES[ANY] (jlong *jarr, jsize sz)
|
||||
{
|
||||
int i;
|
||||
if (!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
|
||||
return $null;
|
||||
}
|
||||
sz = JCALL1(GetArrayLength, jenv, $input);
|
||||
if (sz != $1_size) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
|
||||
return $null;
|
||||
}
|
||||
jarr = JCALL2(GetLongArrayElements, jenv, $input, 0);
|
||||
if (!jarr) {
|
||||
return $null;
|
||||
}
|
||||
#ifdef __cplusplus
|
||||
$1 = new $*1_ltype[sz];
|
||||
#else
|
||||
$1 = ($1_ltype) calloc(sz, sizeof($*1_ltype));
|
||||
#endif
|
||||
if (!$1) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
|
||||
return $null;
|
||||
}
|
||||
for (i=0; i<sz; i++) {
|
||||
$1[i] = **($&1_ltype)&jarr[i];
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(argout) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[]
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<sz$argnum; i++) {
|
||||
**($&1_ltype)&jarr$argnum[i] = $1[i];
|
||||
}
|
||||
JCALL3(ReleaseLongArrayElements, jenv, $input, jarr$argnum, 0);
|
||||
}
|
||||
|
||||
%typemap(out) ARRAYSOFCLASSES[ANY]
|
||||
{
|
||||
jlong *arr;
|
||||
int i;
|
||||
$result = JCALL1(NewLongArray, jenv, $1_dim0);
|
||||
if (!$result) {
|
||||
return $null;
|
||||
}
|
||||
arr = JCALL2(GetLongArrayElements, jenv, $result, 0);
|
||||
if (!arr) {
|
||||
return $null;
|
||||
}
|
||||
for (i=0; i<$1_dim0; i++) {
|
||||
arr[i] = 0;
|
||||
*($&1_ltype)&arr[i] = &$1[i];
|
||||
}
|
||||
JCALL3(ReleaseLongArrayElements, jenv, $result, arr, 0);
|
||||
}
|
||||
|
||||
%typemap(freearg) ARRAYSOFCLASSES[ANY], ARRAYSOFCLASSES[]
|
||||
#ifdef __cplusplus
|
||||
%{ delete [] $1; %}
|
||||
#else
|
||||
%{ free($1); %}
|
||||
#endif
|
||||
|
||||
/* Add some code to the proxy class of the array type for converting between type used in
|
||||
* JNI class (long[]) and type used in proxy class ( ARRAYSOFCLASSES[] ) */
|
||||
%typemap(javacode) ARRAYSOFCLASSES %{
|
||||
protected static long[] cArrayUnwrap($javaclassname[] arrayWrapper) {
|
||||
long[] cArray = new long[arrayWrapper.length];
|
||||
for (int i=0; i<arrayWrapper.length; i++)
|
||||
cArray[i] = $javaclassname.getCPtr(arrayWrapper[i]);
|
||||
return cArray;
|
||||
}
|
||||
|
||||
protected static $javaclassname[] cArrayWrap(long[] cArray, boolean cMemoryOwn) {
|
||||
$javaclassname[] arrayWrapper = new $javaclassname[cArray.length];
|
||||
for (int i=0; i<cArray.length; i++)
|
||||
arrayWrapper[i] = new $javaclassname(cArray[i], cMemoryOwn);
|
||||
return arrayWrapper;
|
||||
}
|
||||
%}
|
||||
|
||||
%enddef /* JAVA_ARRAYSOFCLASSES */
|
||||
|
||||
|
||||
/* Arrays of enums.
|
||||
* Use the following to use these typemaps for an array of enums called name:
|
||||
* %apply ARRAYSOFENUMS[ANY] { name[ANY] }; */
|
||||
%typemap(jni) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "jintArray"
|
||||
%typemap(jtype) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "int[]"
|
||||
%typemap(jstype) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "int[]"
|
||||
|
||||
%typemap(javain) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] "$javainput"
|
||||
%typemap(javaout) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[] {
|
||||
return $jnicall;
|
||||
}
|
||||
|
||||
%typemap(in) ARRAYSOFENUMS[] (jint *jarr)
|
||||
%{ if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null; %}
|
||||
%typemap(in) ARRAYSOFENUMS[ANY] (jint *jarr) {
|
||||
if ($input && JCALL1(GetArrayLength, jenv, $input) != $1_size) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
|
||||
return $null;
|
||||
}
|
||||
if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null;
|
||||
}
|
||||
%typemap(argout) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[]
|
||||
%{ SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, (int *)$1, $input); %}
|
||||
%typemap(out) ARRAYSOFENUMS[ANY]
|
||||
%{$result = SWIG_JavaArrayOutInt(jenv, (int *)$1, $1_dim0); %}
|
||||
%typemap(freearg) ARRAYSOFENUMS[ANY], ARRAYSOFENUMS[]
|
||||
#ifdef __cplusplus
|
||||
%{ delete [] $1; %}
|
||||
#else
|
||||
%{ free($1); %}
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,192 @@
|
||||
%include <shared_ptr.i>
|
||||
|
||||
%define SWIG_SHARED_PTR_TYPEMAPS(PROXYCLASS, CONST, TYPE...)
|
||||
|
||||
%naturalvar TYPE;
|
||||
%naturalvar SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
|
||||
|
||||
// destructor mods
|
||||
%feature("unref") TYPE
|
||||
//"if (debug_shared) { cout << \"deleting use_count: \" << (*smartarg1).use_count() << \" [\" << (boost::get_deleter<SWIG_null_deleter>(*smartarg1) ? std::string(\"CANNOT BE DETERMINED SAFELY\") : ( (*smartarg1).get() ? (*smartarg1)->getValue() : std::string(\"NULL PTR\") )) << \"]\" << endl << flush; }\n"
|
||||
"(void)arg1; delete smartarg1;"
|
||||
|
||||
|
||||
// plain value
|
||||
%typemap(in) CONST TYPE ($&1_type argp = 0) %{
|
||||
argp = (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0;
|
||||
if (!argp) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
|
||||
return $null;
|
||||
}
|
||||
$1 = *argp; %}
|
||||
%typemap(out) CONST TYPE
|
||||
%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1)); %}
|
||||
|
||||
// plain pointer
|
||||
%typemap(in) CONST TYPE * (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) %{
|
||||
smartarg = *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input;
|
||||
$1 = (TYPE *)(smartarg ? smartarg->get() : 0); %}
|
||||
%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * %{
|
||||
*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
|
||||
%}
|
||||
|
||||
// plain reference
|
||||
%typemap(in) CONST TYPE & %{
|
||||
$1 = ($1_ltype)((*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0);
|
||||
if(!$1) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
|
||||
return $null;
|
||||
} %}
|
||||
%typemap(out, fragment="SWIG_null_deleter") CONST TYPE &
|
||||
%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner); %}
|
||||
|
||||
// plain pointer by reference
|
||||
%typemap(in) CONST TYPE *& ($*1_ltype temp = 0)
|
||||
%{ temp = ((*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input) ? (*(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$input)->get() : 0);
|
||||
$1 = &temp; %}
|
||||
%typemap(out, fragment="SWIG_null_deleter") CONST TYPE *&
|
||||
%{ *(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > **)&$result = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner); %}
|
||||
|
||||
// shared_ptr by value
|
||||
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > ($&1_type argp)
|
||||
%{ argp = *($&1_ltype*)&$input;
|
||||
if (argp) $1 = *argp; %}
|
||||
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >
|
||||
%{ *($&1_ltype*)&$result = $1 ? new $1_ltype($1) : 0; %}
|
||||
|
||||
// shared_ptr by reference
|
||||
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & ($*1_ltype tempnull)
|
||||
%{ $1 = $input ? *($&1_ltype)&$input : &tempnull; %}
|
||||
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &
|
||||
%{ *($&1_ltype)&$result = *$1 ? new $*1_ltype(*$1) : 0; %}
|
||||
|
||||
// shared_ptr by pointer
|
||||
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * ($*1_ltype tempnull)
|
||||
%{ $1 = $input ? *($&1_ltype)&$input : &tempnull; %}
|
||||
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *
|
||||
%{ *($&1_ltype)&$result = ($1 && *$1) ? new $*1_ltype(*$1) : 0;
|
||||
if ($owner) delete $1; %}
|
||||
|
||||
// shared_ptr by pointer reference
|
||||
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempnull, $*1_ltype temp = 0)
|
||||
%{ temp = $input ? *($1_ltype)&$input : &tempnull;
|
||||
$1 = &temp; %}
|
||||
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *&
|
||||
%{ *($1_ltype)&$result = (*$1 && **$1) ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0; %}
|
||||
|
||||
// various missing typemaps - If ever used (unlikely) ensure compilation error rather than runtime bug
|
||||
%typemap(in) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
|
||||
#error "typemaps for $1_type not available"
|
||||
%}
|
||||
%typemap(out) CONST TYPE[], CONST TYPE[ANY], CONST TYPE (CLASS::*) %{
|
||||
#error "typemaps for $1_type not available"
|
||||
%}
|
||||
|
||||
|
||||
%typemap (jni) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "jlong"
|
||||
%typemap (jtype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "long"
|
||||
%typemap (jstype) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "PROXYCLASS"
|
||||
|
||||
%typemap(javain) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
|
||||
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& "PROXYCLASS.getCPtr($javainput)"
|
||||
|
||||
%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
|
||||
long cPtr = $jnicall;
|
||||
return (cPtr == 0) ? null : new PROXYCLASS(cPtr, true);
|
||||
}
|
||||
%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
|
||||
long cPtr = $jnicall;
|
||||
return (cPtr == 0) ? null : new PROXYCLASS(cPtr, true);
|
||||
}
|
||||
%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
|
||||
long cPtr = $jnicall;
|
||||
return (cPtr == 0) ? null : new PROXYCLASS(cPtr, true);
|
||||
}
|
||||
%typemap(javaout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
|
||||
long cPtr = $jnicall;
|
||||
return (cPtr == 0) ? null : new PROXYCLASS(cPtr, true);
|
||||
}
|
||||
|
||||
|
||||
%typemap(javaout) CONST TYPE {
|
||||
return new PROXYCLASS($jnicall, true);
|
||||
}
|
||||
%typemap(javaout) CONST TYPE & {
|
||||
return new PROXYCLASS($jnicall, true);
|
||||
}
|
||||
%typemap(javaout) CONST TYPE * {
|
||||
long cPtr = $jnicall;
|
||||
return (cPtr == 0) ? null : new PROXYCLASS(cPtr, true);
|
||||
}
|
||||
%typemap(javaout) CONST TYPE *& {
|
||||
long cPtr = $jnicall;
|
||||
return (cPtr == 0) ? null : new PROXYCLASS(cPtr, true);
|
||||
}
|
||||
|
||||
// Base proxy classes
|
||||
%typemap(javabody) TYPE %{
|
||||
private long swigCPtr;
|
||||
private boolean swigCMemOwnBase;
|
||||
|
||||
protected $javaclassname(long cPtr, boolean cMemoryOwn) {
|
||||
swigCMemOwnBase = cMemoryOwn;
|
||||
swigCPtr = cPtr;
|
||||
}
|
||||
|
||||
protected static long getCPtr($javaclassname obj) {
|
||||
return (obj == null) ? 0 : obj.swigCPtr;
|
||||
}
|
||||
%}
|
||||
|
||||
// Derived proxy classes
|
||||
%typemap(javabody_derived) TYPE %{
|
||||
private long swigCPtr;
|
||||
private boolean swigCMemOwnDerived;
|
||||
|
||||
protected $javaclassname(long cPtr, boolean cMemoryOwn) {
|
||||
super($imclassname.$javaclassname_SWIGSharedPtrUpcast(cPtr), true);
|
||||
swigCMemOwnDerived = cMemoryOwn;
|
||||
swigCPtr = cPtr;
|
||||
}
|
||||
|
||||
protected static long getCPtr($javaclassname obj) {
|
||||
return (obj == null) ? 0 : obj.swigCPtr;
|
||||
}
|
||||
%}
|
||||
|
||||
%typemap(javadestruct, methodname="delete", methodmodifiers="public synchronized") TYPE {
|
||||
if(swigCPtr != 0 && swigCMemOwnBase) {
|
||||
swigCMemOwnBase = false;
|
||||
$jnicall;
|
||||
}
|
||||
swigCPtr = 0;
|
||||
}
|
||||
|
||||
%typemap(javadestruct_derived, methodname="delete", methodmodifiers="public synchronized") TYPE {
|
||||
if(swigCPtr != 0 && swigCMemOwnDerived) {
|
||||
swigCMemOwnDerived = false;
|
||||
$jnicall;
|
||||
}
|
||||
swigCPtr = 0;
|
||||
super.delete();
|
||||
}
|
||||
|
||||
// CONST version needed ???? also for C#
|
||||
%typemap(jtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > swigSharedPtrUpcast "long"
|
||||
%typemap(jtype, nopgcpp="1") SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > swigSharedPtrUpcast "long"
|
||||
|
||||
|
||||
%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
|
||||
%enddef
|
||||
|
||||
@@ -0,0 +1,185 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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.
|
||||
*
|
||||
* director.swg
|
||||
*
|
||||
* This file contains support for director classes that proxy
|
||||
* method calls from C++ to Java extensions.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
#if defined(DEBUG_DIRECTOR_OWNED)
|
||||
#include <iostream>
|
||||
#endif
|
||||
|
||||
namespace Swig {
|
||||
/* Java object wrapper */
|
||||
class JObjectWrapper {
|
||||
public:
|
||||
JObjectWrapper() : jthis_(NULL), weak_global_(true) {
|
||||
}
|
||||
|
||||
~JObjectWrapper() {
|
||||
jthis_ = NULL;
|
||||
weak_global_ = true;
|
||||
}
|
||||
|
||||
bool set(JNIEnv *jenv, jobject jobj, bool mem_own, bool weak_global) {
|
||||
if (!jthis_) {
|
||||
weak_global_ = weak_global;
|
||||
if (jobj)
|
||||
jthis_ = ((weak_global_ || !mem_own) ? jenv->NewWeakGlobalRef(jobj) : jenv->NewGlobalRef(jobj));
|
||||
#if defined(DEBUG_DIRECTOR_OWNED)
|
||||
std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> " << jthis_ << std::endl;
|
||||
#endif
|
||||
return true;
|
||||
} else {
|
||||
#if defined(DEBUG_DIRECTOR_OWNED)
|
||||
std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> already set" << std::endl;
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
jobject get(JNIEnv *jenv) const {
|
||||
#if defined(DEBUG_DIRECTOR_OWNED)
|
||||
std::cout << "JObjectWrapper::get(";
|
||||
if (jthis_)
|
||||
std::cout << jthis_;
|
||||
else
|
||||
std::cout << "null";
|
||||
std::cout << ") -> return new local ref" << std::endl;
|
||||
#endif
|
||||
return (jthis_ ? jenv->NewLocalRef(jthis_) : jthis_);
|
||||
}
|
||||
|
||||
void release(JNIEnv *jenv) {
|
||||
#if defined(DEBUG_DIRECTOR_OWNED)
|
||||
std::cout << "JObjectWrapper::release(" << jthis_ << "): " << (weak_global_ ? "weak global ref" : "global ref") << std::endl;
|
||||
#endif
|
||||
if (jthis_) {
|
||||
if (weak_global_) {
|
||||
if (jenv->IsSameObject(jthis_, NULL) == JNI_FALSE)
|
||||
jenv->DeleteWeakGlobalRef((jweak)jthis_);
|
||||
} else
|
||||
jenv->DeleteGlobalRef(jthis_);
|
||||
}
|
||||
|
||||
jthis_ = NULL;
|
||||
weak_global_ = true;
|
||||
}
|
||||
|
||||
jobject peek() {
|
||||
return jthis_;
|
||||
}
|
||||
|
||||
/* Java proxy releases ownership of C++ object, C++ object is now
|
||||
responsible for destruction (creates NewGlobalRef to pin Java
|
||||
proxy) */
|
||||
void java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
|
||||
if (take_or_release) { /* Java takes ownership of C++ object's lifetime. */
|
||||
if (!weak_global_) {
|
||||
jenv->DeleteGlobalRef(jthis_);
|
||||
jthis_ = jenv->NewWeakGlobalRef(jself);
|
||||
weak_global_ = true;
|
||||
}
|
||||
} else { /* Java releases ownership of C++ object's lifetime */
|
||||
if (weak_global_) {
|
||||
jenv->DeleteWeakGlobalRef((jweak)jthis_);
|
||||
jthis_ = jenv->NewGlobalRef(jself);
|
||||
weak_global_ = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
/* pointer to Java object */
|
||||
jobject jthis_;
|
||||
/* Local or global reference flag */
|
||||
bool weak_global_;
|
||||
};
|
||||
|
||||
/* director base class */
|
||||
class Director {
|
||||
/* pointer to Java virtual machine */
|
||||
JavaVM *swig_jvm_;
|
||||
|
||||
protected:
|
||||
#if defined (_MSC_VER) && (_MSC_VER<1300)
|
||||
class JNIEnvWrapper;
|
||||
friend class JNIEnvWrapper;
|
||||
#endif
|
||||
/* Utility class for managing the JNI environment */
|
||||
class JNIEnvWrapper {
|
||||
const Director *director_;
|
||||
JNIEnv *jenv_;
|
||||
public:
|
||||
JNIEnvWrapper(const Director *director) : director_(director), jenv_(0) {
|
||||
director_->swig_jvm_->AttachCurrentThread((void **) &jenv_, NULL);
|
||||
}
|
||||
~JNIEnvWrapper() {
|
||||
// Some JVMs, eg JDK 1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call.
|
||||
// However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak.
|
||||
#if !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD)
|
||||
director_->swig_jvm_->DetachCurrentThread();
|
||||
#endif
|
||||
}
|
||||
JNIEnv *getJNIEnv() const {
|
||||
return jenv_;
|
||||
}
|
||||
};
|
||||
|
||||
/* Java object wrapper */
|
||||
JObjectWrapper swig_self_;
|
||||
|
||||
/* Disconnect director from Java object */
|
||||
void swig_disconnect_director_self(const char *disconn_method) {
|
||||
JNIEnvWrapper jnienv(this) ;
|
||||
JNIEnv *jenv = jnienv.getJNIEnv() ;
|
||||
jobject jobj = swig_self_.peek();
|
||||
#if defined(DEBUG_DIRECTOR_OWNED)
|
||||
std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl;
|
||||
#endif
|
||||
if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) {
|
||||
jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(jobj), disconn_method, "()V");
|
||||
if (disconn_meth) {
|
||||
#if defined(DEBUG_DIRECTOR_OWNED)
|
||||
std::cout << "Swig::Director::disconnect_director_self upcall to " << disconn_method << std::endl;
|
||||
#endif
|
||||
jenv->CallVoidMethod(jobj, disconn_meth);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
Director(JNIEnv *jenv) : swig_jvm_((JavaVM *) NULL), swig_self_() {
|
||||
/* Acquire the Java VM pointer */
|
||||
jenv->GetJavaVM(&swig_jvm_);
|
||||
}
|
||||
|
||||
virtual ~Director() {
|
||||
JNIEnvWrapper jnienv(this) ;
|
||||
JNIEnv *jenv = jnienv.getJNIEnv() ;
|
||||
swig_self_.release(jenv);
|
||||
}
|
||||
|
||||
bool swig_set_self(JNIEnv *jenv, jobject jself, bool mem_own, bool weak_global) {
|
||||
return swig_self_.set(jenv, jself, mem_own, weak_global);
|
||||
}
|
||||
|
||||
jobject swig_get_self(JNIEnv *jenv) const {
|
||||
return swig_self_.get(jenv);
|
||||
}
|
||||
|
||||
// Change C++ object's ownership, relative to Java
|
||||
void swig_java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
|
||||
swig_self_.java_change_ownership(jenv, jself, take_or_release);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
@@ -0,0 +1,117 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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.
|
||||
*
|
||||
* enums.swg
|
||||
*
|
||||
* Include this file in order for C/C++ enums to be wrapped by proper Java enums.
|
||||
* Note that the JNI layer handles the enum as an int. The Java enum has extra
|
||||
* code generated to store the C++ int value. This is required for C++ enums that
|
||||
* specify a value for the enum item, as native Java enums do not support this.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// const enum SWIGTYPE & typemaps
|
||||
%typemap(jni) const enum SWIGTYPE & "jint"
|
||||
%typemap(jtype) const enum SWIGTYPE & "int"
|
||||
%typemap(jstype) const enum SWIGTYPE & "$*javaclassname"
|
||||
|
||||
%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
|
||||
%{ temp = ($*1_ltype)$input;
|
||||
$1 = &temp; %}
|
||||
%typemap(out) const enum SWIGTYPE & %{ $result = (jint)*$1; %}
|
||||
|
||||
%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
|
||||
%{ static $*1_ltype temp = ($*1_ltype)$input;
|
||||
$result = &temp; %}
|
||||
%typemap(directorin, descriptor="L$packagepath/$*javaclassname;") const enum SWIGTYPE & "$input = (jint)$1_name;"
|
||||
%typemap(javadirectorin) const enum SWIGTYPE & "$*javaclassname.swigToEnum($jniinput)"
|
||||
%typemap(javadirectorout) const enum SWIGTYPE & "($javacall).swigValue()"
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_POINTER) const enum SWIGTYPE & ""
|
||||
|
||||
%typemap(throws) const enum SWIGTYPE &
|
||||
%{ (void)$1;
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
|
||||
|
||||
%typemap(javain) const enum SWIGTYPE & "$javainput.swigValue()"
|
||||
%typemap(javaout) const enum SWIGTYPE & {
|
||||
return $*javaclassname.swigToEnum($jnicall);
|
||||
}
|
||||
|
||||
|
||||
// enum SWIGTYPE typemaps
|
||||
%typemap(jni) enum SWIGTYPE "jint"
|
||||
%typemap(jtype) enum SWIGTYPE "int"
|
||||
%typemap(jstype) enum SWIGTYPE "$javaclassname"
|
||||
|
||||
%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
|
||||
%typemap(out) enum SWIGTYPE %{ $result = (jint)$1; %}
|
||||
|
||||
%typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
|
||||
%typemap(directorin, descriptor="L$packagepath/$javaclassname;") enum SWIGTYPE "$input = (jint) $1;"
|
||||
%typemap(javadirectorin) enum SWIGTYPE "$javaclassname.swigToEnum($jniinput)"
|
||||
%typemap(javadirectorout) enum SWIGTYPE "($javacall).swigValue()"
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""
|
||||
|
||||
%typemap(throws) enum SWIGTYPE
|
||||
%{ (void)$1;
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
|
||||
|
||||
%typemap(javain) enum SWIGTYPE "$javainput.swigValue()"
|
||||
%typemap(javaout) enum SWIGTYPE {
|
||||
return $javaclassname.swigToEnum($jnicall);
|
||||
}
|
||||
|
||||
%typemap(javaclassmodifiers) enum SWIGTYPE "public enum"
|
||||
%typemap(javabase) enum SWIGTYPE ""
|
||||
%typemap(javacode) enum SWIGTYPE ""
|
||||
%typemap(javaimports) enum SWIGTYPE ""
|
||||
%typemap(javainterfaces) enum SWIGTYPE ""
|
||||
%typemap(javabody) enum SWIGTYPE ""
|
||||
|
||||
/*
|
||||
* SwigNext static inner class used instead of a static int as static fields cannot be accessed from enum initialisers.
|
||||
* The swigToEnum method is used to find the Java enum from a C++ enum integer value. The default one here takes
|
||||
* advantage of the fact that most enums do not have initial values specified, so the lookup is fast. If initial
|
||||
* values are specified then a lengthy linear search through all possible enums might occur. Specific typemaps could be
|
||||
* written to possibly optimise this lookup by taking advantage of characteristics peculiar to the targeted enum.
|
||||
*/
|
||||
%typemap(javabody) enum SWIGTYPE %{
|
||||
public final int swigValue() {
|
||||
return swigValue;
|
||||
}
|
||||
|
||||
public static $javaclassname swigToEnum(int swigValue) {
|
||||
$javaclassname[] swigValues = $javaclassname.class.getEnumConstants();
|
||||
if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
|
||||
return swigValues[swigValue];
|
||||
for ($javaclassname swigEnum : swigValues)
|
||||
if (swigEnum.swigValue == swigValue)
|
||||
return swigEnum;
|
||||
throw new IllegalArgumentException("No enum " + $javaclassname.class + " with value " + swigValue);
|
||||
}
|
||||
|
||||
private $javaclassname() {
|
||||
this.swigValue = SwigNext.next++;
|
||||
}
|
||||
|
||||
private $javaclassname(int swigValue) {
|
||||
this.swigValue = swigValue;
|
||||
SwigNext.next = swigValue+1;
|
||||
}
|
||||
|
||||
private $javaclassname($javaclassname swigEnum) {
|
||||
this.swigValue = swigEnum.swigValue;
|
||||
SwigNext.next = this.swigValue+1;
|
||||
}
|
||||
|
||||
private final int swigValue;
|
||||
|
||||
private static class SwigNext {
|
||||
private static int next = 0;
|
||||
}
|
||||
%}
|
||||
|
||||
%javaenum(proper);
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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.
|
||||
*
|
||||
* enumsimple.swg
|
||||
*
|
||||
* This file provides backwards compatible enum wrapping. SWIG versions 1.3.21
|
||||
* and earlier wrapped global enums with constant integers in the module class
|
||||
* or Constants interface. Enums declared within a C++ class were wrapped by
|
||||
* constant integers in the Java proxy class.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// const enum SWIGTYPE & typemaps
|
||||
%typemap(jni) const enum SWIGTYPE & "jint"
|
||||
%typemap(jtype) const enum SWIGTYPE & "int"
|
||||
%typemap(jstype) const enum SWIGTYPE & "int"
|
||||
|
||||
%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
|
||||
%{ temp = ($*1_ltype)$input;
|
||||
$1 = &temp; %}
|
||||
%typemap(out) const enum SWIGTYPE & %{ $result = (jint)*$1; %}
|
||||
|
||||
%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
|
||||
%{ static $*1_ltype temp = ($*1_ltype)$input;
|
||||
$result = &temp; %}
|
||||
%typemap(directorin, descriptor="I") const enum SWIGTYPE & "$input = (jint)$1_name;"
|
||||
%typemap(javadirectorin) const enum SWIGTYPE & "$jniinput"
|
||||
%typemap(javadirectorout) const enum SWIGTYPE & "$javacall"
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_INT32) const enum SWIGTYPE & ""
|
||||
|
||||
%typemap(throws) const enum SWIGTYPE &
|
||||
%{ (void)$1;
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
|
||||
|
||||
%typemap(javain) const enum SWIGTYPE & "$javainput"
|
||||
%typemap(javaout) const enum SWIGTYPE & {
|
||||
return $jnicall;
|
||||
}
|
||||
|
||||
|
||||
// enum SWIGTYPE typemaps
|
||||
%typemap(jni) enum SWIGTYPE "jint"
|
||||
%typemap(jtype) enum SWIGTYPE "int"
|
||||
%typemap(jstype) enum SWIGTYPE "int"
|
||||
|
||||
%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
|
||||
%typemap(out) enum SWIGTYPE %{ $result = (jint)$1; %}
|
||||
|
||||
%typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
|
||||
%typemap(directorin, descriptor="I") enum SWIGTYPE "$input = (jint) $1;"
|
||||
%typemap(javadirectorin) enum SWIGTYPE "$jniinput"
|
||||
%typemap(javadirectorout) enum SWIGTYPE "$javacall"
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_INT32) enum SWIGTYPE ""
|
||||
|
||||
%typemap(throws) enum SWIGTYPE
|
||||
%{ (void)$1;
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
|
||||
|
||||
%typemap(javain) enum SWIGTYPE "$javainput"
|
||||
%typemap(javaout) enum SWIGTYPE {
|
||||
return $jnicall;
|
||||
}
|
||||
|
||||
%typemap(javaclassmodifiers) enum SWIGTYPE ""
|
||||
%typemap(javabase) enum SWIGTYPE ""
|
||||
%typemap(javacode) enum SWIGTYPE ""
|
||||
%typemap(javaimports) enum SWIGTYPE ""
|
||||
%typemap(javainterfaces) enum SWIGTYPE ""
|
||||
%typemap(javabody) enum SWIGTYPE ""
|
||||
|
||||
%javaenum(simple);
|
||||
|
||||
@@ -0,0 +1,121 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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.
|
||||
*
|
||||
* enumtypesafe.swg
|
||||
*
|
||||
* Include this file in order for C/C++ enums to be wrapped by the so called
|
||||
* typesafe enum pattern. Each enum has an equivalent Java class named after the
|
||||
* enum and each enum item is a static instance of this class.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// const enum SWIGTYPE & typemaps
|
||||
%typemap(jni) const enum SWIGTYPE & "jint"
|
||||
%typemap(jtype) const enum SWIGTYPE & "int"
|
||||
%typemap(jstype) const enum SWIGTYPE & "$*javaclassname"
|
||||
|
||||
%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
|
||||
%{ temp = ($*1_ltype)$input;
|
||||
$1 = &temp; %}
|
||||
%typemap(out) const enum SWIGTYPE & %{ $result = (jint)*$1; %}
|
||||
|
||||
%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
|
||||
%{ static $*1_ltype temp = ($*1_ltype)$input;
|
||||
$result = &temp; %}
|
||||
%typemap(directorin, descriptor="L$packagepath/$*javaclassname;") const enum SWIGTYPE & "$input = (jint)$1_name;"
|
||||
%typemap(javadirectorin) const enum SWIGTYPE & "$*javaclassname.swigToEnum($jniinput)"
|
||||
%typemap(javadirectorout) const enum SWIGTYPE & "($javacall).swigValue()"
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_POINTER) const enum SWIGTYPE & ""
|
||||
|
||||
%typemap(throws) const enum SWIGTYPE &
|
||||
%{ (void)$1;
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
|
||||
|
||||
%typemap(javain) const enum SWIGTYPE & "$javainput.swigValue()"
|
||||
%typemap(javaout) const enum SWIGTYPE & {
|
||||
return $*javaclassname.swigToEnum($jnicall);
|
||||
}
|
||||
|
||||
// enum SWIGTYPE typemaps
|
||||
%typemap(jni) enum SWIGTYPE "jint"
|
||||
%typemap(jtype) enum SWIGTYPE "int"
|
||||
%typemap(jstype) enum SWIGTYPE "$javaclassname"
|
||||
|
||||
%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
|
||||
%typemap(out) enum SWIGTYPE %{ $result = (jint)$1; %}
|
||||
|
||||
%typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
|
||||
%typemap(directorin, descriptor="L$packagepath/$javaclassname;") enum SWIGTYPE "$input = (jint) $1;"
|
||||
%typemap(javadirectorin) enum SWIGTYPE "$javaclassname.swigToEnum($jniinput)"
|
||||
%typemap(javadirectorout) enum SWIGTYPE "($javacall).swigValue()"
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_POINTER) enum SWIGTYPE ""
|
||||
|
||||
%typemap(throws) enum SWIGTYPE
|
||||
%{ (void)$1;
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
|
||||
|
||||
%typemap(javain) enum SWIGTYPE "$javainput.swigValue()"
|
||||
%typemap(javaout) enum SWIGTYPE {
|
||||
return $javaclassname.swigToEnum($jnicall);
|
||||
}
|
||||
|
||||
// '$static' will be replaced with either 'static' or nothing depending on whether the enum is an inner Java class or not
|
||||
%typemap(javaclassmodifiers) enum SWIGTYPE "public final $static class"
|
||||
%typemap(javabase) enum SWIGTYPE ""
|
||||
%typemap(javacode) enum SWIGTYPE ""
|
||||
%typemap(javaimports) enum SWIGTYPE ""
|
||||
%typemap(javainterfaces) enum SWIGTYPE ""
|
||||
%typemap(javabody) enum SWIGTYPE ""
|
||||
|
||||
/*
|
||||
* The swigToEnum method is used to find the Java enum from a C++ enum integer value. The default one here takes
|
||||
* advantage of the fact that most enums do not have initial values specified, so the lookup is fast. If initial
|
||||
* values are specified then a lengthy linear search through all possible enums might occur. Specific typemaps could be
|
||||
* written to possibly optimise this lookup by taking advantage of characteristics peculiar to the targeted enum.
|
||||
* The special variable, $enumvalues, is replaced with a comma separated list of all the enum values.
|
||||
*/
|
||||
%typemap(javabody) enum SWIGTYPE %{
|
||||
public final int swigValue() {
|
||||
return swigValue;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return swigName;
|
||||
}
|
||||
|
||||
public static $javaclassname swigToEnum(int swigValue) {
|
||||
if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
|
||||
return swigValues[swigValue];
|
||||
for (int i = 0; i < swigValues.length; i++)
|
||||
if (swigValues[i].swigValue == swigValue)
|
||||
return swigValues[i];
|
||||
throw new IllegalArgumentException("No enum " + $javaclassname.class + " with value " + swigValue);
|
||||
}
|
||||
|
||||
private $javaclassname(String swigName) {
|
||||
this.swigName = swigName;
|
||||
this.swigValue = swigNext++;
|
||||
}
|
||||
|
||||
private $javaclassname(String swigName, int swigValue) {
|
||||
this.swigName = swigName;
|
||||
this.swigValue = swigValue;
|
||||
swigNext = swigValue+1;
|
||||
}
|
||||
|
||||
private $javaclassname(String swigName, $javaclassname swigEnum) {
|
||||
this.swigName = swigName;
|
||||
this.swigValue = swigEnum.swigValue;
|
||||
swigNext = this.swigValue+1;
|
||||
}
|
||||
|
||||
private static $javaclassname[] swigValues = { $enumvalues };
|
||||
private static int swigNext = 0;
|
||||
private final int swigValue;
|
||||
private final String swigName;
|
||||
%}
|
||||
|
||||
%javaenum(typesafe);
|
||||
|
||||
@@ -0,0 +1,75 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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.
|
||||
*
|
||||
* enumtypeunsafe.swg
|
||||
*
|
||||
* Include this file in order for C/C++ enums to be wrapped by integers values.
|
||||
* Each enum has an equivalent class named after the enum and the enum items are
|
||||
* wrapped by constant integers within this class. The enum items are not
|
||||
* typesafe as they are all integers.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// const enum SWIGTYPE & typemaps
|
||||
%typemap(jni) const enum SWIGTYPE & "jint"
|
||||
%typemap(jtype) const enum SWIGTYPE & "int"
|
||||
%typemap(jstype) const enum SWIGTYPE & "int"
|
||||
|
||||
%typemap(in) const enum SWIGTYPE & ($*1_ltype temp)
|
||||
%{ temp = ($*1_ltype)$input;
|
||||
$1 = &temp; %}
|
||||
%typemap(out) const enum SWIGTYPE & %{ $result = (jint)*$1; %}
|
||||
|
||||
%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const enum SWIGTYPE &
|
||||
%{ static $*1_ltype temp = ($*1_ltype)$input;
|
||||
$result = &temp; %}
|
||||
%typemap(directorin, descriptor="I") const enum SWIGTYPE & "$input = (jint)$1_name;"
|
||||
%typemap(javadirectorin) const enum SWIGTYPE & "$jniinput"
|
||||
%typemap(javadirectorout) const enum SWIGTYPE & "$javacall"
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_INT32) const enum SWIGTYPE & ""
|
||||
|
||||
%typemap(throws) const enum SWIGTYPE &
|
||||
%{ (void)$1;
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
|
||||
|
||||
%typemap(javain) const enum SWIGTYPE & "$javainput"
|
||||
%typemap(javaout) const enum SWIGTYPE & {
|
||||
return $jnicall;
|
||||
}
|
||||
|
||||
|
||||
// enum SWIGTYPE typemaps
|
||||
%typemap(jni) enum SWIGTYPE "jint"
|
||||
%typemap(jtype) enum SWIGTYPE "int"
|
||||
%typemap(jstype) enum SWIGTYPE "int"
|
||||
|
||||
%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
|
||||
%typemap(out) enum SWIGTYPE %{ $result = (jint)$1; %}
|
||||
|
||||
%typemap(directorout) enum SWIGTYPE %{ $result = ($1_ltype)$input; %}
|
||||
%typemap(directorin, descriptor="I") enum SWIGTYPE "$input = (jint) $1;"
|
||||
%typemap(javadirectorin) enum SWIGTYPE "$jniinput"
|
||||
%typemap(javadirectorout) enum SWIGTYPE "$javacall"
|
||||
|
||||
%typecheck(SWIG_TYPECHECK_INT32) enum SWIGTYPE ""
|
||||
|
||||
%typemap(throws) enum SWIGTYPE
|
||||
%{ (void)$1;
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); %}
|
||||
|
||||
%typemap(javain) enum SWIGTYPE "$javainput"
|
||||
%typemap(javaout) enum SWIGTYPE {
|
||||
return $jnicall;
|
||||
}
|
||||
|
||||
// '$static' will be replaced with either 'static' or nothing depending on whether the enum is an inner Java class or not
|
||||
%typemap(javaclassmodifiers) enum SWIGTYPE "public final $static class"
|
||||
%typemap(javabase) enum SWIGTYPE ""
|
||||
%typemap(javacode) enum SWIGTYPE ""
|
||||
%typemap(javaimports) enum SWIGTYPE ""
|
||||
%typemap(javainterfaces) enum SWIGTYPE ""
|
||||
%typemap(javabody) enum SWIGTYPE ""
|
||||
|
||||
%javaenum(typeunsafe);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,103 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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.
|
||||
*
|
||||
* javahead.swg
|
||||
*
|
||||
* Java support code
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
|
||||
/* JNI function calls require different calling conventions for C and C++. These JCALL macros are used so
|
||||
* that the same typemaps can be used for generating code for both C and C++. The SWIG preprocessor can expand
|
||||
* the macros thereby generating the correct calling convention. It is thus essential that all typemaps that
|
||||
* use the macros are not within %{ %} brackets as they won't be run through the SWIG preprocessor. */
|
||||
#ifdef __cplusplus
|
||||
# define JCALL0(func, jenv) jenv->func()
|
||||
# define JCALL1(func, jenv, ar1) jenv->func(ar1)
|
||||
# define JCALL2(func, jenv, ar1, ar2) jenv->func(ar1, ar2)
|
||||
# define JCALL3(func, jenv, ar1, ar2, ar3) jenv->func(ar1, ar2, ar3)
|
||||
# define JCALL4(func, jenv, ar1, ar2, ar3, ar4) jenv->func(ar1, ar2, ar3, ar4)
|
||||
# define JCALL5(func, jenv, ar1, ar2, ar3, ar4, ar5) jenv->func(ar1, ar2, ar3, ar4, ar5)
|
||||
# define JCALL6(func, jenv, ar1, ar2, ar3, ar4, ar5, ar6) jenv->func(ar1, ar2, ar3, ar4, ar5, ar6)
|
||||
# define JCALL7(func, jenv, ar1, ar2, ar3, ar4, ar5, ar6, ar7) jenv->func(ar1, ar2, ar3, ar4, ar5, ar6, ar7)
|
||||
#else
|
||||
# define JCALL0(func, jenv) (*jenv)->func(jenv)
|
||||
# define JCALL1(func, jenv, ar1) (*jenv)->func(jenv, ar1)
|
||||
# define JCALL2(func, jenv, ar1, ar2) (*jenv)->func(jenv, ar1, ar2)
|
||||
# define JCALL3(func, jenv, ar1, ar2, ar3) (*jenv)->func(jenv, ar1, ar2, ar3)
|
||||
# define JCALL4(func, jenv, ar1, ar2, ar3, ar4) (*jenv)->func(jenv, ar1, ar2, ar3, ar4)
|
||||
# define JCALL5(func, jenv, ar1, ar2, ar3, ar4, ar5) (*jenv)->func(jenv, ar1, ar2, ar3, ar4, ar5)
|
||||
# define JCALL6(func, jenv, ar1, ar2, ar3, ar4, ar5, ar6) (*jenv)->func(jenv, ar1, ar2, ar3, ar4, ar5, ar6)
|
||||
# define JCALL7(func, jenv, ar1, ar2, ar3, ar4, ar5, ar6, ar7) (*jenv)->func(jenv, ar1, ar2, ar3, ar4, ar5, ar6, ar7)
|
||||
#endif
|
||||
|
||||
%insert(runtime) %{
|
||||
/* Fix for jlong on some versions of gcc on Windows */
|
||||
#if defined(__GNUC__) && !defined(__INTELC__)
|
||||
typedef long long __int64;
|
||||
#endif
|
||||
|
||||
/* Fix for jlong on 64-bit x86 Solaris */
|
||||
#if defined(__x86_64)
|
||||
# ifdef _LP64
|
||||
# undef _LP64
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include <jni.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
%}
|
||||
|
||||
%insert(runtime) %{
|
||||
/* Support for throwing Java exceptions */
|
||||
typedef enum {
|
||||
SWIG_JavaOutOfMemoryError = 1,
|
||||
SWIG_JavaIOException,
|
||||
SWIG_JavaRuntimeException,
|
||||
SWIG_JavaIndexOutOfBoundsException,
|
||||
SWIG_JavaArithmeticException,
|
||||
SWIG_JavaIllegalArgumentException,
|
||||
SWIG_JavaNullPointerException,
|
||||
SWIG_JavaDirectorPureVirtual,
|
||||
SWIG_JavaUnknownError
|
||||
} SWIG_JavaExceptionCodes;
|
||||
|
||||
typedef struct {
|
||||
SWIG_JavaExceptionCodes code;
|
||||
const char *java_exception;
|
||||
} SWIG_JavaExceptions_t;
|
||||
%}
|
||||
|
||||
%insert(runtime) {
|
||||
static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
|
||||
jclass excep;
|
||||
static const SWIG_JavaExceptions_t java_exceptions[] = {
|
||||
{ SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
|
||||
{ SWIG_JavaIOException, "java/io/IOException" },
|
||||
{ SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
|
||||
{ SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
|
||||
{ SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
|
||||
{ SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
|
||||
{ SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
|
||||
{ SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
|
||||
{ SWIG_JavaUnknownError, "java/lang/UnknownError" },
|
||||
{ (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" } };
|
||||
const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
|
||||
|
||||
while (except_ptr->code != code && except_ptr->code)
|
||||
except_ptr++;
|
||||
|
||||
JCALL0(ExceptionClear, jenv);
|
||||
excep = JCALL1(FindClass, jenv, except_ptr->java_exception);
|
||||
if (excep)
|
||||
JCALL2(ThrowNew, jenv, excep, msg);
|
||||
}
|
||||
}
|
||||
|
||||
%insert(runtime) %{
|
||||
/* Contract support */
|
||||
|
||||
#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else
|
||||
%}
|
||||
@@ -0,0 +1,70 @@
|
||||
#ifndef JAVA_JAVAKW_SWG_
|
||||
#define JAVA_JAVAKW_SWG_
|
||||
|
||||
/* Warnings for Java keywords */
|
||||
#define JAVAKW(x) %namewarn("314:" #x " is a java keyword") #x
|
||||
|
||||
/*
|
||||
from
|
||||
http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html
|
||||
*/
|
||||
|
||||
JAVAKW(abstract);
|
||||
JAVAKW(double);
|
||||
JAVAKW(int);
|
||||
JAVAKW(strictfp);
|
||||
JAVAKW(boolean);
|
||||
JAVAKW(else);
|
||||
JAVAKW(interface);
|
||||
JAVAKW(super);
|
||||
JAVAKW(break);
|
||||
JAVAKW(extends);
|
||||
JAVAKW(long);
|
||||
JAVAKW(switch);
|
||||
JAVAKW(byte);
|
||||
JAVAKW(final);
|
||||
JAVAKW(native);
|
||||
JAVAKW(synchronized);
|
||||
JAVAKW(case);
|
||||
JAVAKW(finally);
|
||||
JAVAKW(new);
|
||||
JAVAKW(this);
|
||||
JAVAKW(catch);
|
||||
JAVAKW(float);
|
||||
JAVAKW(package);
|
||||
JAVAKW(throw);
|
||||
JAVAKW(char);
|
||||
JAVAKW(for);
|
||||
JAVAKW(private);
|
||||
JAVAKW(throws);
|
||||
JAVAKW(class);
|
||||
JAVAKW(goto);
|
||||
JAVAKW(protected);
|
||||
JAVAKW(transient);
|
||||
JAVAKW(const);
|
||||
JAVAKW(if);
|
||||
JAVAKW(public);
|
||||
JAVAKW(try);
|
||||
JAVAKW(continue);
|
||||
JAVAKW(implements);
|
||||
JAVAKW(return);
|
||||
JAVAKW(void);
|
||||
JAVAKW(default);
|
||||
JAVAKW(import);
|
||||
JAVAKW(short);
|
||||
JAVAKW(volatile);
|
||||
JAVAKW(do);
|
||||
JAVAKW(instanceof);
|
||||
JAVAKW(static);
|
||||
JAVAKW(while);
|
||||
|
||||
|
||||
/* others bad names */
|
||||
|
||||
/* Note here that only *::clone() is bad, and *::clone(int) is ok */
|
||||
%namewarn("321:clone() is a java bad method name") *::clone();
|
||||
|
||||
|
||||
#undef JAVAKW
|
||||
|
||||
#endif //JAVA_JAVAKW_SWG_
|
||||
@@ -0,0 +1,5 @@
|
||||
%include <std_except.i>
|
||||
|
||||
%apply size_t { std::size_t };
|
||||
%apply const size_t& { const std::size_t& };
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
%include <std/_std_deque.i>
|
||||
@@ -0,0 +1,33 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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_except.i
|
||||
*
|
||||
* Typemaps used by the STL wrappers that throw exceptions.
|
||||
* These typemaps are used when methods are declared with an STL exception specification, such as
|
||||
* size_t at() const throw (std::out_of_range);
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%{
|
||||
#include <stdexcept>
|
||||
%}
|
||||
|
||||
namespace std
|
||||
{
|
||||
%ignore exception;
|
||||
struct exception {};
|
||||
}
|
||||
|
||||
%typemap(throws) std::bad_exception "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::domain_error "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::exception "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::invalid_argument "SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::length_error "SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::logic_error "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::out_of_range "SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::overflow_error "SWIG_JavaThrowException(jenv, SWIG_JavaArithmeticException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::range_error "SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::runtime_error "SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.what());\n return $null;"
|
||||
%typemap(throws) std::underflow_error "SWIG_JavaThrowException(jenv, SWIG_JavaArithmeticException, $1.what());\n return $null;"
|
||||
|
||||
@@ -0,0 +1,179 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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_map.i
|
||||
*
|
||||
* SWIG typemaps for std::map
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%include <std_common.i>
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// std::map
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
%{
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
|
||||
// exported class
|
||||
|
||||
namespace std {
|
||||
|
||||
template<class K, class T> class map {
|
||||
// add typemaps here
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef K key_type;
|
||||
typedef T mapped_type;
|
||||
map();
|
||||
map(const map<K,T> &);
|
||||
|
||||
unsigned int size() const;
|
||||
bool empty() const;
|
||||
void clear();
|
||||
%extend {
|
||||
const T& get(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
return i->second;
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
void set(const K& key, const T& x) {
|
||||
(*self)[key] = x;
|
||||
}
|
||||
void del(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
self->erase(i);
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
bool has_key(const K& key) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
return i != self->end();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// specializations for built-ins
|
||||
|
||||
%define specialize_std_map_on_key(K,CHECK,CONVERT_FROM,CONVERT_TO)
|
||||
|
||||
template<class T> class map<K,T> {
|
||||
// add typemaps here
|
||||
public:
|
||||
map();
|
||||
map(const map<K,T> &);
|
||||
|
||||
unsigned int size() const;
|
||||
bool empty() const;
|
||||
void clear();
|
||||
%extend {
|
||||
T& get(K key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
return i->second;
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
void set(K key, const T& x) {
|
||||
(*self)[key] = x;
|
||||
}
|
||||
void del(K key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
self->erase(i);
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
bool has_key(K key) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
return i != self->end();
|
||||
}
|
||||
}
|
||||
};
|
||||
%enddef
|
||||
|
||||
%define specialize_std_map_on_value(T,CHECK,CONVERT_FROM,CONVERT_TO)
|
||||
template<class K> class map<K,T> {
|
||||
// add typemaps here
|
||||
public:
|
||||
map();
|
||||
map(const map<K,T> &);
|
||||
|
||||
unsigned int size() const;
|
||||
bool empty() const;
|
||||
void clear();
|
||||
%extend {
|
||||
T get(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
return i->second;
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
void set(const K& key, T x) {
|
||||
(*self)[key] = x;
|
||||
}
|
||||
void del(const K& key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
self->erase(i);
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
bool has_key(const K& key) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
return i != self->end();
|
||||
}
|
||||
}
|
||||
};
|
||||
%enddef
|
||||
|
||||
%define specialize_std_map_on_both(K,CHECK_K,CONVERT_K_FROM,CONVERT_K_TO,
|
||||
T,CHECK_T,CONVERT_T_FROM,CONVERT_T_TO)
|
||||
template<> class map<K,T> {
|
||||
// add typemaps here
|
||||
public:
|
||||
map();
|
||||
map(const map<K,T> &);
|
||||
|
||||
unsigned int size() const;
|
||||
bool empty() const;
|
||||
void clear();
|
||||
%extend {
|
||||
T get(K key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
return i->second;
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
void set(K key, T x) {
|
||||
(*self)[key] = x;
|
||||
}
|
||||
void del(K key) throw (std::out_of_range) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
if (i != self->end())
|
||||
self->erase(i);
|
||||
else
|
||||
throw std::out_of_range("key not found");
|
||||
}
|
||||
bool has_key(K key) {
|
||||
std::map<K,T >::iterator i = self->find(key);
|
||||
return i != self->end();
|
||||
}
|
||||
}
|
||||
};
|
||||
%enddef
|
||||
|
||||
// add specializations here
|
||||
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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_pair.i
|
||||
*
|
||||
* SWIG typemaps for std::pair
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%include <std_common.i>
|
||||
%include <exception.i>
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// std::pair
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
%{
|
||||
#include <utility>
|
||||
%}
|
||||
|
||||
namespace std {
|
||||
|
||||
template<class T, class U> struct pair {
|
||||
|
||||
pair();
|
||||
pair(T first, U second);
|
||||
pair(const pair& p);
|
||||
|
||||
template <class U1, class U2> pair(const pair<U1, U2> &p);
|
||||
|
||||
T first;
|
||||
U second;
|
||||
};
|
||||
|
||||
// add specializations here
|
||||
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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_string.i
|
||||
*
|
||||
* Typemaps for std::string and const std::string&
|
||||
* These are mapped to a Java String and are passed around by value.
|
||||
*
|
||||
* To use non-const std::string references use the following %apply. Note
|
||||
* that they are passed by value.
|
||||
* %apply const std::string & {std::string &};
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%{
|
||||
#include <string>
|
||||
%}
|
||||
|
||||
namespace std {
|
||||
|
||||
%naturalvar string;
|
||||
|
||||
class string;
|
||||
|
||||
// string
|
||||
%typemap(jni) string "jstring"
|
||||
%typemap(jtype) string "String"
|
||||
%typemap(jstype) string "String"
|
||||
%typemap(javadirectorin) string "$jniinput"
|
||||
%typemap(javadirectorout) string "$javacall"
|
||||
|
||||
%typemap(in) string
|
||||
%{ if(!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::string");
|
||||
return $null;
|
||||
}
|
||||
const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0);
|
||||
if (!$1_pstr) return $null;
|
||||
$1.assign($1_pstr);
|
||||
jenv->ReleaseStringUTFChars($input, $1_pstr); %}
|
||||
|
||||
%typemap(directorout) string
|
||||
%{ if(!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::string");
|
||||
return $null;
|
||||
}
|
||||
const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0);
|
||||
if (!$1_pstr) return $null;
|
||||
$result.assign($1_pstr);
|
||||
jenv->ReleaseStringUTFChars($input, $1_pstr); %}
|
||||
|
||||
%typemap(directorin,descriptor="Ljava/lang/String;") string
|
||||
%{ $input = jenv->NewStringUTF($1.c_str()); %}
|
||||
|
||||
%typemap(out) string
|
||||
%{ $result = jenv->NewStringUTF($1.c_str()); %}
|
||||
|
||||
%typemap(javain) string "$javainput"
|
||||
|
||||
%typemap(javaout) string {
|
||||
return $jnicall;
|
||||
}
|
||||
|
||||
%typemap(typecheck) string = char *;
|
||||
|
||||
%typemap(throws) string
|
||||
%{ SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.c_str());
|
||||
return $null; %}
|
||||
|
||||
// const string &
|
||||
%typemap(jni) const string & "jstring"
|
||||
%typemap(jtype) const string & "String"
|
||||
%typemap(jstype) const string & "String"
|
||||
%typemap(javadirectorin) const string & "$jniinput"
|
||||
%typemap(javadirectorout) const string & "$javacall"
|
||||
|
||||
%typemap(in) const string &
|
||||
%{ if(!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::string");
|
||||
return $null;
|
||||
}
|
||||
const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0);
|
||||
if (!$1_pstr) return $null;
|
||||
std::string $1_str($1_pstr);
|
||||
$1 = &$1_str;
|
||||
jenv->ReleaseStringUTFChars($input, $1_pstr); %}
|
||||
|
||||
%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const string &
|
||||
%{ if(!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::string");
|
||||
return $null;
|
||||
}
|
||||
const char *$1_pstr = (const char *)jenv->GetStringUTFChars($input, 0);
|
||||
if (!$1_pstr) return $null;
|
||||
/* possible thread/reentrant code problem */
|
||||
static std::string $1_str;
|
||||
$1_str = $1_pstr;
|
||||
$result = &$1_str;
|
||||
jenv->ReleaseStringUTFChars($input, $1_pstr); %}
|
||||
|
||||
%typemap(directorin,descriptor="Ljava/lang/String;") const string &
|
||||
%{ $input = jenv->NewStringUTF($1.c_str()); %}
|
||||
|
||||
%typemap(out) const string &
|
||||
%{ $result = jenv->NewStringUTF($1->c_str()); %}
|
||||
|
||||
%typemap(javain) const string & "$javainput"
|
||||
|
||||
%typemap(javaout) const string & {
|
||||
return $jnicall;
|
||||
}
|
||||
|
||||
%typemap(typecheck) const string & = char *;
|
||||
|
||||
%typemap(throws) const string &
|
||||
%{ SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1.c_str());
|
||||
return $null; %}
|
||||
|
||||
}
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%include <std_common.i>
|
||||
|
||||
%{
|
||||
#include <vector>
|
||||
#include <stdexcept>
|
||||
%}
|
||||
|
||||
namespace std {
|
||||
|
||||
template<class T> class vector {
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef T value_type;
|
||||
typedef const value_type& const_reference;
|
||||
vector();
|
||||
vector(size_type n);
|
||||
size_type size() const;
|
||||
size_type capacity() const;
|
||||
void reserve(size_type n);
|
||||
%rename(isEmpty) empty;
|
||||
bool empty() const;
|
||||
void clear();
|
||||
%rename(add) push_back;
|
||||
void push_back(const value_type& x);
|
||||
%extend {
|
||||
const_reference get(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 value_type& val) throw (std::out_of_range) {
|
||||
int size = int(self->size());
|
||||
if (i>=0 && i<size)
|
||||
(*self)[i] = val;
|
||||
else
|
||||
throw std::out_of_range("vector index out of range");
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
%define specialize_std_vector(T)
|
||||
#warning "specialize_std_vector - specialization for type T no longer needed"
|
||||
%enddef
|
||||
|
||||
@@ -0,0 +1,175 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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_wstring.i
|
||||
*
|
||||
* Typemaps for std::wstring and const std::wstring&
|
||||
*
|
||||
* These are mapped to a Java String and are passed around by value.
|
||||
* Warning: Unicode / multibyte characters are handled differently on different
|
||||
* OSs so the std::wstring typemaps may not always work as intended.
|
||||
*
|
||||
* To use non-const std::wstring references use the following %apply. Note
|
||||
* that they are passed by value.
|
||||
* %apply const std::wstring & {std::wstring &};
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
namespace std {
|
||||
|
||||
%naturalvar wstring;
|
||||
|
||||
class wstring;
|
||||
|
||||
// wstring
|
||||
%typemap(jni) wstring "jstring"
|
||||
%typemap(jtype) wstring "String"
|
||||
%typemap(jstype) wstring "String"
|
||||
%typemap(javadirectorin) wstring "$jniinput"
|
||||
%typemap(javadirectorout) wstring "$javacall"
|
||||
|
||||
%typemap(in) wstring
|
||||
%{if(!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
|
||||
return $null;
|
||||
}
|
||||
const jchar *$1_pstr = jenv->GetStringChars($input, 0);
|
||||
if (!$1_pstr) return $null;
|
||||
jsize $1_len = jenv->GetStringLength($input);
|
||||
if ($1_len) {
|
||||
$1.reserve($1_len);
|
||||
for (jsize i = 0; i < $1_len; ++i) {
|
||||
$1.push_back((wchar_t)$1_pstr[i]);
|
||||
}
|
||||
}
|
||||
jenv->ReleaseStringChars($input, $1_pstr);
|
||||
%}
|
||||
|
||||
%typemap(directorout) wstring
|
||||
%{if(!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
|
||||
return $null;
|
||||
}
|
||||
const jchar *$1_pstr = jenv->GetStringChars($input, 0);
|
||||
if (!$1_pstr) return $null;
|
||||
jsize $1_len = jenv->GetStringLength($input);
|
||||
if ($1_len) {
|
||||
$result.reserve($1_len);
|
||||
for (jsize i = 0; i < $1_len; ++i) {
|
||||
$result.push_back((wchar_t)$1_pstr[i]);
|
||||
}
|
||||
}
|
||||
jenv->ReleaseStringChars($input, $1_pstr);
|
||||
%}
|
||||
|
||||
%typemap(directorin,descriptor="Ljava/lang/String;") wstring {
|
||||
jsize $1_len = $1.length();
|
||||
jchar *conv_buf = new jchar[$1_len];
|
||||
for (jsize i = 0; i < $1_len; ++i) {
|
||||
conv_buf[i] = (jchar)$1[i];
|
||||
}
|
||||
$input = jenv->NewString(conv_buf, $1_len);
|
||||
delete [] conv_buf;
|
||||
}
|
||||
|
||||
%typemap(out) wstring
|
||||
%{jsize $1_len = $1.length();
|
||||
jchar *conv_buf = new jchar[$1_len];
|
||||
for (jsize i = 0; i < $1_len; ++i) {
|
||||
conv_buf[i] = (jchar)$1[i];
|
||||
}
|
||||
$result = jenv->NewString(conv_buf, $1_len);
|
||||
delete [] conv_buf; %}
|
||||
|
||||
%typemap(javain) wstring "$javainput"
|
||||
|
||||
%typemap(javaout) wstring {
|
||||
return $jnicall;
|
||||
}
|
||||
|
||||
//%typemap(typecheck) wstring = wchar_t *;
|
||||
|
||||
%typemap(throws) wstring
|
||||
%{ std::string message($1.begin(), $1.end());
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, message.c_str());
|
||||
return $null; %}
|
||||
|
||||
// const wstring &
|
||||
%typemap(jni) const wstring & "jstring"
|
||||
%typemap(jtype) const wstring & "String"
|
||||
%typemap(jstype) const wstring & "String"
|
||||
%typemap(javadirectorin) const wstring & "$jniinput"
|
||||
%typemap(javadirectorout) const wstring & "$javacall"
|
||||
|
||||
%typemap(in) const wstring &
|
||||
%{if(!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
|
||||
return $null;
|
||||
}
|
||||
const jchar *$1_pstr = jenv->GetStringChars($input, 0);
|
||||
if (!$1_pstr) return $null;
|
||||
jsize $1_len = jenv->GetStringLength($input);
|
||||
std::wstring $1_str;
|
||||
if ($1_len) {
|
||||
$1_str.reserve($1_len);
|
||||
for (jsize i = 0; i < $1_len; ++i) {
|
||||
$1_str.push_back((wchar_t)$1_pstr[i]);
|
||||
}
|
||||
}
|
||||
$1 = &$1_str;
|
||||
jenv->ReleaseStringChars($input, $1_pstr);
|
||||
%}
|
||||
|
||||
%typemap(directorout,warning=SWIGWARN_TYPEMAP_THREAD_UNSAFE_MSG) const wstring &
|
||||
%{if(!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null std::wstring");
|
||||
return $null;
|
||||
}
|
||||
const jchar *$1_pstr = jenv->GetStringChars($input, 0);
|
||||
if (!$1_pstr) return $null;
|
||||
jsize $1_len = jenv->GetStringLength($input);
|
||||
/* possible thread/reentrant code problem */
|
||||
static std::wstring $1_str;
|
||||
if ($1_len) {
|
||||
$1_str.reserve($1_len);
|
||||
for (jsize i = 0; i < $1_len; ++i) {
|
||||
$1_str.push_back((wchar_t)$1_pstr[i]);
|
||||
}
|
||||
}
|
||||
$result = &$1_str;
|
||||
jenv->ReleaseStringChars($input, $1_pstr); %}
|
||||
|
||||
%typemap(directorin,descriptor="Ljava/lang/String;") const wstring & {
|
||||
jsize $1_len = $1.length();
|
||||
jchar *conv_buf = new jchar[$1_len];
|
||||
for (jsize i = 0; i < $1_len; ++i) {
|
||||
conv_buf[i] = (jchar)($1)[i];
|
||||
}
|
||||
$input = jenv->NewString(conv_buf, $1_len);
|
||||
delete [] conv_buf;
|
||||
}
|
||||
|
||||
%typemap(out) const wstring &
|
||||
%{jsize $1_len = $1->length();
|
||||
jchar *conv_buf = new jchar[$1_len];
|
||||
for (jsize i = 0; i < $1_len; ++i) {
|
||||
conv_buf[i] = (jchar)(*$1)[i];
|
||||
}
|
||||
$result = jenv->NewString(conv_buf, $1_len);
|
||||
delete [] conv_buf; %}
|
||||
|
||||
%typemap(javain) const wstring & "$javainput"
|
||||
|
||||
%typemap(javaout) const wstring & {
|
||||
return $jnicall;
|
||||
}
|
||||
|
||||
//%typemap(typecheck) const wstring & = wchar_t *;
|
||||
|
||||
%typemap(throws) const wstring &
|
||||
%{ std::string message($1.begin(), $1.end());
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, message.c_str());
|
||||
return $null; %}
|
||||
|
||||
}
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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.
|
||||
*
|
||||
* stl.i
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%include <std_common.i>
|
||||
%include <std_string.i>
|
||||
%include <std_vector.i>
|
||||
%include <std_map.i>
|
||||
%include <std_pair.i>
|
||||
|
||||
@@ -0,0 +1,449 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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.
|
||||
*
|
||||
* typemaps.i
|
||||
*
|
||||
* Pointer and reference handling typemap library
|
||||
*
|
||||
* These mappings provide support for input/output arguments and common
|
||||
* uses for C/C++ pointers and C++ references.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
/*
|
||||
INPUT typemaps
|
||||
--------------
|
||||
|
||||
These typemaps remap a C pointer or C++ reference to be an "INPUT" value which is
|
||||
passed by value instead of reference.
|
||||
|
||||
The following typemaps can be applied to turn a pointer or reference into a simple
|
||||
input value. That is, instead of passing a pointer or reference to an object,
|
||||
you would use a real value instead.
|
||||
|
||||
bool *INPUT, bool &INPUT
|
||||
signed char *INPUT, signed char &INPUT
|
||||
unsigned char *INPUT, unsigned char &INPUT
|
||||
short *INPUT, short &INPUT
|
||||
unsigned short *INPUT, unsigned short &INPUT
|
||||
int *INPUT, int &INPUT
|
||||
unsigned int *INPUT, unsigned int &INPUT
|
||||
long *INPUT, long &INPUT
|
||||
unsigned long *INPUT, unsigned long &INPUT
|
||||
long long *INPUT, long long &INPUT
|
||||
unsigned long long *INPUT, unsigned long long &INPUT
|
||||
float *INPUT, float &INPUT
|
||||
double *INPUT, double &INPUT
|
||||
|
||||
To use these, suppose you had a C function like this :
|
||||
|
||||
double fadd(double *a, double *b) {
|
||||
return *a+*b;
|
||||
}
|
||||
|
||||
You could wrap it with SWIG as follows :
|
||||
|
||||
%include <typemaps.i>
|
||||
double fadd(double *INPUT, double *INPUT);
|
||||
|
||||
or you can use the %apply directive :
|
||||
|
||||
%include <typemaps.i>
|
||||
%apply double *INPUT { double *a, double *b };
|
||||
double fadd(double *a, double *b);
|
||||
|
||||
In Java you could then use it like this:
|
||||
double answer = modulename.fadd(10.0, 20.0);
|
||||
|
||||
There are no char *INPUT typemaps, however you can apply the signed char * typemaps instead:
|
||||
%include <typemaps.i>
|
||||
%apply signed char *INPUT {char *input};
|
||||
void f(char *input);
|
||||
*/
|
||||
|
||||
%define INPUT_TYPEMAP(TYPE, JNITYPE, JTYPE, JNIDESC)
|
||||
%typemap(jni) TYPE *INPUT, TYPE &INPUT "JNITYPE"
|
||||
%typemap(jtype) TYPE *INPUT, TYPE &INPUT "JTYPE"
|
||||
%typemap(jstype) TYPE *INPUT, TYPE &INPUT "JTYPE"
|
||||
%typemap(javain) TYPE *INPUT, TYPE &INPUT "$javainput"
|
||||
%typemap(javadirectorin) TYPE *INPUT, TYPE &INPUT "$jniinput"
|
||||
%typemap(javadirectorout) TYPE *INPUT, TYPE &INPUT "$javacall"
|
||||
|
||||
%typemap(in) TYPE *INPUT, TYPE &INPUT
|
||||
%{ $1 = ($1_ltype)&$input; %}
|
||||
|
||||
%typemap(freearg) TYPE *INPUT, TYPE &INPUT ""
|
||||
|
||||
%typemap(directorout) TYPE *INPUT, TYPE &INPUT
|
||||
%{ $result = ($1_ltype)&$input; %}
|
||||
|
||||
%typemap(directorin,descriptor=JNIDESC) TYPE &INPUT
|
||||
%{ *(($&1_ltype) $input) = (JNITYPE *) &$1; %}
|
||||
|
||||
%typemap(directorin,descriptor=JNIDESC) TYPE *INPUT
|
||||
%{ *(($&1_ltype) $input) = (JNITYPE *) $1; %}
|
||||
|
||||
%typemap(typecheck) TYPE *INPUT = TYPE;
|
||||
%typemap(typecheck) TYPE &INPUT = TYPE;
|
||||
%enddef
|
||||
|
||||
INPUT_TYPEMAP(bool, jboolean, boolean, "Z");
|
||||
INPUT_TYPEMAP(signed char, jbyte, byte, "B");
|
||||
INPUT_TYPEMAP(unsigned char, jshort, short, "S");
|
||||
INPUT_TYPEMAP(short, jshort, short, "S");
|
||||
INPUT_TYPEMAP(unsigned short, jint, int, "I");
|
||||
INPUT_TYPEMAP(int, jint, int, "I");
|
||||
INPUT_TYPEMAP(unsigned int, jlong, long, "J");
|
||||
INPUT_TYPEMAP(long, jint, int, "I");
|
||||
INPUT_TYPEMAP(unsigned long, jlong, long, "J");
|
||||
INPUT_TYPEMAP(long long, jlong, long, "J");
|
||||
INPUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, "Ljava/math/BigInteger;");
|
||||
INPUT_TYPEMAP(float, jfloat, float, "F");
|
||||
INPUT_TYPEMAP(double, jdouble, double, "D");
|
||||
|
||||
#undef INPUT_TYPEMAP
|
||||
|
||||
/* Convert from BigInteger using the toByteArray member function */
|
||||
/* Overrides the typemap in the INPUT_TYPEMAP macro */
|
||||
%typemap(in) unsigned long long *INPUT($*1_ltype temp), unsigned long long &INPUT($*1_ltype temp) {
|
||||
jclass clazz;
|
||||
jmethodID mid;
|
||||
jbyteArray ba;
|
||||
jbyte* bae;
|
||||
jsize sz;
|
||||
int i;
|
||||
|
||||
if (!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
|
||||
return $null;
|
||||
}
|
||||
clazz = JCALL1(GetObjectClass, jenv, $input);
|
||||
mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
|
||||
ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, $input, mid);
|
||||
bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
|
||||
sz = JCALL1(GetArrayLength, jenv, ba);
|
||||
temp = 0;
|
||||
for(i=0; i<sz; i++) {
|
||||
temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
|
||||
}
|
||||
JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
|
||||
$1 = &temp;
|
||||
}
|
||||
|
||||
// OUTPUT typemaps. These typemaps are used for parameters that
|
||||
// are output only. An array replaces the c pointer or reference parameter.
|
||||
// The output value is returned in this array passed in.
|
||||
|
||||
/*
|
||||
OUTPUT typemaps
|
||||
---------------
|
||||
|
||||
The following typemaps can be applied to turn a pointer or reference into an "output"
|
||||
value. When calling a function, no input value would be given for
|
||||
a parameter, but an output value would be returned. This works by a
|
||||
Java array being passed as a parameter where a c pointer or reference is required.
|
||||
As with any Java function, the array is passed by reference so that
|
||||
any modifications to the array will be picked up in the calling function.
|
||||
Note that the array passed in MUST have at least one element, but as the
|
||||
c function does not require any input, the value can be set to anything.
|
||||
|
||||
bool *OUTPUT, bool &OUTPUT
|
||||
signed char *OUTPUT, signed char &OUTPUT
|
||||
unsigned char *OUTPUT, unsigned char &OUTPUT
|
||||
short *OUTPUT, short &OUTPUT
|
||||
unsigned short *OUTPUT, unsigned short &OUTPUT
|
||||
int *OUTPUT, int &OUTPUT
|
||||
unsigned int *OUTPUT, unsigned int &OUTPUT
|
||||
long *OUTPUT, long &OUTPUT
|
||||
unsigned long *OUTPUT, unsigned long &OUTPUT
|
||||
long long *OUTPUT, long long &OUTPUT
|
||||
unsigned long long *OUTPUT, unsigned long long &OUTPUT
|
||||
float *OUTPUT, float &OUTPUT
|
||||
double *OUTPUT, double &OUTPUT
|
||||
|
||||
For example, suppose you were trying to wrap the modf() function in the
|
||||
C math library which splits x into integral and fractional parts (and
|
||||
returns the integer part in one of its parameters):
|
||||
|
||||
double modf(double x, double *ip);
|
||||
|
||||
You could wrap it with SWIG as follows :
|
||||
|
||||
%include <typemaps.i>
|
||||
double modf(double x, double *OUTPUT);
|
||||
|
||||
or you can use the %apply directive :
|
||||
|
||||
%include <typemaps.i>
|
||||
%apply double *OUTPUT { double *ip };
|
||||
double modf(double x, double *ip);
|
||||
|
||||
The Java output of the function would be the function return value and the
|
||||
value in the single element array. In Java you would use it like this:
|
||||
|
||||
double[] ptr = {0.0};
|
||||
double fraction = modulename.modf(5.0,ptr);
|
||||
|
||||
There are no char *OUTPUT typemaps, however you can apply the signed char * typemaps instead:
|
||||
%include <typemaps.i>
|
||||
%apply signed char *OUTPUT {char *output};
|
||||
void f(char *output);
|
||||
*/
|
||||
|
||||
/* Java BigInteger[] */
|
||||
%typecheck(SWIG_TYPECHECK_INT128_ARRAY) SWIGBIGINTEGERARRAY ""
|
||||
|
||||
%define OUTPUT_TYPEMAP(TYPE, JNITYPE, JTYPE, JAVATYPE, JNIDESC, TYPECHECKTYPE)
|
||||
%typemap(jni) TYPE *OUTPUT, TYPE &OUTPUT %{JNITYPE##Array%}
|
||||
%typemap(jtype) TYPE *OUTPUT, TYPE &OUTPUT "JTYPE[]"
|
||||
%typemap(jstype) TYPE *OUTPUT, TYPE &OUTPUT "JTYPE[]"
|
||||
%typemap(javain) TYPE *OUTPUT, TYPE &OUTPUT "$javainput"
|
||||
%typemap(javadirectorin) TYPE *OUTPUT, TYPE &OUTPUT "$jniinput"
|
||||
%typemap(javadirectorout) TYPE *OUTPUT, TYPE &OUTPUT "$javacall"
|
||||
|
||||
%typemap(in) TYPE *OUTPUT($*1_ltype temp), TYPE &OUTPUT($*1_ltype temp)
|
||||
{
|
||||
if (!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
|
||||
return $null;
|
||||
}
|
||||
if (JCALL1(GetArrayLength, jenv, $input) == 0) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
|
||||
return $null;
|
||||
}
|
||||
$1 = &temp;
|
||||
}
|
||||
|
||||
%typemap(freearg) TYPE *OUTPUT, TYPE &OUTPUT ""
|
||||
|
||||
%typemap(argout) TYPE *OUTPUT, TYPE &OUTPUT
|
||||
{
|
||||
JNITYPE jvalue = (JNITYPE)temp$argnum;
|
||||
JCALL4(Set##JAVATYPE##ArrayRegion, jenv, $input, 0, 1, &jvalue);
|
||||
}
|
||||
|
||||
%typemap(directorout,warning="Need to provide TYPE *OUTPUT directorout typemap") TYPE *OUTPUT, TYPE &OUTPUT {
|
||||
}
|
||||
|
||||
%typemap(directorin,descriptor=JNIDESC) TYPE &OUTPUT
|
||||
%{ *(($&1_ltype) $input = &$1; %}
|
||||
|
||||
%typemap(directorin,descriptor=JNIDESC,warning="Need to provide TYPE *OUTPUT directorin typemap, TYPE array length is unknown") TYPE *OUTPUT
|
||||
{
|
||||
}
|
||||
|
||||
%typemap(typecheck) TYPE *INOUT = TYPECHECKTYPE;
|
||||
%typemap(typecheck) TYPE &INOUT = TYPECHECKTYPE;
|
||||
%enddef
|
||||
|
||||
OUTPUT_TYPEMAP(bool, jboolean, boolean, Boolean, "[Ljava/lang/Boolean;", jbooleanArray);
|
||||
OUTPUT_TYPEMAP(signed char, jbyte, byte, Byte, "[Ljava/lang/Byte;", jbyteArray);
|
||||
OUTPUT_TYPEMAP(unsigned char, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);
|
||||
OUTPUT_TYPEMAP(short, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);
|
||||
OUTPUT_TYPEMAP(unsigned short, jint, int, Int, "[Ljava/lang/Integer;", jintArray);
|
||||
OUTPUT_TYPEMAP(int, jint, int, Int, "[Ljava/lang/Integer;", jintArray);
|
||||
OUTPUT_TYPEMAP(unsigned int, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);
|
||||
OUTPUT_TYPEMAP(long, jint, int, Int, "[Ljava/lang/Integer;", jintArray);
|
||||
OUTPUT_TYPEMAP(unsigned long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);
|
||||
OUTPUT_TYPEMAP(long long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);
|
||||
OUTPUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, NOTUSED, "[Ljava/lang/BigInteger;", SWIGBIGINTEGERARRAY);
|
||||
OUTPUT_TYPEMAP(float, jfloat, float, Float, "[Ljava/lang/Float;", jfloatArray);
|
||||
OUTPUT_TYPEMAP(double, jdouble, double, Double, "[Ljava/lang/Double;", jdoubleArray);
|
||||
|
||||
#undef OUTPUT_TYPEMAP
|
||||
|
||||
/* Convert to BigInteger - byte array holds number in 2's complement big endian format */
|
||||
/* Use first element in BigInteger array for output */
|
||||
/* Overrides the typemap in the OUTPUT_TYPEMAP macro */
|
||||
%typemap(argout) unsigned long long *OUTPUT, unsigned long long &OUTPUT {
|
||||
jbyteArray ba = JCALL1(NewByteArray, jenv, 9);
|
||||
jbyte* bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
|
||||
jclass clazz = JCALL1(FindClass, jenv, "java/math/BigInteger");
|
||||
jmethodID mid = JCALL3(GetMethodID, jenv, clazz, "<init>", "([B)V");
|
||||
jobject bigint;
|
||||
int i;
|
||||
|
||||
bae[0] = 0;
|
||||
for(i=1; i<9; i++ ) {
|
||||
bae[i] = (jbyte)(temp$argnum>>8*(8-i));
|
||||
}
|
||||
|
||||
JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
|
||||
bigint = JCALL3(NewObject, jenv, clazz, mid, ba);
|
||||
JCALL3(SetObjectArrayElement, jenv, $input, 0, bigint);
|
||||
}
|
||||
|
||||
/*
|
||||
INOUT typemaps
|
||||
--------------
|
||||
|
||||
Mappings for a parameter that is both an input and an output parameter
|
||||
|
||||
The following typemaps can be applied to make a function parameter both
|
||||
an input and output value. This combines the behavior of both the
|
||||
"INPUT" and "OUTPUT" typemaps described earlier. Output values are
|
||||
returned as an element in a Java array.
|
||||
|
||||
bool *INOUT, bool &INOUT
|
||||
signed char *INOUT, signed char &INOUT
|
||||
unsigned char *INOUT, unsigned char &INOUT
|
||||
short *INOUT, short &INOUT
|
||||
unsigned short *INOUT, unsigned short &INOUT
|
||||
int *INOUT, int &INOUT
|
||||
unsigned int *INOUT, unsigned int &INOUT
|
||||
long *INOUT, long &INOUT
|
||||
unsigned long *INOUT, unsigned long &INOUT
|
||||
long long *INOUT, long long &INOUT
|
||||
unsigned long long *INOUT, unsigned long long &INOUT
|
||||
float *INOUT, float &INOUT
|
||||
double *INOUT, double &INOUT
|
||||
|
||||
For example, suppose you were trying to wrap the following function :
|
||||
|
||||
void neg(double *x) {
|
||||
*x = -(*x);
|
||||
}
|
||||
|
||||
You could wrap it with SWIG as follows :
|
||||
|
||||
%include <typemaps.i>
|
||||
void neg(double *INOUT);
|
||||
|
||||
or you can use the %apply directive :
|
||||
|
||||
%include <typemaps.i>
|
||||
%apply double *INOUT { double *x };
|
||||
void neg(double *x);
|
||||
|
||||
This works similarly to C in that the mapping directly modifies the
|
||||
input value - the input must be an array with a minimum of one element.
|
||||
The element in the array is the input and the output is the element in
|
||||
the array.
|
||||
|
||||
double x[] = {5.0};
|
||||
neg(x);
|
||||
|
||||
The implementation of the OUTPUT and INOUT typemaps is different to other
|
||||
languages in that other languages will return the output value as part
|
||||
of the function return value. This difference is due to Java being a typed language.
|
||||
|
||||
There are no char *INOUT typemaps, however you can apply the signed char * typemaps instead:
|
||||
%include <typemaps.i>
|
||||
%apply signed char *INOUT {char *inout};
|
||||
void f(char *inout);
|
||||
*/
|
||||
|
||||
%define INOUT_TYPEMAP(TYPE, JNITYPE, JTYPE, JAVATYPE, JNIDESC, TYPECHECKTYPE)
|
||||
%typemap(jni) TYPE *INOUT, TYPE &INOUT %{JNITYPE##Array%}
|
||||
%typemap(jtype) TYPE *INOUT, TYPE &INOUT "JTYPE[]"
|
||||
%typemap(jstype) TYPE *INOUT, TYPE &INOUT "JTYPE[]"
|
||||
%typemap(javain) TYPE *INOUT, TYPE &INOUT "$javainput"
|
||||
%typemap(javadirectorin) TYPE *INOUT, TYPE &INOUT "$jniinput"
|
||||
%typemap(javadirectorout) TYPE *INOUT, TYPE &INOUT "$javacall"
|
||||
|
||||
%typemap(in) TYPE *INOUT, TYPE &INOUT {
|
||||
if (!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
|
||||
return $null;
|
||||
}
|
||||
if (JCALL1(GetArrayLength, jenv, $input) == 0) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
|
||||
return $null;
|
||||
}
|
||||
$1 = ($1_ltype) JCALL2(Get##JAVATYPE##ArrayElements, jenv, $input, 0);
|
||||
}
|
||||
|
||||
%typemap(freearg) TYPE *INOUT, TYPE &INOUT ""
|
||||
|
||||
%typemap(argout) TYPE *INOUT, TYPE &INOUT
|
||||
{ JCALL3(Release##JAVATYPE##ArrayElements, jenv, $input, (JNITYPE *)$1, 0); }
|
||||
|
||||
%typemap(directorout,warning="Need to provide TYPE *INOUT directorout typemap") TYPE *INOUT, TYPE &INOUT {
|
||||
}
|
||||
|
||||
%typemap(directorin,descriptor=JNIDESC) TYPE &INOUT
|
||||
%{ *(($&1_ltype)&$input) = &$1; %}
|
||||
|
||||
%typemap(directorin,descriptor=JNIDESC,warning="Need to provide TYPE *INOUT directorin typemap, TYPE array length is unknown") TYPE *INOUT, TYPE &INOUT
|
||||
{
|
||||
}
|
||||
|
||||
%typemap(typecheck) TYPE *INOUT = TYPECHECKTYPE;
|
||||
%typemap(typecheck) TYPE &INOUT = TYPECHECKTYPE;
|
||||
%enddef
|
||||
|
||||
INOUT_TYPEMAP(bool, jboolean, boolean, Boolean, "[Ljava/lang/Boolean;", jbooleanArray);
|
||||
INOUT_TYPEMAP(signed char, jbyte, byte, Byte, "[Ljava/lang/Byte;", jbyteArray);
|
||||
INOUT_TYPEMAP(unsigned char, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);
|
||||
INOUT_TYPEMAP(short, jshort, short, Short, "[Ljava/lang/Short;", jshortArray);
|
||||
INOUT_TYPEMAP(unsigned short, jint, int, Int, "[Ljava/lang/Integer;", jintArray);
|
||||
INOUT_TYPEMAP(int, jint, int, Int, "[Ljava/lang/Integer;", jintArray);
|
||||
INOUT_TYPEMAP(unsigned int, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);
|
||||
INOUT_TYPEMAP(long, jint, int, Int, "[Ljava/lang/Integer;", jintArray);
|
||||
INOUT_TYPEMAP(unsigned long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);
|
||||
INOUT_TYPEMAP(long long, jlong, long, Long, "[Ljava/lang/Long;", jlongArray);
|
||||
INOUT_TYPEMAP(unsigned long long, jobject, java.math.BigInteger, NOTUSED, "[Ljava.math.BigInteger;", SWIGBIGINTEGERARRAY);
|
||||
INOUT_TYPEMAP(float, jfloat, float, Float, "[Ljava/lang/Float;", jfloatArray);
|
||||
INOUT_TYPEMAP(double, jdouble, double, Double, "[Ljava/lang/Double;", jdoubleArray);
|
||||
|
||||
#undef INOUT_TYPEMAP
|
||||
|
||||
/* Override typemaps in the INOUT_TYPEMAP macro for booleans to fix casts
|
||||
as a jboolean isn't always the same size as a bool */
|
||||
%typemap(in) bool *INOUT (bool btemp, jboolean *jbtemp), bool &INOUT (bool btemp, jboolean *jbtemp) {
|
||||
if (!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
|
||||
return $null;
|
||||
}
|
||||
if (JCALL1(GetArrayLength, jenv, $input) == 0) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
|
||||
return $null;
|
||||
}
|
||||
jbtemp = JCALL2(GetBooleanArrayElements, jenv, $input, 0);
|
||||
btemp = (*jbtemp) ? true : false;
|
||||
$1 = &btemp;
|
||||
}
|
||||
|
||||
%typemap(argout) bool *INOUT, bool &INOUT {
|
||||
*jbtemp$argnum = btemp$argnum ? (jboolean)1 : (jboolean)0;
|
||||
JCALL3(ReleaseBooleanArrayElements, jenv, $input , (jboolean *)jbtemp$argnum, 0);
|
||||
}
|
||||
|
||||
/* Override the typemap in the INOUT_TYPEMAP macro for unsigned long long */
|
||||
%typemap(in) unsigned long long *INOUT ($*1_ltype temp), unsigned long long &INOUT ($*1_ltype temp) {
|
||||
jobject bigint;
|
||||
jclass clazz;
|
||||
jmethodID mid;
|
||||
jbyteArray ba;
|
||||
jbyte* bae;
|
||||
jsize sz;
|
||||
int i;
|
||||
|
||||
if (!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
|
||||
return $null;
|
||||
}
|
||||
if (JCALL1(GetArrayLength, jenv, $input) == 0) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
|
||||
return $null;
|
||||
}
|
||||
bigint = JCALL2(GetObjectArrayElement, jenv, $input, 0);
|
||||
if (!bigint) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array element null");
|
||||
return $null;
|
||||
}
|
||||
clazz = JCALL1(GetObjectClass, jenv, bigint);
|
||||
mid = JCALL3(GetMethodID, jenv, clazz, "toByteArray", "()[B");
|
||||
ba = (jbyteArray)JCALL2(CallObjectMethod, jenv, bigint, mid);
|
||||
bae = JCALL2(GetByteArrayElements, jenv, ba, 0);
|
||||
sz = JCALL1(GetArrayLength, jenv, ba);
|
||||
temp = 0;
|
||||
for(i=0; i<sz; i++) {
|
||||
temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
|
||||
}
|
||||
JCALL3(ReleaseByteArrayElements, jenv, ba, bae, 0);
|
||||
$1 = &temp;
|
||||
}
|
||||
|
||||
%typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT;
|
||||
%typemap(argout) unsigned long long &INOUT = unsigned long long &OUTPUT;
|
||||
@@ -0,0 +1,151 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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.
|
||||
*
|
||||
* various.i
|
||||
*
|
||||
* SWIG Typemap library for Java.
|
||||
* Various useful typemaps.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
/*
|
||||
* char **STRING_ARRAY typemaps.
|
||||
* These typemaps are for C String arrays which are NULL terminated.
|
||||
* char *values[] = { "one", "two", "three", NULL }; // note NULL
|
||||
* char ** is mapped to a Java String[].
|
||||
*
|
||||
* Example usage wrapping:
|
||||
* %apply char **STRING_ARRAY { char **input };
|
||||
* char ** foo(char **input);
|
||||
*
|
||||
* Java usage:
|
||||
* String numbers[] = { "one", "two", "three" };
|
||||
* String[] ret = modulename.foo( numbers };
|
||||
*/
|
||||
%typemap(jni) char **STRING_ARRAY "jobjectArray"
|
||||
%typemap(jtype) char **STRING_ARRAY "String[]"
|
||||
%typemap(jstype) char **STRING_ARRAY "String[]"
|
||||
%typemap(in) char **STRING_ARRAY (jint size) {
|
||||
int i = 0;
|
||||
size = JCALL1(GetArrayLength, jenv, $input);
|
||||
#ifdef __cplusplus
|
||||
$1 = new char*[size+1];
|
||||
#else
|
||||
$1 = (char **)calloc(size+1, sizeof(char *));
|
||||
#endif
|
||||
for (i = 0; i<size; i++) {
|
||||
jstring j_string = (jstring)JCALL2(GetObjectArrayElement, jenv, $input, i);
|
||||
const char *c_string = JCALL2(GetStringUTFChars, jenv, j_string, 0);
|
||||
#ifdef __cplusplus
|
||||
$1[i] = new char [strlen(c_string)+1];
|
||||
#else
|
||||
$1[i] = (char *)calloc(strlen(c_string)+1, sizeof(const char *));
|
||||
#endif
|
||||
strcpy($1[i], c_string);
|
||||
JCALL2(ReleaseStringUTFChars, jenv, j_string, c_string);
|
||||
JCALL1(DeleteLocalRef, jenv, j_string);
|
||||
}
|
||||
$1[i] = 0;
|
||||
}
|
||||
|
||||
%typemap(freearg) char **STRING_ARRAY {
|
||||
int i;
|
||||
for (i=0; i<size$argnum-1; i++)
|
||||
#ifdef __cplusplus
|
||||
delete[] $1[i];
|
||||
delete[] $1;
|
||||
#else
|
||||
free($1[i]);
|
||||
free($1);
|
||||
#endif
|
||||
}
|
||||
|
||||
%typemap(out) char **STRING_ARRAY (char *s) {
|
||||
int i;
|
||||
int len=0;
|
||||
jstring temp_string;
|
||||
const jclass clazz = JCALL1(FindClass, jenv, "java/lang/String");
|
||||
|
||||
while ($1[len]) len++;
|
||||
jresult = JCALL3(NewObjectArray, jenv, len, clazz, NULL);
|
||||
/* exception checking omitted */
|
||||
|
||||
for (i=0; i<len; i++) {
|
||||
temp_string = JCALL1(NewStringUTF, jenv, *result++);
|
||||
JCALL3(SetObjectArrayElement, jenv, jresult, i, temp_string);
|
||||
JCALL1(DeleteLocalRef, jenv, temp_string);
|
||||
}
|
||||
}
|
||||
|
||||
%typemap(javain) char **STRING_ARRAY "$javainput"
|
||||
%typemap(javaout) char **STRING_ARRAY {
|
||||
return $jnicall;
|
||||
}
|
||||
|
||||
/*
|
||||
* char **STRING_OUT typemaps.
|
||||
* These are typemaps for returning strings when using a C char ** parameter type.
|
||||
* The returned string appears in the 1st element of the passed in Java String array.
|
||||
*
|
||||
* Example usage wrapping:
|
||||
* void foo(char **string_out);
|
||||
*
|
||||
* Java usage:
|
||||
* String stringOutArray[] = { "" };
|
||||
* modulename.foo(stringOutArray);
|
||||
* System.out.println( stringOutArray[0] );
|
||||
*/
|
||||
%typemap(jni) char **STRING_OUT "jobjectArray"
|
||||
%typemap(jtype) char **STRING_OUT "String[]"
|
||||
%typemap(jstype) char **STRING_OUT "String[]"
|
||||
%typemap(javain) char **STRING_OUT "$javainput"
|
||||
|
||||
%typemap(in) char **STRING_OUT($*1_ltype temp) {
|
||||
if (!$input) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
|
||||
return $null;
|
||||
}
|
||||
if (JCALL1(GetArrayLength, jenv, $input) == 0) {
|
||||
SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
|
||||
return $null;
|
||||
}
|
||||
$1 = &temp;
|
||||
}
|
||||
|
||||
%typemap(argout) char **STRING_OUT {
|
||||
jstring jnewstring = NULL;
|
||||
if($1) {
|
||||
jnewstring = JCALL1(NewStringUTF, jenv, *$1);
|
||||
}
|
||||
JCALL3(SetObjectArrayElement, jenv, $input, 0, jnewstring);
|
||||
}
|
||||
|
||||
/*
|
||||
* char *BYTE typemaps.
|
||||
* These are input typemaps for mapping a Java byte[] array to a C char array.
|
||||
* Note that as a Java array is used and thus passeed by reference, the C routine
|
||||
* can return data to Java via the parameter.
|
||||
*
|
||||
* Example usage wrapping:
|
||||
* void foo(char *array);
|
||||
*
|
||||
* Java usage:
|
||||
* byte b[] = new byte[20];
|
||||
* modulename.foo(b);
|
||||
*/
|
||||
%typemap(jni) char *BYTE "jbyteArray"
|
||||
%typemap(jtype) char *BYTE "byte[]"
|
||||
%typemap(jstype) char *BYTE "byte[]"
|
||||
%typemap(in) char *BYTE {
|
||||
$1 = (char *) JCALL2(GetByteArrayElements, jenv, $input, 0);
|
||||
}
|
||||
|
||||
%typemap(argout) char *BYTE {
|
||||
JCALL3(ReleaseByteArrayElements, jenv, $input, (jbyte *) $1, 0);
|
||||
}
|
||||
|
||||
%typemap(javain) char *BYTE "$javainput"
|
||||
|
||||
/* Prevent default freearg typemap from being used */
|
||||
%typemap(freearg) char *BYTE ""
|
||||
|
||||
Reference in New Issue
Block a user