2 * Licensed under the Apache License, Version 2.0 (the "License");
3 * you may not use this file except in compliance with the License.
4 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
8 * Unless required by applicable law or agreed to in writing, software
9 * distributed under the License is distributed on an "AS IS" BASIS,
10 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 * See the License for the specific language governing permissions and
12 * limitations under the License.
22 extern jobjectArray fromPySequence(jclass cls, PyObject *sequence);
23 extern PyObject *PyErr_SetJavaError();
25 extern PyTypeObject *PY_TYPE(JArrayObject);
26 extern PyTypeObject *PY_TYPE(JArrayString);
27 extern PyTypeObject *PY_TYPE(JArrayBool);
28 extern PyTypeObject *PY_TYPE(JArrayByte);
29 extern PyTypeObject *PY_TYPE(JArrayChar);
30 extern PyTypeObject *PY_TYPE(JArrayDouble);
31 extern PyTypeObject *PY_TYPE(JArrayFloat);
32 extern PyTypeObject *PY_TYPE(JArrayInt);
33 extern PyTypeObject *PY_TYPE(JArrayLong);
34 extern PyTypeObject *PY_TYPE(JArrayShort);
39 #include "java/lang/Object.h"
42 template<typename T> class JArray : public java::lang::Object {
46 explicit JArray<T>(jobject obj) : java::lang::Object(obj) {
47 length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
49 JArray<T>(const JArray<T>& obj) : java::lang::Object(obj) {
54 JArray<T>(PyObject *sequence) : java::lang::Object(fromPySequence(T::initializeClass(), sequence)) {
55 length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
58 JArray<T>(jclass cls, PyObject *sequence) : java::lang::Object(fromPySequence(cls, sequence)) {
59 length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
62 PyObject *toSequence(PyObject *(*wrapfn)(const T&))
67 PyObject *list = PyList_New(length);
69 for (Py_ssize_t i = 0; i < length; i++)
70 PyList_SET_ITEM(list, i, (*wrapfn)((*this)[i]));
75 PyObject *get(Py_ssize_t n, PyObject *(*wrapfn)(const T&))
82 if (n >= 0 && n < length)
83 return (*wrapfn)((*this)[n]);
86 PyErr_SetString(PyExc_IndexError, "index out of range");
91 T operator[](Py_ssize_t n) {
92 return T(env->getObjectArrayElement((jobjectArray) this$, n));
96 template<> class JArray<jobject> : public java::lang::Object {
100 JArray<jobject>(jclass cls, Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewObjectArray(n, cls, NULL)) {
101 length = env->getArrayLength((jobjectArray) this$);
104 JArray<jobject>(jobject obj) : java::lang::Object(obj) {
105 length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
108 JArray<jobject>(const JArray& obj) : java::lang::Object(obj) {
113 JArray<jobject>(jclass cls, PyObject *sequence) : java::lang::Object(fromPySequence(cls, sequence)) {
114 length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
117 PyObject *toSequence(PyObject *(*wrapfn)(const jobject&))
119 return toSequence(0, length, wrapfn);
122 PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi,
123 PyObject *(*wrapfn)(const jobject&))
128 if (lo < 0) lo = length + lo;
130 else if (lo > length) lo = length;
131 if (hi < 0) hi = length + hi;
133 else if (hi > length) hi = length;
134 if (lo > hi) lo = hi;
136 PyObject *list = PyList_New(hi - lo);
139 wrapfn = java::lang::t_Object::wrap_jobject;
141 for (Py_ssize_t i = lo; i < hi; i++) {
142 jobject jobj = env->getObjectArrayElement((jobjectArray) this$, i);
143 PyObject *obj = (*wrapfn)(jobj);
145 PyList_SET_ITEM(list, i - lo, obj);
151 PyObject *get(Py_ssize_t n, PyObject *(*wrapfn)(const jobject&))
158 if (n >= 0 && n < length)
161 wrapfn = java::lang::t_Object::wrap_jobject;
164 env->getObjectArrayElement((jobjectArray) this$, n);
166 return (*wrapfn)(jobj);
170 PyErr_SetString(PyExc_IndexError, "index out of range");
174 int set(Py_ssize_t n, PyObject *obj)
181 if (n >= 0 && n < length)
183 if (!PyObject_TypeCheck(obj, &PY_TYPE(JObject)))
185 PyErr_SetObject(PyExc_TypeError, obj);
189 jobject jobj = ((t_JObject *) obj)->object.this$;
192 env->setObjectArrayElement((jobjectArray) this$, n, jobj);
196 PyErr_SetJavaError();
207 PyErr_SetString(PyExc_IndexError, "index out of range");
211 PyObject *wrap(PyObject *(*wrapfn)(const jobject&));
214 jobject operator[](Py_ssize_t n) {
215 return (jobject) env->getObjectArrayElement((jobjectArray) this$, n);
219 template<> class JArray<jstring> : public java::lang::Object {
223 JArray<jstring>(jobject obj) : java::lang::Object(obj) {
224 length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
227 JArray<jstring>(const JArray& obj) : java::lang::Object(obj) {
231 JArray<jstring>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewObjectArray(n, env->findClass("java/lang/String"), NULL)) {
232 length = env->getArrayLength((jobjectArray) this$);
236 JArray<jstring>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewObjectArray(PySequence_Length(sequence), env->findClass("java/lang/String"), NULL)) {
237 length = env->getArrayLength((jobjectArray) this$);
239 for (Py_ssize_t i = 0; i < length; i++) {
240 PyObject *obj = PySequence_GetItem(sequence, i);
245 jstring str = env->fromPyString(obj);
248 if (PyErr_Occurred())
251 env->setObjectArrayElement((jobjectArray) this$, i, str);
252 env->get_vm_env()->DeleteLocalRef(str);
256 PyObject *toSequence()
258 return toSequence(0, length);
261 PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
266 if (lo < 0) lo = length + lo;
268 else if (lo > length) lo = length;
269 if (hi < 0) hi = length + hi;
271 else if (hi > length) hi = length;
272 if (lo > hi) lo = hi;
274 PyObject *list = PyList_New(hi - lo);
276 for (Py_ssize_t i = lo; i < hi; i++) {
277 jstring str = (jstring)
278 env->getObjectArrayElement((jobjectArray) this$, i);
279 PyObject *obj = env->fromJString(str, 1);
281 PyList_SET_ITEM(list, i - lo, obj);
287 PyObject *get(Py_ssize_t n)
294 if (n >= 0 && n < length)
296 jstring str = (jstring)
297 env->getObjectArrayElement((jobjectArray) this$, n);
298 PyObject *obj = env->fromJString(str, 1);
304 PyErr_SetString(PyExc_IndexError, "index out of range");
308 int set(Py_ssize_t n, PyObject *obj)
315 if (n >= 0 && n < length)
317 jstring str = env->fromPyString(obj);
319 if (PyErr_Occurred())
322 env->setObjectArrayElement((jobjectArray) this$, n, str);
327 PyErr_SetString(PyExc_IndexError, "index out of range");
331 PyObject *wrap() const;
334 jstring operator[](Py_ssize_t n) {
335 return (jstring) env->getObjectArrayElement((jobjectArray) this$, n);
339 template<> class JArray<jboolean> : public java::lang::Object {
343 class arrayElements {
349 arrayElements(jbooleanArray array) {
351 elts = env->get_vm_env()->GetBooleanArrayElements(array, &isCopy);
353 virtual ~arrayElements() {
354 env->get_vm_env()->ReleaseBooleanArrayElements(array, elts, 0);
356 operator jboolean *() {
361 arrayElements elements() {
362 return arrayElements((jbooleanArray) this$);
365 JArray<jboolean>(jobject obj) : java::lang::Object(obj) {
366 length = this$ ? env->getArrayLength((jarray) this$) : 0;
369 JArray<jboolean>(const JArray& obj) : java::lang::Object(obj) {
373 JArray<jboolean>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewBooleanArray(n)) {
374 length = env->getArrayLength((jarray) this$);
378 JArray<jboolean>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewBooleanArray(PySequence_Length(sequence))) {
379 length = env->getArrayLength((jarray) this$);
380 arrayElements elts = elements();
381 jboolean *buf = (jboolean *) elts;
383 for (Py_ssize_t i = 0; i < length; i++) {
384 PyObject *obj = PySequence_GetItem(sequence, i);
389 if (obj == Py_True || obj == Py_False)
391 buf[i] = (jboolean) (obj == Py_True);
396 PyErr_SetObject(PyExc_TypeError, obj);
403 PyObject *toSequence()
405 return toSequence(0, length);
408 PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
413 if (lo < 0) lo = length + lo;
415 else if (lo > length) lo = length;
416 if (hi < 0) hi = length + hi;
418 else if (hi > length) hi = length;
419 if (lo > hi) lo = hi;
421 PyObject *list = PyList_New(hi - lo);
422 arrayElements elts = elements();
423 jboolean *buf = (jboolean *) elts;
425 for (Py_ssize_t i = lo; i < hi; i++) {
426 jboolean value = buf[i];
427 PyObject *obj = value ? Py_True : Py_False;
430 PyList_SET_ITEM(list, i - lo, obj);
436 PyObject *get(Py_ssize_t n)
443 if (n >= 0 && n < length)
444 Py_RETURN_BOOL(elements()[n]);
447 PyErr_SetString(PyExc_IndexError, "index out of range");
451 int set(Py_ssize_t n, PyObject *obj)
458 if (n >= 0 && n < length)
460 elements()[n] = (jboolean) PyObject_IsTrue(obj);
465 PyErr_SetString(PyExc_IndexError, "index out of range");
469 PyObject *wrap() const;
472 jboolean operator[](Py_ssize_t n) {
473 JNIEnv *vm_env = env->get_vm_env();
475 jboolean *elts = (jboolean *)
476 vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
477 jboolean value = elts[n];
479 vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
485 template<> class JArray<jbyte> : public java::lang::Object {
489 class arrayElements {
495 arrayElements(jbyteArray array) {
497 elts = env->get_vm_env()->GetByteArrayElements(array, &isCopy);
499 virtual ~arrayElements() {
500 env->get_vm_env()->ReleaseByteArrayElements(array, elts, 0);
507 arrayElements elements() {
508 return arrayElements((jbyteArray) this$);
511 JArray<jbyte>(jobject obj) : java::lang::Object(obj) {
512 length = this$ ? env->getArrayLength((jarray) this$) : 0;
515 JArray<jbyte>(const JArray& obj) : java::lang::Object(obj) {
519 JArray<jbyte>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewByteArray(n)) {
520 length = env->getArrayLength((jarray) this$);
524 JArray<jbyte>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewByteArray(PySequence_Length(sequence))) {
525 length = env->getArrayLength((jarray) this$);
526 arrayElements elts = elements();
527 jbyte *buf = (jbyte *) elts;
529 if (PyString_Check(sequence))
530 memcpy(buf, PyString_AS_STRING(sequence), length);
532 for (Py_ssize_t i = 0; i < length; i++) {
533 PyObject *obj = PySequence_GetItem(sequence, i);
538 if (PyString_Check(obj) && (PyString_GET_SIZE(obj) == 1))
540 buf[i] = (jbyte) PyString_AS_STRING(obj)[0];
543 else if (PyInt_CheckExact(obj))
545 buf[i] = (jbyte) PyInt_AS_LONG(obj);
550 PyErr_SetObject(PyExc_TypeError, obj);
562 PyObject *toSequence()
564 return toSequence(0, length);
567 PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
572 if (lo < 0) lo = length + lo;
574 else if (lo > length) lo = length;
575 if (hi < 0) hi = length + hi;
577 else if (hi > length) hi = length;
578 if (lo > hi) lo = hi;
580 arrayElements elts = elements();
581 jbyte *buf = (jbyte *) elts;
582 PyObject *tuple = PyTuple_New(hi - lo);
584 for (Py_ssize_t i = 0; i < hi - lo; i++)
585 PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(buf[lo + i]));
590 PyObject *to_string_()
595 arrayElements elts = elements();
596 jbyte *buf = (jbyte *) elts;
598 return PyString_FromStringAndSize((char *) buf, length);
601 PyObject *get(Py_ssize_t n)
608 if (n >= 0 && n < length)
610 jbyte b = (*this)[n];
611 return PyInt_FromLong(b);
615 PyErr_SetString(PyExc_IndexError, "index out of range");
619 int set(Py_ssize_t n, PyObject *obj)
626 if (n >= 0 && n < length)
628 if (!PyInt_CheckExact(obj))
630 PyErr_SetObject(PyExc_TypeError, obj);
634 elements()[n] = (jbyte) PyInt_AS_LONG(obj);
639 PyErr_SetString(PyExc_IndexError, "index out of range");
643 PyObject *wrap() const;
646 jbyte operator[](Py_ssize_t n) {
647 JNIEnv *vm_env = env->get_vm_env();
649 jbyte *elts = (jbyte *)
650 vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
651 jbyte value = elts[n];
653 vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
659 template<> class JArray<jchar> : public java::lang::Object {
663 class arrayElements {
669 arrayElements(jcharArray array) {
671 elts = env->get_vm_env()->GetCharArrayElements(array, &isCopy);
673 virtual ~arrayElements() {
674 env->get_vm_env()->ReleaseCharArrayElements(array, elts, 0);
681 arrayElements elements() {
682 return arrayElements((jcharArray) this$);
685 JArray<jchar>(jobject obj) : java::lang::Object(obj) {
686 length = this$ ? env->getArrayLength((jarray) this$) : 0;
689 JArray<jchar>(const JArray& obj) : java::lang::Object(obj) {
693 JArray<jchar>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewCharArray(n)) {
694 length = env->getArrayLength((jarray) this$);
698 JArray<jchar>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewCharArray(PySequence_Length(sequence))) {
699 length = env->getArrayLength((jarray) this$);
700 arrayElements elts = elements();
701 jchar *buf = (jchar *) elts;
703 if (PyUnicode_Check(sequence))
705 if (sizeof(Py_UNICODE) == sizeof(jchar))
706 memcpy(buf, PyUnicode_AS_UNICODE(sequence),
707 length * sizeof(jchar));
710 Py_UNICODE *pchars = PyUnicode_AS_UNICODE(sequence);
711 for (Py_ssize_t i = 0; i < length; i++)
712 buf[i] = (jchar) pchars[i];
716 for (Py_ssize_t i = 0; i < length; i++) {
717 PyObject *obj = PySequence_GetItem(sequence, i);
722 if (PyUnicode_Check(obj) && (PyUnicode_GET_SIZE(obj) == 1))
724 buf[i] = (jchar) PyUnicode_AS_UNICODE(obj)[0];
729 PyErr_SetObject(PyExc_TypeError, obj);
736 PyObject *toSequence()
738 return toSequence(0, length);
741 PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
746 if (lo < 0) lo = length + lo;
748 else if (lo > length) lo = length;
749 if (hi < 0) hi = length + hi;
751 else if (hi > length) hi = length;
752 if (lo > hi) lo = hi;
754 arrayElements elts = elements();
755 jchar *buf = (jchar *) elts;
757 if (sizeof(Py_UNICODE) == sizeof(jchar))
758 return PyUnicode_FromUnicode((const Py_UNICODE *) buf + lo,
762 PyObject *string = PyUnicode_FromUnicode(NULL, hi - lo);
763 Py_UNICODE *pchars = PyUnicode_AS_UNICODE(string);
765 for (Py_ssize_t i = lo; i < hi; i++)
766 pchars[i - lo] = (Py_UNICODE) buf[i];
772 PyObject *get(Py_ssize_t n)
779 if (n >= 0 && n < length)
781 jchar c = (*this)[n];
783 if (sizeof(Py_UNICODE) == sizeof(jchar))
784 return PyUnicode_FromUnicode((const Py_UNICODE *) &c, 1);
787 PyObject *string = PyUnicode_FromUnicode(NULL, 1);
788 Py_UNICODE *pchars = PyUnicode_AS_UNICODE(string);
790 pchars[0] = (Py_UNICODE) c;
797 PyErr_SetString(PyExc_IndexError, "index out of range");
801 int set(Py_ssize_t n, PyObject *obj)
808 if (n >= 0 && n < length)
810 if (!PyUnicode_Check(obj))
812 PyErr_SetObject(PyExc_TypeError, obj);
815 if (PyUnicode_GET_SIZE(obj) != 1)
817 PyErr_SetObject(PyExc_ValueError, obj);
821 elements()[n] = (jchar) PyUnicode_AS_UNICODE(obj)[0];
826 PyErr_SetString(PyExc_IndexError, "index out of range");
830 PyObject *wrap() const;
833 jchar operator[](Py_ssize_t n) {
834 JNIEnv *vm_env = env->get_vm_env();
836 jchar *elts = (jchar *)
837 vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
838 jchar value = elts[n];
840 vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
846 template<> class JArray<jdouble> : public java::lang::Object {
850 class arrayElements {
856 arrayElements(jdoubleArray array) {
858 elts = env->get_vm_env()->GetDoubleArrayElements(array, &isCopy);
860 virtual ~arrayElements() {
861 env->get_vm_env()->ReleaseDoubleArrayElements(array, elts, 0);
863 operator jdouble *() {
868 arrayElements elements() {
869 return arrayElements((jdoubleArray) this$);
872 JArray<jdouble>(jobject obj) : java::lang::Object(obj) {
873 length = this$ ? env->getArrayLength((jarray) this$) : 0;
876 JArray<jdouble>(const JArray& obj) : java::lang::Object(obj) {
880 JArray<jdouble>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewDoubleArray(n)) {
881 length = env->getArrayLength((jarray) this$);
885 JArray<jdouble>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewDoubleArray(PySequence_Length(sequence))) {
886 length = env->getArrayLength((jarray) this$);
887 arrayElements elts = elements();
888 jdouble *buf = (jdouble *) elts;
890 for (Py_ssize_t i = 0; i < length; i++) {
891 PyObject *obj = PySequence_GetItem(sequence, i);
896 if (PyFloat_Check(obj))
898 buf[i] = (jdouble) PyFloat_AS_DOUBLE(obj);
903 PyErr_SetObject(PyExc_TypeError, obj);
910 PyObject *toSequence()
912 return toSequence(0, length);
915 PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
920 if (lo < 0) lo = length + lo;
922 else if (lo > length) lo = length;
923 if (hi < 0) hi = length + hi;
925 else if (hi > length) hi = length;
926 if (lo > hi) lo = hi;
928 PyObject *list = PyList_New(hi - lo);
929 arrayElements elts = elements();
930 jdouble *buf = (jdouble *) elts;
932 for (Py_ssize_t i = lo; i < hi; i++)
933 PyList_SET_ITEM(list, i - lo, PyFloat_FromDouble((double) buf[i]));
938 PyObject *get(Py_ssize_t n)
945 if (n >= 0 && n < length)
946 return PyFloat_FromDouble((double) (*this)[n]);
949 PyErr_SetString(PyExc_IndexError, "index out of range");
953 int set(Py_ssize_t n, PyObject *obj)
960 if (n >= 0 && n < length)
962 if (!PyFloat_Check(obj))
964 PyErr_SetObject(PyExc_TypeError, obj);
968 elements()[n] = (jdouble) PyFloat_AS_DOUBLE(obj);
973 PyErr_SetString(PyExc_IndexError, "index out of range");
977 PyObject *wrap() const;
980 jdouble operator[](Py_ssize_t n) {
981 JNIEnv *vm_env = env->get_vm_env();
983 jdouble *elts = (jdouble *)
984 vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
985 jdouble value = elts[n];
987 vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
993 template<> class JArray<jfloat> : public java::lang::Object {
997 class arrayElements {
1003 arrayElements(jfloatArray array) {
1004 this->array = array;
1005 elts = env->get_vm_env()->GetFloatArrayElements(array, &isCopy);
1007 virtual ~arrayElements() {
1008 env->get_vm_env()->ReleaseFloatArrayElements(array, elts, 0);
1010 operator jfloat *() {
1015 arrayElements elements() {
1016 return arrayElements((jfloatArray) this$);
1019 JArray<jfloat>(jobject obj) : java::lang::Object(obj) {
1020 length = this$ ? env->getArrayLength((jarray) this$) : 0;
1023 JArray<jfloat>(const JArray& obj) : java::lang::Object(obj) {
1024 length = obj.length;
1027 JArray<jfloat>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewFloatArray(n)) {
1028 length = env->getArrayLength((jarray) this$);
1032 JArray<jfloat>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewFloatArray(PySequence_Length(sequence))) {
1033 length = env->getArrayLength((jarray) this$);
1034 arrayElements elts = elements();
1035 jfloat *buf = (jfloat *) elts;
1037 for (Py_ssize_t i = 0; i < length; i++) {
1038 PyObject *obj = PySequence_GetItem(sequence, i);
1043 if (PyFloat_Check(obj))
1045 buf[i] = (jfloat) PyFloat_AS_DOUBLE(obj);
1050 PyErr_SetObject(PyExc_TypeError, obj);
1057 PyObject *toSequence()
1059 return toSequence(0, length);
1062 PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
1067 if (lo < 0) lo = length + lo;
1069 else if (lo > length) lo = length;
1070 if (hi < 0) hi = length + hi;
1072 else if (hi > length) hi = length;
1073 if (lo > hi) lo = hi;
1075 PyObject *list = PyList_New(hi - lo);
1076 arrayElements elts = elements();
1077 jfloat *buf = (jfloat *) elts;
1079 for (Py_ssize_t i = lo; i < hi; i++)
1080 PyList_SET_ITEM(list, i - lo, PyFloat_FromDouble((double) buf[i]));
1085 PyObject *get(Py_ssize_t n)
1092 if (n >= 0 && n < length)
1093 return PyFloat_FromDouble((double) (*this)[n]);
1096 PyErr_SetString(PyExc_IndexError, "index out of range");
1100 int set(Py_ssize_t n, PyObject *obj)
1107 if (n >= 0 && n < length)
1109 if (!PyFloat_Check(obj))
1111 PyErr_SetObject(PyExc_TypeError, obj);
1115 elements()[n] = (jfloat) PyFloat_AS_DOUBLE(obj);
1120 PyErr_SetString(PyExc_IndexError, "index out of range");
1124 PyObject *wrap() const;
1127 jfloat operator[](Py_ssize_t n) {
1128 JNIEnv *vm_env = env->get_vm_env();
1129 jboolean isCopy = 0;
1130 jfloat *elts = (jfloat *)
1131 vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
1132 jfloat value = elts[n];
1134 vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
1140 template<> class JArray<jint> : public java::lang::Object {
1144 class arrayElements {
1150 arrayElements(jintArray array) {
1151 this->array = array;
1152 elts = env->get_vm_env()->GetIntArrayElements(array, &isCopy);
1154 virtual ~arrayElements() {
1155 env->get_vm_env()->ReleaseIntArrayElements(array, elts, 0);
1162 arrayElements elements() {
1163 return arrayElements((jintArray) this$);
1166 JArray<jint>(jobject obj) : java::lang::Object(obj) {
1167 length = this$ ? env->getArrayLength((jarray) this$) : 0;
1170 JArray<jint>(const JArray& obj) : java::lang::Object(obj) {
1171 length = obj.length;
1174 JArray<jint>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewIntArray(n)) {
1175 length = env->getArrayLength((jarray) this$);
1179 JArray<jint>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewIntArray(PySequence_Length(sequence))) {
1180 length = env->getArrayLength((jarray) this$);
1181 arrayElements elts = elements();
1182 jint *buf = (jint *) elts;
1184 for (Py_ssize_t i = 0; i < length; i++) {
1185 PyObject *obj = PySequence_GetItem(sequence, i);
1190 if (PyInt_Check(obj))
1192 buf[i] = (jint) PyInt_AS_LONG(obj);
1197 PyErr_SetObject(PyExc_TypeError, obj);
1204 PyObject *toSequence()
1206 return toSequence(0, length);
1209 PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
1214 if (lo < 0) lo = length + lo;
1216 else if (lo > length) lo = length;
1217 if (hi < 0) hi = length + hi;
1219 else if (hi > length) hi = length;
1220 if (lo > hi) lo = hi;
1222 PyObject *list = PyList_New(hi - lo);
1223 arrayElements elts = elements();
1224 jint *buf = (jint *) elts;
1226 for (Py_ssize_t i = lo; i < hi; i++)
1227 PyList_SET_ITEM(list, i - lo, PyInt_FromLong(buf[i]));
1232 PyObject *get(Py_ssize_t n)
1239 if (n >= 0 && n < length)
1240 return PyInt_FromLong((*this)[n]);
1243 PyErr_SetString(PyExc_IndexError, "index out of range");
1247 int set(Py_ssize_t n, PyObject *obj)
1254 if (n >= 0 && n < length)
1256 if (!PyInt_Check(obj))
1258 PyErr_SetObject(PyExc_TypeError, obj);
1262 elements()[n] = (jint) PyInt_AS_LONG(obj);
1267 PyErr_SetString(PyExc_IndexError, "index out of range");
1271 PyObject *wrap() const;
1274 jint operator[](Py_ssize_t n) {
1275 JNIEnv *vm_env = env->get_vm_env();
1276 jboolean isCopy = 0;
1277 jint *elts = (jint *)
1278 vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
1279 jint value = elts[n];
1281 vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
1287 template<> class JArray<jlong> : public java::lang::Object {
1291 class arrayElements {
1297 arrayElements(jlongArray array) {
1298 this->array = array;
1299 elts = env->get_vm_env()->GetLongArrayElements(array, &isCopy);
1301 virtual ~arrayElements() {
1302 env->get_vm_env()->ReleaseLongArrayElements(array, elts, 0);
1304 operator jlong *() {
1309 arrayElements elements() {
1310 return arrayElements((jlongArray) this$);
1313 JArray<jlong>(jobject obj) : java::lang::Object(obj) {
1314 length = this$ ? env->getArrayLength((jarray) this$) : 0;
1317 JArray<jlong>(const JArray& obj) : java::lang::Object(obj) {
1318 length = obj.length;
1321 JArray<jlong>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewLongArray(n)) {
1322 length = env->getArrayLength((jarray) this$);
1326 JArray<jlong>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewLongArray(PySequence_Length(sequence))) {
1327 length = env->getArrayLength((jarray) this$);
1328 arrayElements elts = elements();
1329 jlong *buf = (jlong *) elts;
1331 for (Py_ssize_t i = 0; i < length; i++) {
1332 PyObject *obj = PySequence_GetItem(sequence, i);
1337 if (PyLong_Check(obj))
1339 buf[i] = (jlong) PyLong_AsLongLong(obj);
1344 PyErr_SetObject(PyExc_TypeError, obj);
1351 PyObject *toSequence()
1353 return toSequence(0, length);
1356 PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
1361 if (lo < 0) lo = length + lo;
1363 else if (lo > length) lo = length;
1364 if (hi < 0) hi = length + hi;
1366 else if (hi > length) hi = length;
1367 if (lo > hi) lo = hi;
1369 PyObject *list = PyList_New(hi - lo);
1370 arrayElements elts = elements();
1371 jlong *buf = (jlong *) elts;
1373 for (Py_ssize_t i = lo; i < hi; i++)
1374 PyList_SET_ITEM(list, i - lo, PyLong_FromLongLong((long long) buf[i]));
1379 PyObject *get(Py_ssize_t n)
1386 if (n >= 0 && n < length)
1387 return PyLong_FromLongLong((long long) (*this)[n]);
1390 PyErr_SetString(PyExc_IndexError, "index out of range");
1394 int set(Py_ssize_t n, PyObject *obj)
1401 if (n >= 0 && n < length)
1403 if (!PyLong_Check(obj))
1405 PyErr_SetObject(PyExc_TypeError, obj);
1409 elements()[n] = (jlong) PyLong_AsLongLong(obj);
1414 PyErr_SetString(PyExc_IndexError, "index out of range");
1418 PyObject *wrap() const;
1421 jlong operator[](long n) {
1422 JNIEnv *vm_env = env->get_vm_env();
1423 jboolean isCopy = 0;
1424 jlong *elts = (jlong *)
1425 vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
1426 jlong value = elts[n];
1428 vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
1434 template<> class JArray<jshort> : public java::lang::Object {
1438 class arrayElements {
1444 arrayElements(jshortArray array) {
1445 this->array = array;
1446 elts = env->get_vm_env()->GetShortArrayElements(array, &isCopy);
1448 virtual ~arrayElements() {
1449 env->get_vm_env()->ReleaseShortArrayElements(array, elts, 0);
1451 operator jshort *() {
1456 arrayElements elements() {
1457 return arrayElements((jshortArray) this$);
1460 JArray<jshort>(jobject obj) : java::lang::Object(obj) {
1461 length = this$ ? env->getArrayLength((jarray) this$) : 0;
1464 JArray<jshort>(const JArray& obj) : java::lang::Object(obj) {
1465 length = obj.length;
1468 JArray<jshort>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewShortArray(n)) {
1469 length = env->getArrayLength((jarray) this$);
1473 JArray<jshort>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewShortArray(PySequence_Length(sequence))) {
1474 length = env->getArrayLength((jarray) this$);
1475 arrayElements elts = elements();
1476 jshort *buf = (jshort *) elts;
1478 for (Py_ssize_t i = 0; i < length; i++) {
1479 PyObject *obj = PySequence_GetItem(sequence, i);
1484 if (PyInt_Check(obj))
1486 buf[i] = (jshort) PyInt_AS_LONG(obj);
1491 PyErr_SetObject(PyExc_TypeError, obj);
1498 PyObject *toSequence()
1500 return toSequence(0, length);
1503 PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
1508 if (lo < 0) lo = length + lo;
1510 else if (lo > length) lo = length;
1511 if (hi < 0) hi = length + hi;
1513 else if (hi > length) hi = length;
1514 if (lo > hi) lo = hi;
1516 PyObject *list = PyList_New(hi - lo);
1517 arrayElements elts = elements();
1518 jshort *buf = (jshort *) elts;
1520 for (Py_ssize_t i = lo; i < hi; i++)
1521 PyList_SET_ITEM(list, i - lo, PyInt_FromLong(buf[i]));
1526 PyObject *get(Py_ssize_t n)
1533 if (n >= 0 && n < length)
1534 return PyInt_FromLong((long) (*this)[n]);
1537 PyErr_SetString(PyExc_IndexError, "index out of range");
1541 int set(Py_ssize_t n, PyObject *obj)
1548 if (n >= 0 && n < length)
1550 if (!PyInt_Check(obj))
1552 PyErr_SetObject(PyExc_TypeError, obj);
1556 elements()[n] = (jshort) PyInt_AS_LONG(obj);
1561 PyErr_SetString(PyExc_IndexError, "index out of range");
1565 PyObject *wrap() const;
1568 jshort operator[](Py_ssize_t n) {
1569 JNIEnv *vm_env = env->get_vm_env();
1570 jboolean isCopy = 0;
1571 jshort *elts = (jshort *)
1572 vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
1573 jshort value = elts[n];
1575 vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
1583 template<typename T> class t_JArray {
1588 static PyObject *wrap_Object(const JArray<T>& array)
1591 return array.wrap();
1599 #endif /* _JArray_H */