1 /*

     2  *   Copyright (c) 2007-2008 Open Source Applications Foundation

     3  *

     4  *   Licensed under the Apache License, Version 2.0 (the "License");

     5  *   you may not use this file except in compliance with the License.

     6  *   You may obtain a copy of the License at

     7  *

     8  *       http://www.apache.org/licenses/LICENSE-2.0

     9  *

    10  *   Unless required by applicable law or agreed to in writing, software

    11  *   distributed under the License is distributed on an "AS IS" BASIS,

    12  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    13  *   See the License for the specific language governing permissions and

    14  *   limitations under the License.

    15  */

    16 

    17 #ifndef _JArray_H

    18 #define _JArray_H

    19 

    20 #ifdef PYTHON

    21 #include <Python.h>

    22 #include "macros.h"

    23 

    24 extern jobjectArray fromPySequence(jclass cls, PyObject *sequence);

    25 extern PyObject *PyErr_SetJavaError(jthrowable throwable);

    26 

    27 extern PyTypeObject *JArrayObject$$Type;

    28 extern PyTypeObject *JArrayString$$Type;

    29 extern PyTypeObject *JArrayBool$$Type;

    30 extern PyTypeObject *JArrayByte$$Type;

    31 extern PyTypeObject *JArrayChar$$Type;

    32 extern PyTypeObject *JArrayDouble$$Type;

    33 extern PyTypeObject *JArrayFloat$$Type;

    34 extern PyTypeObject *JArrayInt$$Type;

    35 extern PyTypeObject *JArrayLong$$Type;

    36 extern PyTypeObject *JArrayShort$$Type;

    37 

    38 #endif

    39 

    40 #include "JCCEnv.h"

    41 #include "java/lang/Object.h"

    42 

    43 

    44 template<typename T> class JArray : public java::lang::Object {

    45 public:

    46     int length;

    47 

    48     explicit JArray<T>(jobject obj) : java::lang::Object(obj) {

    49         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

    50     }

    51     JArray<T>(const JArray<T>& obj) : java::lang::Object(obj) {

    52         length = obj.length;

    53     }

    54 

    55 #ifdef PYTHON

    56     JArray<T>(PyObject *sequence) : java::lang::Object(fromPySequence(T::initializeClass(), sequence)) {

    57         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

    58     }

    59 

    60     JArray<T>(jclass cls, PyObject *sequence) : java::lang::Object(fromPySequence(cls, sequence)) {

    61         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

    62     }

    63 

    64     PyObject *toSequence(PyObject *(*wrapfn)(const T&))

    65     {

    66         if (this$ == NULL)

    67             Py_RETURN_NONE;

    68 

    69         PyObject *list = PyList_New(length);

    70 

    71         for (int i = 0; i < length; i++)

    72             PyList_SET_ITEM(list, i, (*wrapfn)((*this)[i]));

    73 

    74         return list;

    75     }

    76 

    77     PyObject *get(int n, PyObject *(*wrapfn)(const T&))

    78     {

    79         if (this$ != NULL)

    80         {

    81             if (n < 0)

    82                 n = length + n;

    83 

    84             if (n >= 0 && n < length)

    85                 return (*wrapfn)((*this)[n]);

    86         }

    87 

    88         PyErr_SetString(PyExc_IndexError, "index out of range");

    89         return NULL;

    90     }

    91 #endif

    92 

    93     T operator[](int n) {

    94         return T(env->getObjectArrayElement((jobjectArray) this$, n));

    95     }

    96 };

    97 

    98 template<> class JArray<jobject> : public java::lang::Object {

    99   public:

   100     int length;

   101 

   102     JArray<jobject>(jclass cls, int n) : java::lang::Object(env->get_vm_env()->NewObjectArray(n, cls, NULL)) {

   103         length = env->getArrayLength((jobjectArray) this$);

   104     }

   105 

   106     JArray<jobject>(jobject obj) : java::lang::Object(obj) {

   107         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

   108     }

   109 

   110     JArray<jobject>(const JArray& obj) : java::lang::Object(obj) {

   111         length = obj.length;

   112     }

   113 

   114 #ifdef PYTHON

   115     JArray<jobject>(jclass cls, PyObject *sequence) : java::lang::Object(fromPySequence(cls, sequence)) {

   116         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

   117     }

   118 

   119     PyObject *toSequence(PyObject *(*wrapfn)(const jobject&))

   120     {

   121         return toSequence(0, length, wrapfn);

   122     }

   123 

   124     PyObject *toSequence(int lo, int hi, PyObject *(*wrapfn)(const jobject&))

   125     {

   126         if (this$ == NULL)

   127             Py_RETURN_NONE;

   128 

   129         if (lo < 0) lo = length + lo;

   130         if (lo < 0) lo = 0;

   131         else if (lo > length) lo = length;

   132         if (hi < 0) hi = length + hi;

   133         if (hi < 0) hi = 0;

   134         else if (hi > length) hi = length;

   135         if (lo > hi) lo = hi;

   136 

   137         PyObject *list = PyList_New(hi - lo);

   138 

   139         if (!wrapfn)

   140             wrapfn = java::lang::t_Object::wrap_jobject;

   141 

   142         for (int i = lo; i < hi; i++) {

   143             jobject jobj = env->getObjectArrayElement((jobjectArray) this$, i);

   144             PyObject *obj = (*wrapfn)(jobj);

   145 

   146             PyList_SET_ITEM(list, i - lo, obj);

   147         }

   148          

   149         return list;

   150     }

   151 

   152     PyObject *get(int n, PyObject *(*wrapfn)(const jobject&))

   153     {

   154         if (this$ != NULL)

   155         {

   156             if (n < 0)

   157                 n = length + n;

   158 

   159             if (n >= 0 && n < length)

   160             {

   161                 if (!wrapfn)

   162                     wrapfn = java::lang::t_Object::wrap_jobject;

   163 

   164                 jobject jobj =

   165                     env->getObjectArrayElement((jobjectArray) this$, n);

   166 

   167                 return (*wrapfn)(jobj);

   168             }

   169         }

   170 

   171         PyErr_SetString(PyExc_IndexError, "index out of range");

   172         return NULL;

   173     }

   174 

   175     int set(int n, PyObject *obj)

   176     {

   177         if (this$ != NULL)

   178         {

   179             if (n < 0)

   180                 n = length + n;

   181 

   182             if (n >= 0 && n < length)

   183             {

   184                 if (!PyObject_TypeCheck(obj, &JObject$$Type))

   185                 {

   186                     PyErr_SetObject(PyExc_TypeError, obj);

   187                     return -1;

   188                 }

   189 

   190                 jobject jobj = ((t_JObject *) obj)->object.this$;

   191 

   192                 try {

   193                     env->setObjectArrayElement((jobjectArray) this$, n, jobj);

   194                 } catch (JCCEnv::exception e) {

   195                     PyErr_SetJavaError(e.throwable);

   196                     return -1;

   197                 }

   198 

   199                 return 0;

   200             }

   201         }

   202 

   203         PyErr_SetString(PyExc_IndexError, "index out of range");

   204         return -1;

   205     }

   206 

   207     PyObject *wrap(PyObject *(*wrapfn)(const jobject&));

   208 #endif

   209 

   210     jobject operator[](int n) {

   211         return (jobject) env->getObjectArrayElement((jobjectArray) this$, n);

   212     }

   213 };

   214 

   215 template<> class JArray<jstring> : public java::lang::Object {

   216   public:

   217     int length;

   218 

   219     JArray<jstring>(jobject obj) : java::lang::Object(obj) {

   220         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;

   221     }

   222 

   223     JArray<jstring>(const JArray& obj) : java::lang::Object(obj) {

   224         length = obj.length;

   225     }

   226 

   227     JArray<jstring>(int n) : java::lang::Object(env->get_vm_env()->NewObjectArray(n, env->findClass("java/lang/String"), NULL)) {

   228         length = env->getArrayLength((jobjectArray) this$);

   229     }

   230 

   231 #ifdef PYTHON

   232     JArray<jstring>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewObjectArray(PySequence_Length(sequence), env->findClass("java/lang/String"), NULL)) {

   233         length = env->getArrayLength((jobjectArray) this$);

   234 

   235         for (int i = 0; i < length; i++) {

   236             PyObject *obj = PySequence_GetItem(sequence, i);

   237 

   238             if (obj == NULL)

   239                 break;

   240 

   241             jstring str = env->fromPyString(obj);

   242 

   243             Py_DECREF(obj);

   244             if (PyErr_Occurred())

   245                 break;

   246 

   247             env->setObjectArrayElement((jobjectArray) this$, i, str);

   248             env->get_vm_env()->DeleteLocalRef(str);

   249         }

   250     }

   251 

   252     PyObject *toSequence()

   253     {

   254         return toSequence(0, length);

   255     }

   256 

   257     PyObject *toSequence(int lo, int hi)

   258     {

   259         if (this$ == NULL)

   260             Py_RETURN_NONE;

   261 

   262         if (lo < 0) lo = length + lo;

   263         if (lo < 0) lo = 0;

   264         else if (lo > length) lo = length;

   265         if (hi < 0) hi = length + hi;

   266         if (hi < 0) hi = 0;

   267         else if (hi > length) hi = length;

   268         if (lo > hi) lo = hi;

   269 

   270         PyObject *list = PyList_New(hi - lo);

   271 

   272         for (int i = lo; i < hi; i++) {

   273             jstring str = (jstring)

   274                 env->getObjectArrayElement((jobjectArray) this$, i);

   275             PyObject *obj = env->fromJString(str, 1);

   276 

   277             PyList_SET_ITEM(list, i - lo, obj);

   278         }

   279          

   280         return list;

   281     }

   282 

   283     PyObject *get(int n)

   284     {

   285         if (this$ != NULL)

   286         {

   287             if (n < 0)

   288                 n = length + n;

   289 

   290             if (n >= 0 && n < length)

   291             {

   292                 jstring str = (jstring)

   293                     env->getObjectArrayElement((jobjectArray) this$, n);

   294                 PyObject *obj = env->fromJString(str, 1);

   295 

   296                 return obj;

   297             }

   298         }

   299 

   300         PyErr_SetString(PyExc_IndexError, "index out of range");

   301         return NULL;

   302     }

   303 

   304     int set(int n, PyObject *obj)

   305     {

   306         if (this$ != NULL)

   307         {

   308             if (n < 0)

   309                 n = length + n;

   310 

   311             if (n >= 0 && n < length)

   312             {

   313                 jstring str = env->fromPyString(obj);

   314 

   315                 if (PyErr_Occurred())

   316                     return -1;

   317 

   318                 env->setObjectArrayElement((jobjectArray) this$, n, str);

   319                 return 0;

   320             }

   321         }

   322 

   323         PyErr_SetString(PyExc_IndexError, "index out of range");

   324         return -1;

   325     }

   326 

   327     PyObject *wrap();

   328 #endif

   329 

   330     jstring operator[](int n) {

   331         return (jstring) env->getObjectArrayElement((jobjectArray) this$, n);

   332     }

   333 };

   334 

   335 template<> class JArray<jboolean> : public java::lang::Object {

   336   public:

   337     int length;

   338 

   339     class arrayElements {

   340     private:

   341         jboolean isCopy;

   342         jbooleanArray array;

   343         jboolean *elts;

   344     public:

   345         arrayElements(jbooleanArray array) {

   346             this->array = array;

   347             elts = env->get_vm_env()->GetBooleanArrayElements(array, &isCopy);

   348         }

   349         virtual ~arrayElements() {

   350             env->get_vm_env()->ReleaseBooleanArrayElements(array, elts, isCopy);

   351         }

   352         operator jboolean *() {

   353             return elts;

   354         }

   355     };

   356 

   357     arrayElements elements() {

   358         return arrayElements((jbooleanArray) this$);

   359     }

   360 

   361     JArray<jboolean>(jobject obj) : java::lang::Object(obj) {

   362         length = this$ ? env->getArrayLength((jarray) this$) : 0;

   363     }

   364 

   365     JArray<jboolean>(const JArray& obj) : java::lang::Object(obj) {

   366         length = obj.length;

   367     }

   368 

   369     JArray<jboolean>(int n) : java::lang::Object(env->get_vm_env()->NewBooleanArray(n)) {

   370         length = env->getArrayLength((jarray) this$);

   371     }

   372 

   373 #ifdef PYTHON

   374     JArray<jboolean>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewBooleanArray(PySequence_Length(sequence))) {

   375         length = env->getArrayLength((jarray) this$);

   376         arrayElements elts = elements();

   377         jboolean *buf = (jboolean *) elts;

   378 

   379         for (int i = 0; i < length; i++) {

   380             PyObject *obj = PySequence_GetItem(sequence, i);

   381 

   382             if (!obj)

   383                 break;

   384 

   385             if (obj == Py_True || obj == Py_False)

   386             {

   387                 buf[i] = (jboolean) (obj == Py_True);

   388                 Py_DECREF(obj);

   389             }

   390             else

   391             {

   392                 PyErr_SetObject(PyExc_TypeError, obj);

   393                 Py_DECREF(obj);

   394                 break;

   395             }

   396         }

   397     }

   398 

   399     PyObject *toSequence()

   400     {

   401         return toSequence(0, length);

   402     }

   403 

   404     PyObject *toSequence(int lo, int hi)

   405     {

   406         if (this$ == NULL)

   407             Py_RETURN_NONE;

   408 

   409         if (lo < 0) lo = length + lo;

   410         if (lo < 0) lo = 0;

   411         else if (lo > length) lo = length;

   412         if (hi < 0) hi = length + hi;

   413         if (hi < 0) hi = 0;

   414         else if (hi > length) hi = length;

   415         if (lo > hi) lo = hi;

   416 

   417         PyObject *list = PyList_New(hi - lo);

   418         arrayElements elts = elements();

   419         jboolean *buf = (jboolean *) elts;

   420 

   421         for (int i = lo; i < hi; i++) {

   422             jboolean value = buf[i];

   423             PyObject *obj = value ? Py_True : Py_False;

   424 

   425             Py_INCREF(obj);

   426             PyList_SET_ITEM(list, i - lo, obj);

   427         }

   428          

   429         return list;

   430     }

   431 

   432     PyObject *get(int n)

   433     {

   434         if (this$ != NULL)

   435         {

   436             if (n < 0)

   437                 n = length + n;

   438 

   439             if (n >= 0 && n < length)

   440                 Py_RETURN_BOOL(elements()[n]);

   441         }

   442 

   443         PyErr_SetString(PyExc_IndexError, "index out of range");

   444         return NULL;

   445     }

   446 

   447     int set(int n, PyObject *obj)

   448     {

   449         if (this$ != NULL)

   450         {

   451             if (n < 0)

   452                 n = length + n;

   453 

   454             if (n >= 0 && n < length)

   455             {

   456                 elements()[n] = (jboolean) PyObject_IsTrue(obj);

   457                 return 0;

   458             }

   459         }

   460 

   461         PyErr_SetString(PyExc_IndexError, "index out of range");

   462         return -1;

   463     }

   464 

   465     PyObject *wrap();

   466 #endif

   467 

   468     jboolean operator[](int n) {

   469         JNIEnv *vm_env = env->get_vm_env();

   470         jboolean isCopy = 0;

   471         jboolean *elts = (jboolean *)

   472             vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);

   473         jboolean value = elts[n];

   474 

   475         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, isCopy);

   476 

   477         return value;

   478     }

   479 };

   480 

   481 template<> class JArray<jbyte> : public java::lang::Object {

   482   public:

   483     int length;

   484 

   485     class arrayElements {

   486     private:

   487         jboolean isCopy;

   488         jbyteArray array;

   489         jbyte *elts;

   490     public:

   491         arrayElements(jbyteArray array) {

   492             this->array = array;

   493             elts = env->get_vm_env()->GetByteArrayElements(array, &isCopy);

   494         }

   495         virtual ~arrayElements() {

   496             env->get_vm_env()->ReleaseByteArrayElements(array, elts, isCopy);

   497         }

   498         operator jbyte *() {

   499             return elts;

   500         }

   501     };

   502 

   503     arrayElements elements() {

   504         return arrayElements((jbyteArray) this$);

   505     }

   506 

   507     JArray<jbyte>(jobject obj) : java::lang::Object(obj) {

   508         length = this$ ? env->getArrayLength((jarray) this$) : 0;

   509     }

   510 

   511     JArray<jbyte>(const JArray& obj) : java::lang::Object(obj) {

   512         length = obj.length;

   513     }

   514 

   515     JArray<jbyte>(int n) : java::lang::Object(env->get_vm_env()->NewByteArray(n)) {

   516         length = env->getArrayLength((jarray) this$);

   517     }

   518 

   519 #ifdef PYTHON

   520     JArray<jbyte>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewByteArray(PySequence_Length(sequence))) {

   521         length = env->getArrayLength((jarray) this$);

   522         arrayElements elts = elements();

   523         jbyte *buf = (jbyte *) elts;

   524 

   525         if (PyString_Check(sequence))

   526             memcpy(buf, PyString_AS_STRING(sequence), length);

   527         else

   528             for (int i = 0; i < length; i++) {

   529                 PyObject *obj = PySequence_GetItem(sequence, i);

   530 

   531                 if (!obj)

   532                     break;

   533 

   534                 if (PyString_Check(obj) && (PyString_GET_SIZE(obj) == 1))

   535                 {

   536                     buf[i] = (jbyte) PyString_AS_STRING(obj)[0];

   537                     Py_DECREF(obj);

   538                 }

   539                 else if (PyInt_CheckExact(obj))

   540                 {

   541                     buf[i] = (jbyte) PyInt_AS_LONG(obj);

   542                     Py_DECREF(obj);

   543                 }

   544                 else

   545                 {

   546                     PyErr_SetObject(PyExc_TypeError, obj);

   547                     Py_DECREF(obj);

   548                     break;

   549                 }

   550             }

   551     }

   552 

   553     char getType()

   554     {

   555         return 'Z';

   556     }

   557 

   558     PyObject *toSequence()

   559     {

   560         return toSequence(0, length);

   561     }

   562 

   563     PyObject *toSequence(int lo, int hi)

   564     {

   565         if (this$ == NULL)

   566             Py_RETURN_NONE;

   567 

   568         if (lo < 0) lo = length + lo;

   569         if (lo < 0) lo = 0;

   570         else if (lo > length) lo = length;

   571         if (hi < 0) hi = length + hi;

   572         if (hi < 0) hi = 0;

   573         else if (hi > length) hi = length;

   574         if (lo > hi) lo = hi;

   575 

   576         arrayElements elts = elements();

   577         jbyte *buf = (jbyte *) elts;

   578         PyObject *tuple = PyTuple_New(hi - lo);

   579         

   580         for (int i = 0; i < hi - lo; i++)

   581             PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(buf[lo + i]));

   582 

   583         return tuple;

   584     }

   585 

   586     PyObject *to_string_()

   587     {

   588         if (this$ == NULL)

   589             Py_RETURN_NONE;

   590 

   591         arrayElements elts = elements();

   592         jbyte *buf = (jbyte *) elts;

   593 

   594         return PyString_FromStringAndSize((char *) buf, length);

   595     }

   596 

   597     PyObject *get(int n)

   598     {

   599         if (this$ != NULL)

   600         {

   601             if (n < 0)

   602                 n = length + n;

   603 

   604             if (n >= 0 && n < length)

   605             {

   606                 jbyte b = (*this)[n];

   607                 return PyInt_FromLong(b);

   608             }

   609         }

   610 

   611         PyErr_SetString(PyExc_IndexError, "index out of range");

   612         return NULL;

   613     }

   614 

   615     int set(int n, PyObject *obj)

   616     {

   617         if (this$ != NULL)

   618         {

   619             if (n < 0)

   620                 n = length + n;

   621 

   622             if (n >= 0 && n < length)

   623             {

   624                 if (!PyInt_CheckExact(obj))

   625                 {

   626                     PyErr_SetObject(PyExc_TypeError, obj);

   627                     return -1;

   628                 }

   629 

   630                 elements()[n] = (jbyte) PyInt_AS_LONG(obj);

   631                 return 0;

   632             }

   633         }

   634 

   635         PyErr_SetString(PyExc_IndexError, "index out of range");

   636         return -1;

   637     }

   638 

   639     PyObject *wrap();

   640 #endif

   641 

   642     jbyte operator[](int n) {

   643         JNIEnv *vm_env = env->get_vm_env();

   644         jboolean isCopy = 0;

   645         jbyte *elts = (jbyte *)

   646             vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);

   647         jbyte value = elts[n];

   648 

   649         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, isCopy);

   650 

   651         return value;

   652     }

   653 };

   654 

   655 template<> class JArray<jchar> : public java::lang::Object {

   656   public:

   657     int length;

   658 

   659     class arrayElements {

   660     private:

   661         jboolean isCopy;

   662         jcharArray array;

   663         jchar *elts;

   664     public:

   665         arrayElements(jcharArray array) {

   666             this->array = array;

   667             elts = env->get_vm_env()->GetCharArrayElements(array, &isCopy);

   668         }

   669         virtual ~arrayElements() {

   670             env->get_vm_env()->ReleaseCharArrayElements(array, elts, isCopy);

   671         }

   672         operator jchar *() {

   673             return elts;

   674         }

   675     };

   676 

   677     arrayElements elements() {

   678         return arrayElements((jcharArray) this$);

   679     }

   680 

   681     JArray<jchar>(jobject obj) : java::lang::Object(obj) {

   682         length = this$ ? env->getArrayLength((jarray) this$) : 0;

   683     }

   684 

   685     JArray<jchar>(const JArray& obj) : java::lang::Object(obj) {

   686         length = obj.length;

   687     }

   688 

   689     JArray<jchar>(int n) : java::lang::Object(env->get_vm_env()->NewCharArray(n)) {

   690         length = env->getArrayLength((jarray) this$);

   691     }

   692 

   693 #ifdef PYTHON

   694     JArray<jchar>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewCharArray(PySequence_Length(sequence))) {

   695         length = env->getArrayLength((jarray) this$);

   696         arrayElements elts = elements();

   697         jchar *buf = (jchar *) elts;

   698 

   699         if (PyUnicode_Check(sequence))

   700         {

   701             if (sizeof(Py_UNICODE) == sizeof(jchar))

   702                 memcpy(buf, PyUnicode_AS_UNICODE(sequence),

   703                        length * sizeof(jchar));

   704             else

   705             {

   706                 Py_UNICODE *pchars = PyUnicode_AS_UNICODE(sequence);

   707                 for (int i = 0; i < length; i++)

   708                     buf[i] = (jchar) pchars[i];

   709             }

   710         }

   711         else

   712             for (int i = 0; i < length; i++) {

   713                 PyObject *obj = PySequence_GetItem(sequence, i);

   714 

   715                 if (!obj)

   716                     break;

   717 

   718                 if (PyUnicode_Check(obj) && (PyUnicode_GET_SIZE(obj) == 1))

   719                 {

   720                     buf[i] = (jchar) PyUnicode_AS_UNICODE(obj)[0];

   721                     Py_DECREF(obj);

   722                 }

   723                 else

   724                 {

   725                     PyErr_SetObject(PyExc_TypeError, obj);

   726                     Py_DECREF(obj);

   727                     break;

   728                 }

   729             }

   730     }

   731 

   732     PyObject *toSequence()

   733     {

   734         return toSequence(0, length);

   735     }

   736 

   737     PyObject *toSequence(int lo, int hi)

   738     {

   739         if (this$ == NULL)

   740             Py_RETURN_NONE;

   741 

   742         if (lo < 0) lo = length + lo;

   743         if (lo < 0) lo = 0;

   744         else if (lo > length) lo = length;

   745         if (hi < 0) hi = length + hi;

   746         if (hi < 0) hi = 0;

   747         else if (hi > length) hi = length;

   748         if (lo > hi) lo = hi;

   749 

   750         arrayElements elts = elements();

   751         jchar *buf = (jchar *) elts;

   752 

   753         if (sizeof(Py_UNICODE) == sizeof(jchar))

   754             return PyUnicode_FromUnicode((const Py_UNICODE *) buf + lo,

   755                                          hi - lo);

   756         else

   757         {

   758             PyObject *string = PyUnicode_FromUnicode(NULL, hi - lo);

   759             Py_UNICODE *pchars = PyUnicode_AS_UNICODE(string);

   760 

   761             for (int i = lo; i < hi; i++)

   762                 pchars[i - lo] = (Py_UNICODE) buf[i];

   763 

   764             return string;

   765         }

   766     }

   767 

   768     PyObject *get(int n)

   769     {

   770         if (this$ != NULL)

   771         {

   772             if (n < 0)

   773                 n = length + n;

   774 

   775             if (n >= 0 && n < length)

   776             {

   777                 jchar c = (*this)[n];

   778 

   779                 if (sizeof(Py_UNICODE) == sizeof(jchar))

   780                     return PyUnicode_FromUnicode((const Py_UNICODE *) &c, 1);

   781                 else

   782                 {

   783                     PyObject *string = PyUnicode_FromUnicode(NULL, 1);

   784                     Py_UNICODE *pchars = PyUnicode_AS_UNICODE(string);

   785 

   786                     pchars[0] = (Py_UNICODE) c;

   787 

   788                     return string;

   789                 }

   790             }

   791         }

   792 

   793         PyErr_SetString(PyExc_IndexError, "index out of range");

   794         return NULL;

   795     }

   796 

   797     int set(int n, PyObject *obj)

   798     {

   799         if (this$ != NULL)

   800         {

   801             if (n < 0)

   802                 n = length + n;

   803 

   804             if (n >= 0 && n < length)

   805             {

   806                 if (!PyUnicode_Check(obj))

   807                 {

   808                     PyErr_SetObject(PyExc_TypeError, obj);

   809                     return -1;

   810                 }

   811                 if (PyUnicode_GET_SIZE(obj) != 1)

   812                 {

   813                     PyErr_SetObject(PyExc_ValueError, obj);

   814                     return -1;

   815                 }

   816 

   817                 elements()[n] = (jchar) PyUnicode_AS_UNICODE(obj)[0];

   818                 return 0;

   819             }

   820         }

   821 

   822         PyErr_SetString(PyExc_IndexError, "index out of range");

   823         return -1;

   824     }

   825 

   826     PyObject *wrap();

   827 #endif

   828 

   829     jchar operator[](int n) {

   830         JNIEnv *vm_env = env->get_vm_env();

   831         jboolean isCopy = 0;

   832         jchar *elts = (jchar *)

   833             vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);

   834         jchar value = elts[n];

   835 

   836         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, isCopy);

   837 

   838         return value;

   839     }

   840 };

   841 

   842 template<> class JArray<jdouble> : public java::lang::Object {

   843   public:

   844     int length;

   845 

   846     class arrayElements {

   847     private:

   848         jboolean isCopy;

   849         jdoubleArray array;

   850         jdouble *elts;

   851     public:

   852         arrayElements(jdoubleArray array) {

   853             this->array = array;

   854             elts = env->get_vm_env()->GetDoubleArrayElements(array, &isCopy);

   855         }

   856         virtual ~arrayElements() {

   857             env->get_vm_env()->ReleaseDoubleArrayElements(array, elts, isCopy);

   858         }

   859         operator jdouble *() {

   860             return elts;

   861         }

   862     };

   863 

   864     arrayElements elements() {

   865         return arrayElements((jdoubleArray) this$);

   866     }

   867 

   868     JArray<jdouble>(jobject obj) : java::lang::Object(obj) {

   869         length = this$ ? env->getArrayLength((jarray) this$) : 0;

   870     }

   871 

   872     JArray<jdouble>(const JArray& obj) : java::lang::Object(obj) {

   873         length = obj.length;

   874     }

   875 

   876     JArray<jdouble>(int n) : java::lang::Object(env->get_vm_env()->NewDoubleArray(n)) {

   877         length = env->getArrayLength((jarray) this$);

   878     }

   879 

   880 #ifdef PYTHON

   881     JArray<jdouble>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewDoubleArray(PySequence_Length(sequence))) {

   882         length = env->getArrayLength((jarray) this$);

   883         arrayElements elts = elements();

   884         jdouble *buf = (jdouble *) elts;

   885 

   886         for (int i = 0; i < length; i++) {

   887             PyObject *obj = PySequence_GetItem(sequence, i);

   888 

   889             if (!obj)

   890                 break;

   891 

   892             if (PyFloat_Check(obj))

   893             {

   894                 buf[i] = (jdouble) PyFloat_AS_DOUBLE(obj);

   895                 Py_DECREF(obj);

   896             }

   897             else

   898             {

   899                 PyErr_SetObject(PyExc_TypeError, obj);

   900                 Py_DECREF(obj);

   901                 break;

   902             }

   903         }

   904     }

   905 

   906     PyObject *toSequence()

   907     {

   908         return toSequence(0, length);

   909     }

   910 

   911     PyObject *toSequence(int lo, int hi)

   912     {

   913         if (this$ == NULL)

   914             Py_RETURN_NONE;

   915 

   916         if (lo < 0) lo = length + lo;

   917         if (lo < 0) lo = 0;

   918         else if (lo > length) lo = length;

   919         if (hi < 0) hi = length + hi;

   920         if (hi < 0) hi = 0;

   921         else if (hi > length) hi = length;

   922         if (lo > hi) lo = hi;

   923 

   924         PyObject *list = PyList_New(hi - lo);

   925         arrayElements elts = elements();

   926         jdouble *buf = (jdouble *) elts;

   927 

   928         for (int i = lo; i < hi; i++)

   929             PyList_SET_ITEM(list, i - lo, PyFloat_FromDouble((double) buf[i]));

   930 

   931         return list;

   932     }

   933 

   934     PyObject *get(int n)

   935     {

   936         if (this$ != NULL)

   937         {

   938             if (n < 0)

   939                 n = length + n;

   940 

   941             if (n >= 0 && n < length)

   942                 return PyFloat_FromDouble((double) (*this)[n]);

   943         }

   944 

   945         PyErr_SetString(PyExc_IndexError, "index out of range");

   946         return NULL;

   947     }

   948 

   949     int set(int n, PyObject *obj)

   950     {

   951         if (this$ != NULL)

   952         {

   953             if (n < 0)

   954                 n = length + n;

   955 

   956             if (n >= 0 && n < length)

   957             {

   958                 if (!PyFloat_Check(obj))

   959                 {

   960                     PyErr_SetObject(PyExc_TypeError, obj);

   961                     return -1;

   962                 }

   963 

   964                 elements()[n] = (jdouble) PyFloat_AS_DOUBLE(obj);

   965                 return 0;

   966             }

   967         }

   968 

   969         PyErr_SetString(PyExc_IndexError, "index out of range");

   970         return -1;

   971     }

   972 

   973     PyObject *wrap();

   974 #endif

   975 

   976     jdouble operator[](int n) {

   977         JNIEnv *vm_env = env->get_vm_env();

   978         jboolean isCopy = 0;

   979         jdouble *elts = (jdouble *)

   980             vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);

   981         jdouble value = elts[n];

   982 

   983         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, isCopy);

   984 

   985         return value;

   986     }

   987 };

   988 

   989 template<> class JArray<jfloat> : public java::lang::Object {

   990   public:

   991     int length;

   992 

   993     class arrayElements {

   994     private:

   995         jboolean isCopy;

   996         jfloatArray array;

   997         jfloat *elts;

   998     public:

   999         arrayElements(jfloatArray array) {

  1000             this->array = array;

  1001             elts = env->get_vm_env()->GetFloatArrayElements(array, &isCopy);

  1002         }

  1003         virtual ~arrayElements() {

  1004             env->get_vm_env()->ReleaseFloatArrayElements(array, elts, isCopy);

  1005         }

  1006         operator jfloat *() {

  1007             return elts;

  1008         }

  1009     };

  1010 

  1011     arrayElements elements() {

  1012         return arrayElements((jfloatArray) this$);

  1013     }

  1014 

  1015     JArray<jfloat>(jobject obj) : java::lang::Object(obj) {

  1016         length = this$ ? env->getArrayLength((jarray) this$) : 0;

  1017     }

  1018 

  1019     JArray<jfloat>(const JArray& obj) : java::lang::Object(obj) {

  1020         length = obj.length;

  1021     }

  1022 

  1023     JArray<jfloat>(int n) : java::lang::Object(env->get_vm_env()->NewFloatArray(n)) {

  1024         length = env->getArrayLength((jarray) this$);

  1025     }

  1026 

  1027 #ifdef PYTHON

  1028     JArray<jfloat>(PyObject *sequence) : java::lang::Object(env->get_vm_env()->NewFloatArray(PySequence_Length(sequence))) {

  1029         length = env->getArrayLength((jarray) this$);

  1030         arrayElements elts = elements();

  1031         jfloat *buf = (jfloat *) elts;

  1032 

  1033         for (int i = 0; i < length; i++) {

  1034             PyObject *obj = PySequence_GetItem(sequence, i);

  1035 

  1036             if (!obj)

  1037                 break;

  1038 

  1039             if (PyFloat_Check(obj))

  1040             {

  1041                 buf[i] = (jfloat) PyFloat_AS_DOUBLE(obj);

  1042                 Py_DECREF(obj);

  1043             }

  1044             else

  1045             {

  1046                 PyErr_SetObject(PyExc_TypeError, obj);

  1047                 Py_DECREF(obj);

  1048                 break;

  1049             }

  1050         }

  1051     }

  1052 

  1053     PyObject *toSequence()

  1054     {

  1055         return toSequence(0, length);

  1056     }

  1057 

  1058     PyObject *toSequence(int lo, int hi)

  1059     {

  1060         if (this$ == NULL)

  1061             Py_RETURN_NONE;

  1062 

  1063         if (lo < 0) lo = length + lo;

  1064         if (lo < 0) lo = 0;

  1065         else if (lo > length) lo = length;

  1066         if (hi < 0) hi = length + hi;

  1067         if (hi < 0) hi = 0;

  1068         else if (hi > length) hi = length;

  1069         if (lo > hi) lo = hi;

  1070 

  1071         PyObject *list = PyList_New(hi - lo);

  1072         arrayElements elts = elements();

  1073         jfloat *buf = (jfloat *) elts;

  1074 

  1075         for (int i = lo; i < hi; i++)

  1076             PyList_SET_ITEM(list, i - lo, PyFloat_FromDouble((double) buf[i]));

  1077 

  1078         return list;

  1079     }

  1080 

  1081     PyObject *get(int n)

  1082     {

  1083         if (this$ != NULL)

  1084         {

  1085             if (n < 0)

  1086                 n = length + n;

  1087 

  1088             if (n >= 0 && n < length)

  1089                 return PyFloat_FromDouble((double) (*this)[n]);

  1090         }

  1091 

  1092         PyErr_SetString(PyExc_IndexError, "index out of range");

  1093         return NULL;

  1094     }

  1095 

  1096     int set(int n, PyObject *obj)

  1097     {

  1098         if (this$ != NULL)

  1099         {

  1100             if (n < 0)

  1101                 n = length + n;

  1102 

  1103             if (n >= 0 && n < length)

  1104             {

  1105                 if (!PyFloat_Check(obj))

  1106                 {

  1107                     PyErr_SetObject(PyExc_TypeError, obj);

  1108                     return -1;

  1109                 }

  1110 

  1111                 elements()[n] = (jfloat) PyFloat_AS_DOUBLE(obj);

  1112                 return 0;

  1113             }

  1114         }

  1115 

  1116         PyErr_SetString(PyExc_IndexError, "index out of range");

  1117         return -1;

  1118     }

  1119 

  1120     PyObject *wrap();

  1121 #endif

  1122 

  1123     jfloat operator[](int n) {

  1124         JNIEnv *vm_env = env->get_vm_env();

  1125         jboolean isCopy = 0;

  1126         jfloat *elts = (jfloat *)

  1127             vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);

  1128         jfloat value = elts[n];

  1129 

  1130         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, isCopy);

  1131 

  1132         return value;

  1133     }

  1134 };

  1135 

  1136 template<> class JArray<jint> : public java::lang::Object {