You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
392 lines
13 KiB
392 lines
13 KiB
5 years ago
|
/* -----------------------------------------------------------------------------
|
||
|
|
* 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
|
||
|
|
|