jcc/jcc/sources/JArray.h

   1 /*
   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
   5  *
   6  *       http://www.apache.org/licenses/LICENSE-2.0
   7  *
   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.
  13  */
  14
  15 #ifndef _JArray_H
  16 #define _JArray_H
  17
  18 #ifdef PYTHON
  19 #include <Python.h>
  20 #include "macros.h"
  21
  22 extern jobjectArray fromPySequence(jclass cls, PyObject *sequence);
  23 extern PyObject *PyErr_SetJavaError();
  24
  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);
  35
  36 #endif
  37
  38 #include "JCCEnv.h"
  39 #include "java/lang/Object.h"
  40
  41
  42 template<typename T> class JArray : public java::lang::Object {
  43 public:
  44     Py_ssize_t length;
  45
  46     explicit JArray<T>(jobject obj) : java::lang::Object(obj) {
  47         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
  48     }
  49     JArray<T>(const JArray<T>& obj) : java::lang::Object(obj) {
  50         length = obj.length;
  51     }
  52
  53 #ifdef PYTHON
  54     JArray<T>(PyObject *sequence) : java::lang::Object(fromPySequence(T::initializeClass(), sequence)) {
  55         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
  56     }
  57
  58     JArray<T>(jclass cls, PyObject *sequence) : java::lang::Object(fromPySequence(cls, sequence)) {
  59         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
  60     }
  61
  62     PyObject *toSequence(PyObject *(*wrapfn)(const T&))
  63     {
  64         if (this$ == NULL)
  65             Py_RETURN_NONE;
  66
  67         PyObject *list = PyList_New(length);
  68
  69         for (Py_ssize_t i = 0; i < length; i++)
  70             PyList_SET_ITEM(list, i, (*wrapfn)((*this)[i]));
  71
  72         return list;
  73     }
  74
  75     PyObject *get(Py_ssize_t n, PyObject *(*wrapfn)(const T&))
  76     {
  77         if (this$ != NULL)
  78         {
  79             if (n < 0)
  80                 n = length + n;
  81
  82             if (n >= 0 && n < length)
  83                 return (*wrapfn)((*this)[n]);
  84         }
  85
  86         PyErr_SetString(PyExc_IndexError, "index out of range");
  87         return NULL;
  88     }
  89 #endif
  90
  91     T operator[](Py_ssize_t n) {
  92         return T(env->getObjectArrayElement((jobjectArray) this$, n));
  93     }
  94 };
  95
  96 template<> class JArray<jobject> : public java::lang::Object {
  97   public:
  98     Py_ssize_t length;
  99
 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$);
 102     }
 103
 104     JArray<jobject>(jobject obj) : java::lang::Object(obj) {
 105         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
 106     }
 107
 108     JArray<jobject>(const JArray& obj) : java::lang::Object(obj) {
 109         length = obj.length;
 110     }
 111
 112 #ifdef PYTHON
 113     JArray<jobject>(jclass cls, PyObject *sequence) : java::lang::Object(fromPySequence(cls, sequence)) {
 114         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
 115     }
 116
 117     PyObject *toSequence(PyObject *(*wrapfn)(const jobject&))
 118     {
 119         return toSequence(0, length, wrapfn);
 120     }
 121
 122     PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi,
 123                          PyObject *(*wrapfn)(const jobject&))
 124     {
 125         if (this$ == NULL)
 126             Py_RETURN_NONE;
 127
 128         if (lo < 0) lo = length + lo;
 129         if (lo < 0) lo = 0;
 130         else if (lo > length) lo = length;
 131         if (hi < 0) hi = length + hi;
 132         if (hi < 0) hi = 0;
 133         else if (hi > length) hi = length;
 134         if (lo > hi) lo = hi;
 135
 136         PyObject *list = PyList_New(hi - lo);
 137
 138         if (!wrapfn)
 139             wrapfn = java::lang::t_Object::wrap_jobject;
 140
 141         for (Py_ssize_t i = lo; i < hi; i++) {
 142             jobject jobj = env->getObjectArrayElement((jobjectArray) this$, i);
 143             PyObject *obj = (*wrapfn)(jobj);
 144
 145             PyList_SET_ITEM(list, i - lo, obj);
 146         }
 147
 148         return list;
 149     }
 150
 151     PyObject *get(Py_ssize_t n, PyObject *(*wrapfn)(const jobject&))
 152     {
 153         if (this$ != NULL)
 154         {
 155             if (n < 0)
 156                 n = length + n;
 157
 158             if (n >= 0 && n < length)
 159             {
 160                 if (!wrapfn)
 161                     wrapfn = java::lang::t_Object::wrap_jobject;
 162
 163                 jobject jobj =
 164                     env->getObjectArrayElement((jobjectArray) this$, n);
 165
 166                 return (*wrapfn)(jobj);
 167             }
 168         }
 169
 170         PyErr_SetString(PyExc_IndexError, "index out of range");
 171         return NULL;
 172     }
 173
 174     int set(Py_ssize_t n, PyObject *obj)
 175     {
 176         if (this$ != NULL)
 177         {
 178             if (n < 0)
 179                 n = length + n;
 180
 181             if (n >= 0 && n < length)
 182             {
 183                 if (!PyObject_TypeCheck(obj, &PY_TYPE(JObject)))
 184                 {
 185                     PyErr_SetObject(PyExc_TypeError, obj);
 186                     return -1;
 187                 }
 188
 189                 jobject jobj = ((t_JObject *) obj)->object.this$;
 190
 191                 try {
 192                     env->setObjectArrayElement((jobjectArray) this$, n, jobj);
 193                 } catch (int e) {
 194                     switch (e) {
 195                       case _EXC_JAVA:
 196                         PyErr_SetJavaError();
 197                         return -1;
 198                       default:
 199                         throw;
 200                     }
 201                 }
 202
 203                 return 0;
 204             }
 205         }
 206
 207         PyErr_SetString(PyExc_IndexError, "index out of range");
 208         return -1;
 209     }
 210
 211     PyObject *wrap(PyObject *(*wrapfn)(const jobject&));
 212 #endif
 213
 214     jobject operator[](Py_ssize_t n) {
 215         return (jobject) env->getObjectArrayElement((jobjectArray) this$, n);
 216     }
 217 };
 218
 219 template<> class JArray<jstring> : public java::lang::Object {
 220   public:
 221     Py_ssize_t length;
 222
 223     JArray<jstring>(jobject obj) : java::lang::Object(obj) {
 224         length = this$ ? env->getArrayLength((jobjectArray) this$) : 0;
 225     }
 226
 227     JArray<jstring>(const JArray& obj) : java::lang::Object(obj) {
 228         length = obj.length;
 229     }
 230
 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$);
 233     }
 234
 235 #ifdef PYTHON
 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$);
 238
 239         for (Py_ssize_t i = 0; i < length; i++) {
 240             PyObject *obj = PySequence_GetItem(sequence, i);
 241
 242             if (obj == NULL)
 243                 break;
 244
 245             jstring str = env->fromPyString(obj);
 246
 247             Py_DECREF(obj);
 248             if (PyErr_Occurred())
 249                 break;
 250
 251             env->setObjectArrayElement((jobjectArray) this$, i, str);
 252             env->get_vm_env()->DeleteLocalRef(str);
 253         }
 254     }
 255
 256     PyObject *toSequence()
 257     {
 258         return toSequence(0, length);
 259     }
 260
 261     PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
 262     {
 263         if (this$ == NULL)
 264             Py_RETURN_NONE;
 265
 266         if (lo < 0) lo = length + lo;
 267         if (lo < 0) lo = 0;
 268         else if (lo > length) lo = length;
 269         if (hi < 0) hi = length + hi;
 270         if (hi < 0) hi = 0;
 271         else if (hi > length) hi = length;
 272         if (lo > hi) lo = hi;
 273
 274         PyObject *list = PyList_New(hi - lo);
 275
 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);
 280
 281             PyList_SET_ITEM(list, i - lo, obj);
 282         }
 283
 284         return list;
 285     }
 286
 287     PyObject *get(Py_ssize_t n)
 288     {
 289         if (this$ != NULL)
 290         {
 291             if (n < 0)
 292                 n = length + n;
 293
 294             if (n >= 0 && n < length)
 295             {
 296                 jstring str = (jstring)
 297                     env->getObjectArrayElement((jobjectArray) this$, n);
 298                 PyObject *obj = env->fromJString(str, 1);
 299
 300                 return obj;
 301             }
 302         }
 303
 304         PyErr_SetString(PyExc_IndexError, "index out of range");
 305         return NULL;
 306     }
 307
 308     int set(Py_ssize_t n, PyObject *obj)
 309     {
 310         if (this$ != NULL)
 311         {
 312             if (n < 0)
 313                 n = length + n;
 314
 315             if (n >= 0 && n < length)
 316             {
 317                 jstring str = env->fromPyString(obj);
 318
 319                 if (PyErr_Occurred())
 320                     return -1;
 321
 322                 env->setObjectArrayElement((jobjectArray) this$, n, str);
 323                 return 0;
 324             }
 325         }
 326
 327         PyErr_SetString(PyExc_IndexError, "index out of range");
 328         return -1;
 329     }
 330
 331     PyObject *wrap() const;
 332 #endif
 333
 334     jstring operator[](Py_ssize_t n) {
 335         return (jstring) env->getObjectArrayElement((jobjectArray) this$, n);
 336     }
 337 };
 338
 339 template<> class JArray<jboolean> : public java::lang::Object {
 340   public:
 341     Py_ssize_t length;
 342
 343     class arrayElements {
 344     private:
 345         jboolean isCopy;
 346         jbooleanArray array;
 347         jboolean *elts;
 348     public:
 349         arrayElements(jbooleanArray array) {
 350             this->array = array;
 351             elts = env->get_vm_env()->GetBooleanArrayElements(array, &isCopy);
 352         }
 353         virtual ~arrayElements() {
 354             env->get_vm_env()->ReleaseBooleanArrayElements(array, elts, 0);
 355         }
 356         operator jboolean *() {
 357             return elts;
 358         }
 359     };
 360
 361     arrayElements elements() {
 362         return arrayElements((jbooleanArray) this$);
 363     }
 364
 365     JArray<jboolean>(jobject obj) : java::lang::Object(obj) {
 366         length = this$ ? env->getArrayLength((jarray) this$) : 0;
 367     }
 368
 369     JArray<jboolean>(const JArray& obj) : java::lang::Object(obj) {
 370         length = obj.length;
 371     }
 372
 373     JArray<jboolean>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewBooleanArray(n)) {
 374         length = env->getArrayLength((jarray) this$);
 375     }
 376
 377 #ifdef PYTHON
 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;
 382
 383         for (Py_ssize_t i = 0; i < length; i++) {
 384             PyObject *obj = PySequence_GetItem(sequence, i);
 385
 386             if (!obj)
 387                 break;
 388
 389             if (obj == Py_True || obj == Py_False)
 390             {
 391                 buf[i] = (jboolean) (obj == Py_True);
 392                 Py_DECREF(obj);
 393             }
 394             else
 395             {
 396                 PyErr_SetObject(PyExc_TypeError, obj);
 397                 Py_DECREF(obj);
 398                 break;
 399             }
 400         }
 401     }
 402
 403     PyObject *toSequence()
 404     {
 405         return toSequence(0, length);
 406     }
 407
 408     PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
 409     {
 410         if (this$ == NULL)
 411             Py_RETURN_NONE;
 412
 413         if (lo < 0) lo = length + lo;
 414         if (lo < 0) lo = 0;
 415         else if (lo > length) lo = length;
 416         if (hi < 0) hi = length + hi;
 417         if (hi < 0) hi = 0;
 418         else if (hi > length) hi = length;
 419         if (lo > hi) lo = hi;
 420
 421         PyObject *list = PyList_New(hi - lo);
 422         arrayElements elts = elements();
 423         jboolean *buf = (jboolean *) elts;
 424
 425         for (Py_ssize_t i = lo; i < hi; i++) {
 426             jboolean value = buf[i];
 427             PyObject *obj = value ? Py_True : Py_False;
 428
 429             Py_INCREF(obj);
 430             PyList_SET_ITEM(list, i - lo, obj);
 431         }
 432
 433         return list;
 434     }
 435
 436     PyObject *get(Py_ssize_t n)
 437     {
 438         if (this$ != NULL)
 439         {
 440             if (n < 0)
 441                 n = length + n;
 442
 443             if (n >= 0 && n < length)
 444                 Py_RETURN_BOOL(elements()[n]);
 445         }
 446
 447         PyErr_SetString(PyExc_IndexError, "index out of range");
 448         return NULL;
 449     }
 450
 451     int set(Py_ssize_t n, PyObject *obj)
 452     {
 453         if (this$ != NULL)
 454         {
 455             if (n < 0)
 456                 n = length + n;
 457
 458             if (n >= 0 && n < length)
 459             {
 460                 elements()[n] = (jboolean) PyObject_IsTrue(obj);
 461                 return 0;
 462             }
 463         }
 464
 465         PyErr_SetString(PyExc_IndexError, "index out of range");
 466         return -1;
 467     }
 468
 469     PyObject *wrap() const;
 470 #endif
 471
 472     jboolean operator[](Py_ssize_t n) {
 473         JNIEnv *vm_env = env->get_vm_env();
 474         jboolean isCopy = 0;
 475         jboolean *elts = (jboolean *)
 476             vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
 477         jboolean value = elts[n];
 478
 479         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
 480
 481         return value;
 482     }
 483 };
 484
 485 template<> class JArray<jbyte> : public java::lang::Object {
 486   public:
 487     Py_ssize_t length;
 488
 489     class arrayElements {
 490     private:
 491         jboolean isCopy;
 492         jbyteArray array;
 493         jbyte *elts;
 494     public:
 495         arrayElements(jbyteArray array) {
 496             this->array = array;
 497             elts = env->get_vm_env()->GetByteArrayElements(array, &isCopy);
 498         }
 499         virtual ~arrayElements() {
 500             env->get_vm_env()->ReleaseByteArrayElements(array, elts, 0);
 501         }
 502         operator jbyte *() {
 503             return elts;
 504         }
 505     };
 506
 507     arrayElements elements() {
 508         return arrayElements((jbyteArray) this$);
 509     }
 510
 511     JArray<jbyte>(jobject obj) : java::lang::Object(obj) {
 512         length = this$ ? env->getArrayLength((jarray) this$) : 0;
 513     }
 514
 515     JArray<jbyte>(const JArray& obj) : java::lang::Object(obj) {
 516         length = obj.length;
 517     }
 518
 519     JArray<jbyte>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewByteArray(n)) {
 520         length = env->getArrayLength((jarray) this$);
 521     }
 522
 523 #ifdef PYTHON
 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;
 528
 529         if (PyString_Check(sequence))
 530             memcpy(buf, PyString_AS_STRING(sequence), length);
 531         else
 532             for (Py_ssize_t i = 0; i < length; i++) {
 533                 PyObject *obj = PySequence_GetItem(sequence, i);
 534
 535                 if (!obj)
 536                     break;
 537
 538                 if (PyString_Check(obj) && (PyString_GET_SIZE(obj) == 1))
 539                 {
 540                     buf[i] = (jbyte) PyString_AS_STRING(obj)[0];
 541                     Py_DECREF(obj);
 542                 }
 543                 else if (PyInt_CheckExact(obj))
 544                 {
 545                     buf[i] = (jbyte) PyInt_AS_LONG(obj);
 546                     Py_DECREF(obj);
 547                 }
 548                 else
 549                 {
 550                     PyErr_SetObject(PyExc_TypeError, obj);
 551                     Py_DECREF(obj);
 552                     break;
 553                 }
 554             }
 555     }
 556
 557     char getType()
 558     {
 559         return 'Z';
 560     }
 561
 562     PyObject *toSequence()
 563     {
 564         return toSequence(0, length);
 565     }
 566
 567     PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
 568     {
 569         if (this$ == NULL)
 570             Py_RETURN_NONE;
 571
 572         if (lo < 0) lo = length + lo;
 573         if (lo < 0) lo = 0;
 574         else if (lo > length) lo = length;
 575         if (hi < 0) hi = length + hi;
 576         if (hi < 0) hi = 0;
 577         else if (hi > length) hi = length;
 578         if (lo > hi) lo = hi;
 579
 580         arrayElements elts = elements();
 581         jbyte *buf = (jbyte *) elts;
 582         PyObject *tuple = PyTuple_New(hi - lo);
 583
 584         for (Py_ssize_t i = 0; i < hi - lo; i++)
 585             PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(buf[lo + i]));
 586
 587         return tuple;
 588     }
 589
 590     PyObject *to_string_()
 591     {
 592         if (this$ == NULL)
 593             Py_RETURN_NONE;
 594
 595         arrayElements elts = elements();
 596         jbyte *buf = (jbyte *) elts;
 597
 598         return PyString_FromStringAndSize((char *) buf, length);
 599     }
 600
 601     PyObject *get(Py_ssize_t n)
 602     {
 603         if (this$ != NULL)
 604         {
 605             if (n < 0)
 606                 n = length + n;
 607
 608             if (n >= 0 && n < length)
 609             {
 610                 jbyte b = (*this)[n];
 611                 return PyInt_FromLong(b);
 612             }
 613         }
 614
 615         PyErr_SetString(PyExc_IndexError, "index out of range");
 616         return NULL;
 617     }
 618
 619     int set(Py_ssize_t n, PyObject *obj)
 620     {
 621         if (this$ != NULL)
 622         {
 623             if (n < 0)
 624                 n = length + n;
 625
 626             if (n >= 0 && n < length)
 627             {
 628                 if (!PyInt_CheckExact(obj))
 629                 {
 630                     PyErr_SetObject(PyExc_TypeError, obj);
 631                     return -1;
 632                 }
 633
 634                 elements()[n] = (jbyte) PyInt_AS_LONG(obj);
 635                 return 0;
 636             }
 637         }
 638
 639         PyErr_SetString(PyExc_IndexError, "index out of range");
 640         return -1;
 641     }
 642
 643     PyObject *wrap() const;
 644 #endif
 645
 646     jbyte operator[](Py_ssize_t n) {
 647         JNIEnv *vm_env = env->get_vm_env();
 648         jboolean isCopy = 0;
 649         jbyte *elts = (jbyte *)
 650             vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
 651         jbyte value = elts[n];
 652
 653         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
 654
 655         return value;
 656     }
 657 };
 658
 659 template<> class JArray<jchar> : public java::lang::Object {
 660   public:
 661     Py_ssize_t length;
 662
 663     class arrayElements {
 664     private:
 665         jboolean isCopy;
 666         jcharArray array;
 667         jchar *elts;
 668     public:
 669         arrayElements(jcharArray array) {
 670             this->array = array;
 671             elts = env->get_vm_env()->GetCharArrayElements(array, &isCopy);
 672         }
 673         virtual ~arrayElements() {
 674             env->get_vm_env()->ReleaseCharArrayElements(array, elts, 0);
 675         }
 676         operator jchar *() {
 677             return elts;
 678         }
 679     };
 680
 681     arrayElements elements() {
 682         return arrayElements((jcharArray) this$);
 683     }
 684
 685     JArray<jchar>(jobject obj) : java::lang::Object(obj) {
 686         length = this$ ? env->getArrayLength((jarray) this$) : 0;
 687     }
 688
 689     JArray<jchar>(const JArray& obj) : java::lang::Object(obj) {
 690         length = obj.length;
 691     }
 692
 693     JArray<jchar>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewCharArray(n)) {
 694         length = env->getArrayLength((jarray) this$);
 695     }
 696
 697 #ifdef PYTHON
 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;
 702
 703         if (PyUnicode_Check(sequence))
 704         {
 705             if (sizeof(Py_UNICODE) == sizeof(jchar))
 706                 memcpy(buf, PyUnicode_AS_UNICODE(sequence),
 707                        length * sizeof(jchar));
 708             else
 709             {
 710                 Py_UNICODE *pchars = PyUnicode_AS_UNICODE(sequence);
 711                 for (Py_ssize_t i = 0; i < length; i++)
 712                     buf[i] = (jchar) pchars[i];
 713             }
 714         }
 715         else
 716             for (Py_ssize_t i = 0; i < length; i++) {
 717                 PyObject *obj = PySequence_GetItem(sequence, i);
 718
 719                 if (!obj)
 720                     break;
 721
 722                 if (PyUnicode_Check(obj) && (PyUnicode_GET_SIZE(obj) == 1))
 723                 {
 724                     buf[i] = (jchar) PyUnicode_AS_UNICODE(obj)[0];
 725                     Py_DECREF(obj);
 726                 }
 727                 else
 728                 {
 729                     PyErr_SetObject(PyExc_TypeError, obj);
 730                     Py_DECREF(obj);
 731                     break;
 732                 }
 733             }
 734     }
 735
 736     PyObject *toSequence()
 737     {
 738         return toSequence(0, length);
 739     }
 740
 741     PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
 742     {
 743         if (this$ == NULL)
 744             Py_RETURN_NONE;
 745
 746         if (lo < 0) lo = length + lo;
 747         if (lo < 0) lo = 0;
 748         else if (lo > length) lo = length;
 749         if (hi < 0) hi = length + hi;
 750         if (hi < 0) hi = 0;
 751         else if (hi > length) hi = length;
 752         if (lo > hi) lo = hi;
 753
 754         arrayElements elts = elements();
 755         jchar *buf = (jchar *) elts;
 756
 757         if (sizeof(Py_UNICODE) == sizeof(jchar))
 758             return PyUnicode_FromUnicode((const Py_UNICODE *) buf + lo,
 759                                          hi - lo);
 760         else
 761         {
 762             PyObject *string = PyUnicode_FromUnicode(NULL, hi - lo);
 763             Py_UNICODE *pchars = PyUnicode_AS_UNICODE(string);
 764
 765             for (Py_ssize_t i = lo; i < hi; i++)
 766                 pchars[i - lo] = (Py_UNICODE) buf[i];
 767
 768             return string;
 769         }
 770     }
 771
 772     PyObject *get(Py_ssize_t n)
 773     {
 774         if (this$ != NULL)
 775         {
 776             if (n < 0)
 777                 n = length + n;
 778
 779             if (n >= 0 && n < length)
 780             {
 781                 jchar c = (*this)[n];
 782
 783                 if (sizeof(Py_UNICODE) == sizeof(jchar))
 784                     return PyUnicode_FromUnicode((const Py_UNICODE *) &c, 1);
 785                 else
 786                 {
 787                     PyObject *string = PyUnicode_FromUnicode(NULL, 1);
 788                     Py_UNICODE *pchars = PyUnicode_AS_UNICODE(string);
 789
 790                     pchars[0] = (Py_UNICODE) c;
 791
 792                     return string;
 793                 }
 794             }
 795         }
 796
 797         PyErr_SetString(PyExc_IndexError, "index out of range");
 798         return NULL;
 799     }
 800
 801     int set(Py_ssize_t n, PyObject *obj)
 802     {
 803         if (this$ != NULL)
 804         {
 805             if (n < 0)
 806                 n = length + n;
 807
 808             if (n >= 0 && n < length)
 809             {
 810                 if (!PyUnicode_Check(obj))
 811                 {
 812                     PyErr_SetObject(PyExc_TypeError, obj);
 813                     return -1;
 814                 }
 815                 if (PyUnicode_GET_SIZE(obj) != 1)
 816                 {
 817                     PyErr_SetObject(PyExc_ValueError, obj);
 818                     return -1;
 819                 }
 820
 821                 elements()[n] = (jchar) PyUnicode_AS_UNICODE(obj)[0];
 822                 return 0;
 823             }
 824         }
 825
 826         PyErr_SetString(PyExc_IndexError, "index out of range");
 827         return -1;
 828     }
 829
 830     PyObject *wrap() const;
 831 #endif
 832
 833     jchar operator[](Py_ssize_t n) {
 834         JNIEnv *vm_env = env->get_vm_env();
 835         jboolean isCopy = 0;
 836         jchar *elts = (jchar *)
 837             vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
 838         jchar value = elts[n];
 839
 840         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
 841
 842         return value;
 843     }
 844 };
 845
 846 template<> class JArray<jdouble> : public java::lang::Object {
 847   public:
 848     Py_ssize_t length;
 849
 850     class arrayElements {
 851     private:
 852         jboolean isCopy;
 853         jdoubleArray array;
 854         jdouble *elts;
 855     public:
 856         arrayElements(jdoubleArray array) {
 857             this->array = array;
 858             elts = env->get_vm_env()->GetDoubleArrayElements(array, &isCopy);
 859         }
 860         virtual ~arrayElements() {
 861             env->get_vm_env()->ReleaseDoubleArrayElements(array, elts, 0);
 862         }
 863         operator jdouble *() {
 864             return elts;
 865         }
 866     };
 867
 868     arrayElements elements() {
 869         return arrayElements((jdoubleArray) this$);
 870     }
 871
 872     JArray<jdouble>(jobject obj) : java::lang::Object(obj) {
 873         length = this$ ? env->getArrayLength((jarray) this$) : 0;
 874     }
 875
 876     JArray<jdouble>(const JArray& obj) : java::lang::Object(obj) {
 877         length = obj.length;
 878     }
 879
 880     JArray<jdouble>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewDoubleArray(n)) {
 881         length = env->getArrayLength((jarray) this$);
 882     }
 883
 884 #ifdef PYTHON
 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;
 889
 890         for (Py_ssize_t i = 0; i < length; i++) {
 891             PyObject *obj = PySequence_GetItem(sequence, i);
 892
 893             if (!obj)
 894                 break;
 895
 896             if (PyFloat_Check(obj))
 897             {
 898                 buf[i] = (jdouble) PyFloat_AS_DOUBLE(obj);
 899                 Py_DECREF(obj);
 900             }
 901             else
 902             {
 903                 PyErr_SetObject(PyExc_TypeError, obj);
 904                 Py_DECREF(obj);
 905                 break;
 906             }
 907         }
 908     }
 909
 910     PyObject *toSequence()
 911     {
 912         return toSequence(0, length);
 913     }
 914
 915     PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
 916     {
 917         if (this$ == NULL)
 918             Py_RETURN_NONE;
 919
 920         if (lo < 0) lo = length + lo;
 921         if (lo < 0) lo = 0;
 922         else if (lo > length) lo = length;
 923         if (hi < 0) hi = length + hi;
 924         if (hi < 0) hi = 0;
 925         else if (hi > length) hi = length;
 926         if (lo > hi) lo = hi;
 927
 928         PyObject *list = PyList_New(hi - lo);
 929         arrayElements elts = elements();
 930         jdouble *buf = (jdouble *) elts;
 931
 932         for (Py_ssize_t i = lo; i < hi; i++)
 933             PyList_SET_ITEM(list, i - lo, PyFloat_FromDouble((double) buf[i]));
 934
 935         return list;
 936     }
 937
 938     PyObject *get(Py_ssize_t n)
 939     {
 940         if (this$ != NULL)
 941         {
 942             if (n < 0)
 943                 n = length + n;
 944
 945             if (n >= 0 && n < length)
 946                 return PyFloat_FromDouble((double) (*this)[n]);
 947         }
 948
 949         PyErr_SetString(PyExc_IndexError, "index out of range");
 950         return NULL;
 951     }
 952
 953     int set(Py_ssize_t n, PyObject *obj)
 954     {
 955         if (this$ != NULL)
 956         {
 957             if (n < 0)
 958                 n = length + n;
 959
 960             if (n >= 0 && n < length)
 961             {
 962                 if (!PyFloat_Check(obj))
 963                 {
 964                     PyErr_SetObject(PyExc_TypeError, obj);
 965                     return -1;
 966                 }
 967
 968                 elements()[n] = (jdouble) PyFloat_AS_DOUBLE(obj);
 969                 return 0;
 970             }
 971         }
 972
 973         PyErr_SetString(PyExc_IndexError, "index out of range");
 974         return -1;
 975     }
 976
 977     PyObject *wrap() const;
 978 #endif
 979
 980     jdouble operator[](Py_ssize_t n) {
 981         JNIEnv *vm_env = env->get_vm_env();
 982         jboolean isCopy = 0;
 983         jdouble *elts = (jdouble *)
 984             vm_env->GetPrimitiveArrayCritical((jarray) this$, &isCopy);
 985         jdouble value = elts[n];
 986
 987         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
 988
 989         return value;
 990     }
 991 };
 992
 993 template<> class JArray<jfloat> : public java::lang::Object {
 994   public:
 995     Py_ssize_t length;
 996
 997     class arrayElements {
 998     private:
 999         jboolean isCopy;
1000         jfloatArray array;
1001         jfloat *elts;
1002     public:
1003         arrayElements(jfloatArray array) {
1004             this->array = array;
1005             elts = env->get_vm_env()->GetFloatArrayElements(array, &isCopy);
1006         }
1007         virtual ~arrayElements() {
1008             env->get_vm_env()->ReleaseFloatArrayElements(array, elts, 0);
1009         }
1010         operator jfloat *() {
1011             return elts;
1012         }
1013     };
1014
1015     arrayElements elements() {
1016         return arrayElements((jfloatArray) this$);
1017     }
1018
1019     JArray<jfloat>(jobject obj) : java::lang::Object(obj) {
1020         length = this$ ? env->getArrayLength((jarray) this$) : 0;
1021     }
1022
1023     JArray<jfloat>(const JArray& obj) : java::lang::Object(obj) {
1024         length = obj.length;
1025     }
1026
1027     JArray<jfloat>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewFloatArray(n)) {
1028         length = env->getArrayLength((jarray) this$);
1029     }
1030
1031 #ifdef PYTHON
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;
1036
1037         for (Py_ssize_t i = 0; i < length; i++) {
1038             PyObject *obj = PySequence_GetItem(sequence, i);
1039
1040             if (!obj)
1041                 break;
1042
1043             if (PyFloat_Check(obj))
1044             {
1045                 buf[i] = (jfloat) PyFloat_AS_DOUBLE(obj);
1046                 Py_DECREF(obj);
1047             }
1048             else
1049             {
1050                 PyErr_SetObject(PyExc_TypeError, obj);
1051                 Py_DECREF(obj);
1052                 break;
1053             }
1054         }
1055     }
1056
1057     PyObject *toSequence()
1058     {
1059         return toSequence(0, length);
1060     }
1061
1062     PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
1063     {
1064         if (this$ == NULL)
1065             Py_RETURN_NONE;
1066
1067         if (lo < 0) lo = length + lo;
1068         if (lo < 0) lo = 0;
1069         else if (lo > length) lo = length;
1070         if (hi < 0) hi = length + hi;
1071         if (hi < 0) hi = 0;
1072         else if (hi > length) hi = length;
1073         if (lo > hi) lo = hi;
1074
1075         PyObject *list = PyList_New(hi - lo);
1076         arrayElements elts = elements();
1077         jfloat *buf = (jfloat *) elts;
1078
1079         for (Py_ssize_t i = lo; i < hi; i++)
1080             PyList_SET_ITEM(list, i - lo, PyFloat_FromDouble((double) buf[i]));
1081
1082         return list;
1083     }
1084
1085     PyObject *get(Py_ssize_t n)
1086     {
1087         if (this$ != NULL)
1088         {
1089             if (n < 0)
1090                 n = length + n;
1091
1092             if (n >= 0 && n < length)
1093                 return PyFloat_FromDouble((double) (*this)[n]);
1094         }
1095
1096         PyErr_SetString(PyExc_IndexError, "index out of range");
1097         return NULL;
1098     }
1099
1100     int set(Py_ssize_t n, PyObject *obj)
1101     {
1102         if (this$ != NULL)
1103         {
1104             if (n < 0)
1105                 n = length + n;
1106
1107             if (n >= 0 && n < length)
1108             {
1109                 if (!PyFloat_Check(obj))
1110                 {
1111                     PyErr_SetObject(PyExc_TypeError, obj);
1112                     return -1;
1113                 }
1114
1115                 elements()[n] = (jfloat) PyFloat_AS_DOUBLE(obj);
1116                 return 0;
1117             }
1118         }
1119
1120         PyErr_SetString(PyExc_IndexError, "index out of range");
1121         return -1;
1122     }
1123
1124     PyObject *wrap() const;
1125 #endif
1126
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];
1133
1134         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
1135
1136         return value;
1137     }
1138 };
1139
1140 template<> class JArray<jint> : public java::lang::Object {
1141   public:
1142     Py_ssize_t length;
1143
1144     class arrayElements {
1145     private:
1146         jboolean isCopy;
1147         jintArray array;
1148         jint *elts;
1149     public:
1150         arrayElements(jintArray array) {
1151             this->array = array;
1152             elts = env->get_vm_env()->GetIntArrayElements(array, &isCopy);
1153         }
1154         virtual ~arrayElements() {
1155             env->get_vm_env()->ReleaseIntArrayElements(array, elts, 0);
1156         }
1157         operator jint *() {
1158             return elts;
1159         }
1160     };
1161
1162     arrayElements elements() {
1163         return arrayElements((jintArray) this$);
1164     }
1165
1166     JArray<jint>(jobject obj) : java::lang::Object(obj) {
1167         length = this$ ? env->getArrayLength((jarray) this$) : 0;
1168     }
1169
1170     JArray<jint>(const JArray& obj) : java::lang::Object(obj) {
1171         length = obj.length;
1172     }
1173
1174     JArray<jint>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewIntArray(n)) {
1175         length = env->getArrayLength((jarray) this$);
1176     }
1177
1178 #ifdef PYTHON
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;
1183
1184         for (Py_ssize_t i = 0; i < length; i++) {
1185             PyObject *obj = PySequence_GetItem(sequence, i);
1186
1187             if (!obj)
1188                 break;
1189
1190             if (PyInt_Check(obj))
1191             {
1192                 buf[i] = (jint) PyInt_AS_LONG(obj);
1193                 Py_DECREF(obj);
1194             }
1195             else
1196             {
1197                 PyErr_SetObject(PyExc_TypeError, obj);
1198                 Py_DECREF(obj);
1199                 break;
1200             }
1201         }
1202     }
1203
1204     PyObject *toSequence()
1205     {
1206         return toSequence(0, length);
1207     }
1208
1209     PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
1210     {
1211         if (this$ == NULL)
1212             Py_RETURN_NONE;
1213
1214         if (lo < 0) lo = length + lo;
1215         if (lo < 0) lo = 0;
1216         else if (lo > length) lo = length;
1217         if (hi < 0) hi = length + hi;
1218         if (hi < 0) hi = 0;
1219         else if (hi > length) hi = length;
1220         if (lo > hi) lo = hi;
1221
1222         PyObject *list = PyList_New(hi - lo);
1223         arrayElements elts = elements();
1224         jint *buf = (jint *) elts;
1225
1226         for (Py_ssize_t i = lo; i < hi; i++)
1227             PyList_SET_ITEM(list, i - lo, PyInt_FromLong(buf[i]));
1228
1229         return list;
1230     }
1231
1232     PyObject *get(Py_ssize_t n)
1233     {
1234         if (this$ != NULL)
1235         {
1236             if (n < 0)
1237                 n = length + n;
1238
1239             if (n >= 0 && n < length)
1240                 return PyInt_FromLong((*this)[n]);
1241         }
1242
1243         PyErr_SetString(PyExc_IndexError, "index out of range");
1244         return NULL;
1245     }
1246
1247     int set(Py_ssize_t n, PyObject *obj)
1248     {
1249         if (this$ != NULL)
1250         {
1251             if (n < 0)
1252                 n = length + n;
1253
1254             if (n >= 0 && n < length)
1255             {
1256                 if (!PyInt_Check(obj))
1257                 {
1258                     PyErr_SetObject(PyExc_TypeError, obj);
1259                     return -1;
1260                 }
1261
1262                 elements()[n] = (jint) PyInt_AS_LONG(obj);
1263                 return 0;
1264             }
1265         }
1266
1267         PyErr_SetString(PyExc_IndexError, "index out of range");
1268         return -1;
1269     }
1270
1271     PyObject *wrap() const;
1272 #endif
1273
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];
1280
1281         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
1282
1283         return value;
1284     }
1285 };
1286
1287 template<> class JArray<jlong> : public java::lang::Object {
1288   public:
1289     Py_ssize_t length;
1290
1291     class arrayElements {
1292     private:
1293         jboolean isCopy;
1294         jlongArray array;
1295         jlong *elts;
1296     public:
1297         arrayElements(jlongArray array) {
1298             this->array = array;
1299             elts = env->get_vm_env()->GetLongArrayElements(array, &isCopy);
1300         }
1301         virtual ~arrayElements() {
1302             env->get_vm_env()->ReleaseLongArrayElements(array, elts, 0);
1303         }
1304         operator jlong *() {
1305             return elts;
1306         }
1307     };
1308
1309     arrayElements elements() {
1310         return arrayElements((jlongArray) this$);
1311     }
1312
1313     JArray<jlong>(jobject obj) : java::lang::Object(obj) {
1314         length = this$ ? env->getArrayLength((jarray) this$) : 0;
1315     }
1316
1317     JArray<jlong>(const JArray& obj) : java::lang::Object(obj) {
1318         length = obj.length;
1319     }
1320
1321     JArray<jlong>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewLongArray(n)) {
1322         length = env->getArrayLength((jarray) this$);
1323     }
1324
1325 #ifdef PYTHON
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;
1330
1331         for (Py_ssize_t i = 0; i < length; i++) {
1332             PyObject *obj = PySequence_GetItem(sequence, i);
1333
1334             if (!obj)
1335                 break;
1336
1337             if (PyLong_Check(obj))
1338             {
1339                 buf[i] = (jlong) PyLong_AsLongLong(obj);
1340                 Py_DECREF(obj);
1341             }
1342             else
1343             {
1344                 PyErr_SetObject(PyExc_TypeError, obj);
1345                 Py_DECREF(obj);
1346                 break;
1347             }
1348         }
1349     }
1350
1351     PyObject *toSequence()
1352     {
1353         return toSequence(0, length);
1354     }
1355
1356     PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
1357     {
1358         if (this$ == NULL)
1359             Py_RETURN_NONE;
1360
1361         if (lo < 0) lo = length + lo;
1362         if (lo < 0) lo = 0;
1363         else if (lo > length) lo = length;
1364         if (hi < 0) hi = length + hi;
1365         if (hi < 0) hi = 0;
1366         else if (hi > length) hi = length;
1367         if (lo > hi) lo = hi;
1368
1369         PyObject *list = PyList_New(hi - lo);
1370         arrayElements elts = elements();
1371         jlong *buf = (jlong *) elts;
1372
1373         for (Py_ssize_t i = lo; i < hi; i++)
1374             PyList_SET_ITEM(list, i - lo, PyLong_FromLongLong((long long) buf[i]));
1375
1376         return list;
1377     }
1378
1379     PyObject *get(Py_ssize_t n)
1380     {
1381         if (this$ != NULL)
1382         {
1383             if (n < 0)
1384                 n = length + n;
1385
1386             if (n >= 0 && n < length)
1387                 return PyLong_FromLongLong((long long) (*this)[n]);
1388         }
1389
1390         PyErr_SetString(PyExc_IndexError, "index out of range");
1391         return NULL;
1392     }
1393
1394     int set(Py_ssize_t n, PyObject *obj)
1395     {
1396         if (this$ != NULL)
1397         {
1398             if (n < 0)
1399                 n = length + n;
1400
1401             if (n >= 0 && n < length)
1402             {
1403                 if (!PyLong_Check(obj))
1404                 {
1405                     PyErr_SetObject(PyExc_TypeError, obj);
1406                     return -1;
1407                 }
1408
1409                 elements()[n] = (jlong) PyLong_AsLongLong(obj);
1410                 return 0;
1411             }
1412         }
1413
1414         PyErr_SetString(PyExc_IndexError, "index out of range");
1415         return -1;
1416     }
1417
1418     PyObject *wrap() const;
1419 #endif
1420
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];
1427
1428         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
1429
1430         return value;
1431     }
1432 };
1433
1434 template<> class JArray<jshort> : public java::lang::Object {
1435   public:
1436     Py_ssize_t length;
1437
1438     class arrayElements {
1439     private:
1440         jboolean isCopy;
1441         jshortArray array;
1442         jshort *elts;
1443     public:
1444         arrayElements(jshortArray array) {
1445             this->array = array;
1446             elts = env->get_vm_env()->GetShortArrayElements(array, &isCopy);
1447         }
1448         virtual ~arrayElements() {
1449             env->get_vm_env()->ReleaseShortArrayElements(array, elts, 0);
1450         }
1451         operator jshort *() {
1452             return elts;
1453         }
1454     };
1455
1456     arrayElements elements() {
1457         return arrayElements((jshortArray) this$);
1458     }
1459
1460     JArray<jshort>(jobject obj) : java::lang::Object(obj) {
1461         length = this$ ? env->getArrayLength((jarray) this$) : 0;
1462     }
1463
1464     JArray<jshort>(const JArray& obj) : java::lang::Object(obj) {
1465         length = obj.length;
1466     }
1467
1468     JArray<jshort>(Py_ssize_t n) : java::lang::Object(env->get_vm_env()->NewShortArray(n)) {
1469         length = env->getArrayLength((jarray) this$);
1470     }
1471
1472 #ifdef PYTHON
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;
1477
1478         for (Py_ssize_t i = 0; i < length; i++) {
1479             PyObject *obj = PySequence_GetItem(sequence, i);
1480
1481             if (!obj)
1482                 break;
1483
1484             if (PyInt_Check(obj))
1485             {
1486                 buf[i] = (jshort) PyInt_AS_LONG(obj);
1487                 Py_DECREF(obj);
1488             }
1489             else
1490             {
1491                 PyErr_SetObject(PyExc_TypeError, obj);
1492                 Py_DECREF(obj);
1493                 break;
1494             }
1495         }
1496     }
1497
1498     PyObject *toSequence()
1499     {
1500         return toSequence(0, length);
1501     }
1502
1503     PyObject *toSequence(Py_ssize_t lo, Py_ssize_t hi)
1504     {
1505         if (this$ == NULL)
1506             Py_RETURN_NONE;
1507
1508         if (lo < 0) lo = length + lo;
1509         if (lo < 0) lo = 0;
1510         else if (lo > length) lo = length;
1511         if (hi < 0) hi = length + hi;
1512         if (hi < 0) hi = 0;
1513         else if (hi > length) hi = length;
1514         if (lo > hi) lo = hi;
1515
1516         PyObject *list = PyList_New(hi - lo);
1517         arrayElements elts = elements();
1518         jshort *buf = (jshort *) elts;
1519
1520         for (Py_ssize_t i = lo; i < hi; i++)
1521             PyList_SET_ITEM(list, i - lo, PyInt_FromLong(buf[i]));
1522
1523         return list;
1524     }
1525
1526     PyObject *get(Py_ssize_t n)
1527     {
1528         if (this$ != NULL)
1529         {
1530             if (n < 0)
1531                 n = length + n;
1532
1533             if (n >= 0 && n < length)
1534                 return PyInt_FromLong((long) (*this)[n]);
1535         }
1536
1537         PyErr_SetString(PyExc_IndexError, "index out of range");
1538         return NULL;
1539     }
1540
1541     int set(Py_ssize_t n, PyObject *obj)
1542     {
1543         if (this$ != NULL)
1544         {
1545             if (n < 0)
1546                 n = length + n;
1547
1548             if (n >= 0 && n < length)
1549             {
1550                 if (!PyInt_Check(obj))
1551                 {
1552                     PyErr_SetObject(PyExc_TypeError, obj);
1553                     return -1;
1554                 }
1555
1556                 elements()[n] = (jshort) PyInt_AS_LONG(obj);
1557                 return 0;
1558             }
1559         }
1560
1561         PyErr_SetString(PyExc_IndexError, "index out of range");
1562         return -1;
1563     }
1564
1565     PyObject *wrap() const;
1566 #endif
1567
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];
1574
1575         vm_env->ReleasePrimitiveArrayCritical((jarray) this$, elts, 0);
1576
1577         return value;
1578     }
1579 };
1580
1581 #ifdef PYTHON
1582
1583 template<typename T> class t_JArray {
1584 public:
1585     PyObject_HEAD
1586     JArray<T> array;
1587
1588     static PyObject *wrap_Object(const JArray<T>& array)
1589     {
1590         if (!!array)
1591             return array.wrap();
1592
1593         Py_RETURN_NONE;
1594     }
1595 };
1596
1597 #endif
1598
1599 #endif /* _JArray_H */