scilab/modules/external_objects_java/src/cpp/ScilabJavaEnvironmentWrapper.hxx

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2012 - Scilab Enterprises - Calixte DENIZET
   4  *
   5  * This file must be used under the terms of the CeCILL.
   6  * This source file is licensed as described in the file COPYING, which
   7  * you should have received as part of this distribution.  The terms
   8  * are also available at
   9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  10  *
  11  */
  12
  13 #ifndef __SCILABPYTHONENVIRONMENTWRAPPER_HXX__
  14 #define __SCILABPYTHONENVIRONMENTWRAPPER_HXX__
  15
  16 #include "ExternalObjects.h"
  17 #include "JavaOptionsHelper.hxx"
  18
  19 #include "ScilabAbstractEnvironmentWrapper.hxx"
  20 #include "ScilabJavaException.hxx"
  21
  22 #include "ScilabJavaObject.hxx"
  23
  24 #include "GiwsException.hxx"
  25
  26 extern "C" {
  27 #include "getScilabJavaVM.h"
  28 }
  29
  30 #define SCILABJAVAOBJECT "org/scilab/modules/external_objects_java/ScilabJavaObject"
  31
  32 using namespace org_modules_external_objects;
  33
  34 namespace org_scilab_modules_external_objects_java
  35 {
  36
  37 typedef struct
  38 {
  39     double re;
  40     double im;
  41 } complex;
  42
  43 class ScilabJavaEnvironmentWrapper : public ScilabAbstractEnvironmentWrapper
  44 {
  45
  46     //    JavaVariablesScope & scope;
  47     JavaOptionsHelper & helper;
  48     jclass ScilabJavaObjectClass_;
  49
  50     jmethodID unwrapStringID_;
  51     jmethodID unwrapRowStringID_;
  52     jmethodID unwrapMatStringID_;
  53
  54     jmethodID unwrapBooleanID_;
  55     jmethodID unwrapRowBooleanID_;
  56     jmethodID unwrapMatBooleanID_;
  57
  58     jmethodID unwrapByteID_;
  59     jmethodID unwrapRowByteID_;
  60     jmethodID unwrapMatByteID_;
  61
  62     jmethodID unwrapShortID_;
  63     jmethodID unwrapRowShortID_;
  64     jmethodID unwrapMatShortID_;
  65
  66     jmethodID unwrapIntID_;
  67     jmethodID unwrapRowIntID_;
  68     jmethodID unwrapMatIntID_;
  69
  70     jmethodID unwrapLongID_;
  71     jmethodID unwrapRowLongID_;
  72     jmethodID unwrapMatLongID_;
  73
  74     jmethodID unwrapDoubleID_;
  75     jmethodID unwrapRowDoubleID_;
  76     jmethodID unwrapMatDoubleID_;
  77
  78     jmethodID unwrapFloatID_;
  79     jmethodID unwrapRowFloatID_;
  80     jmethodID unwrapMatFloatID_;
  81
  82     jmethodID unwrapCharID_;
  83     jmethodID unwrapRowCharID_;
  84     jmethodID unwrapMatCharID_;
  85
  86     jmethodID wrapAsDirectByteBufferID_;
  87     jmethodID wrapAsDirectDoubleBufferID_;
  88     jmethodID wrapAsDirectIntBufferID_;
  89     jmethodID wrapAsDirectCharBufferID_;
  90     jmethodID wrapAsDirectFloatBufferID_;
  91     jmethodID wrapAsDirectLongBufferID_;
  92     jmethodID wrapAsDirectShortBufferID_;
  93
  94 public:
  95
  96     ScilabJavaEnvironmentWrapper(JavaOptionsHelper & _helper) : helper(_helper)
  97     {
  98         JavaVM * vm = getScilabJavaVM();
  99         JNIEnv * curEnv = NULL;
 100
 101         vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 102         ScilabJavaObjectClass_ = curEnv->FindClass(SCILABJAVAOBJECT);
 103
 104         unwrapStringID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapString", "(I)Ljava/lang/String;");
 105         unwrapRowStringID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapRowString", "(I)[Ljava/lang/String;");
 106         unwrapMatStringID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapMatString", "(I)[[Ljava/lang/String;");
 107
 108         unwrapBooleanID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapBoolean", "(I)Z");
 109         unwrapRowBooleanID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapRowBoolean", "(I)[Z");
 110         unwrapMatBooleanID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapMatBoolean", "(I)[[Z");
 111
 112         unwrapByteID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapByte", "(I)B");
 113         unwrapRowByteID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapRowByte", "(I)Ljava/lang/Object;");
 114         unwrapMatByteID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapMatByte", "(I)[[B");
 115
 116         unwrapShortID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapShort", "(I)S");
 117         unwrapRowShortID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapRowShort", "(I)Ljava/lang/Object;");
 118         unwrapMatShortID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapMatShort", "(I)[[S");
 119
 120         unwrapIntID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapInt", "(I)I");
 121         unwrapRowIntID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapRowInt", "(I)Ljava/lang/Object;");
 122         unwrapMatIntID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapMatInt", "(I)[[I");
 123
 124         unwrapLongID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapLong", "(I)J");
 125         unwrapRowLongID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapRowLong", "(I)Ljava/lang/Object;");
 126         unwrapMatLongID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapMatLong", "(I)[[J");
 127
 128         unwrapDoubleID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapDouble", "(I)D");
 129         unwrapRowDoubleID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapRowDouble", "(I)Ljava/lang/Object;");
 130         unwrapMatDoubleID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapMatDouble", "(I)[[D");
 131
 132         unwrapFloatID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapFloat", "(I)F");
 133         unwrapRowFloatID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapRowFloat", "(I)Ljava/lang/Object;");
 134         unwrapMatFloatID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapMatFloat", "(I)[[F");
 135
 136         unwrapCharID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapChar", "(I)C");
 137         unwrapRowCharID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapRowChar", "(I)Ljava/lang/Object;");
 138         unwrapMatCharID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "unwrapMatChar", "(I)[[C");
 139
 140         wrapAsDirectByteBufferID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "wrapAsDirectByteBuffer", "(Ljava/nio/ByteBuffer;)I");
 141         wrapAsDirectDoubleBufferID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "wrapAsDirectDoubleBuffer", "(Ljava/nio/ByteBuffer;)I");
 142         wrapAsDirectIntBufferID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "wrapAsDirectIntBuffer", "(Ljava/nio/ByteBuffer;)I");
 143         wrapAsDirectCharBufferID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "wrapAsDirectCharBuffer", "(Ljava/nio/ByteBuffer;)I");
 144         wrapAsDirectFloatBufferID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "wrapAsDirectFloatBuffer", "(Ljava/nio/ByteBuffer;)I");
 145         wrapAsDirectLongBufferID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "wrapAsDirectLongBuffer", "(Ljava/nio/ByteBuffer;)I");
 146         wrapAsDirectShortBufferID_ = curEnv->GetStaticMethodID(ScilabJavaObjectClass_, "wrapAsDirectShortBuffer", "(Ljava/nio/ByteBuffer;)I");
 147     }
 148
 149     ~ScilabJavaEnvironmentWrapper() { }
 150
 151     VariableType isunwrappable(int id) const;
 152
 153     int wrap(double * x, const bool isRef) const;
 154
 155     int wrap(double * x, int xSize, const bool isRef) const;
 156
 157     int wrap(double * x, int xSize, int xSizeCol, const bool isRef) const;
 158
 159     int wrap(double * re, double * im, const bool isRef) const;
 160
 161     int wrap(double * re, double * im, int xSize, const bool isRef) const;
 162
 163     int wrap(double * re, double * im, int xSize, int xSizeCol, const bool isRef) const;
 164
 165     int wrap(char * x, const bool isRef) const;
 166
 167     int wrap(char * x, int xSize, const bool isRef) const;
 168
 169     int wrap(char * x, int xSize, int xSizeCol, const bool isRef) const;
 170
 171
 172     int wrap(unsigned char * x, const bool isRef) const;
 173
 174     int wrap(unsigned char * x, int xSize, const bool isRef) const;
 175
 176     int wrap(unsigned char * x, int xSize, int xSizeCol, const bool isRef) const;
 177
 178
 179     int wrap(short * x, const bool isRef) const;
 180
 181     int wrap(short * x, int xSize, const bool isRef) const;
 182
 183     int wrap(short * x, int xSize, int xSizeCol, const bool isRef) const;
 184
 185
 186     int wrap(unsigned short * x, const bool isRef) const;
 187
 188     int wrap(unsigned short * x, int xSize, const bool isRef) const;
 189
 190     int wrap(unsigned short * x, int xSize, int xSizeCol, const bool isRef) const;
 191
 192
 193     int wrap(int * x, const bool isRef) const;
 194
 195     int wrap(int * x, int xSize, const bool isRef) const;
 196
 197     int wrap(int * x, int xSize, int xSizeCol, const bool isRef) const;
 198
 199
 200     int wrap(unsigned int * x, const bool isRef) const;
 201
 202     int wrap(unsigned int * x, int xSize, const bool isRef) const;
 203
 204     int wrap(unsigned int * x, int xSize, int xSizeCol, const bool isRef) const;
 205
 206 #ifdef __SCILAB_INT64__
 207
 208     int wrap(long long * x, const bool isRef) const;
 209
 210     int wrap(long long * x, int xSize, const bool isRef) const;
 211
 212     int wrap(long long * x, int xSize, int xSizeCol, const bool isRef) const;
 213
 214
 215     int wrap(unsigned long long * x, const bool isRef) const;
 216
 217     int wrap(unsigned long long * x, int xSize, const bool isRef) const;
 218
 219     int wrap(unsigned long long * x, int xSize, int xSizeCol, const bool isRef) const;
 220
 221 #endif
 222
 223     int wrap(char ** x, const bool isRef) const;
 224
 225     int wrap(char ** x, int xSize, const bool isRef) const;
 226
 227     int wrap(char ** x, int xSize, int xSizeCol, const bool isRef) const;
 228
 229
 230     int wrapFloat(double * x, const bool isRef) const;
 231
 232     int wrapFloat(double * x, int xSize, const bool isRef) const;
 233
 234     int wrapFloat(double * x, int xSize, int xSizeCol, const bool isRef) const;
 235
 236
 237     int wrapBool(int * x, const bool isRef) const;
 238
 239     int wrapBool(int * x, int xSize, const bool isRef) const;
 240
 241     int wrapBool(int * x, int xSize, int xSizeCol, const bool isRef) const;
 242
 243     /**
 244      * Unwrap a the external object with the given id into a double
 245      * @param id the value to wrap
 246      * @param pos the position in the Scilab stack where to put the result
 247      */
 248     void unwrapdouble(int id, const ScilabDoubleStackAllocator & allocator) const;
 249
 250     void unwraprowdouble(int id, const ScilabDoubleStackAllocator & allocator) const;
 251
 252     void unwrapmatdouble(int id, const ScilabDoubleStackAllocator & allocator) const;
 253
 254     void unwrapcomplex(int id, const ScilabComplexStackAllocator & allocator) const;
 255
 256     void unwraprowcomplex(int id, const ScilabComplexStackAllocator & allocator) const;
 257
 258     void unwrapmatcomplex(int id, const ScilabComplexStackAllocator & allocator) const;
 259
 260     void unwrapchar(int id, const ScilabCharStackAllocator & allocator) const;
 261
 262     void unwraprowchar(int id, const ScilabCharStackAllocator & allocator) const;
 263
 264     void unwrapmatchar(int id, const ScilabCharStackAllocator & allocator) const;
 265
 266     void unwrapuchar(int id, const ScilabUCharStackAllocator & allocator) const;
 267
 268     void unwraprowuchar(int id, const ScilabUCharStackAllocator & allocator) const;
 269
 270     void unwrapmatuchar(int id, const ScilabUCharStackAllocator & allocator) const ;
 271
 272     void unwrapshort(int id, const ScilabShortStackAllocator & allocator) const;
 273
 274     void unwraprowshort(int id, const ScilabShortStackAllocator  & allocator) const;
 275
 276     void unwrapmatshort(int id, const ScilabShortStackAllocator & allocator) const;
 277
 278     void unwrapushort(int id, const ScilabUShortStackAllocator & allocator) const;
 279
 280     void unwraprowushort(int id, const ScilabUShortStackAllocator & allocator) const;
 281
 282     void unwrapmatushort(int id, const ScilabUShortStackAllocator & allocator) const;
 283
 284     void unwrapint(int id, const ScilabIntStackAllocator & allocator) const;
 285
 286     void unwraprowint(int id, const ScilabIntStackAllocator & allocator) const;
 287
 288     void unwrapmatint(int id, const ScilabIntStackAllocator & allocator) const;
 289
 290     void unwrapuint(int id, const ScilabUIntStackAllocator & allocator) const;
 291
 292     void unwraprowuint(int id, const ScilabUIntStackAllocator & allocator) const;
 293
 294     void unwrapmatuint(int id, const ScilabUIntStackAllocator & allocator) const;
 295
 296     void unwraplong(int id, const ScilabLongStackAllocator & allocator) const;
 297
 298     void unwraprowlong(int id, const ScilabLongStackAllocator & allocator) const;
 299
 300     void unwrapmatlong(int id, const ScilabLongStackAllocator & allocator) const;
 301
 302     void unwrapulong(int id, const ScilabULongStackAllocator & allocator) const;
 303
 304     void unwraprowulong(int id, const ScilabULongStackAllocator & allocator) const;
 305
 306     void unwrapmatulong(int id, const ScilabULongStackAllocator & allocator) const;
 307
 308     void unwrapboolean(int id, const ScilabBooleanStackAllocator & allocator) const;
 309
 310     void unwraprowboolean(int id, const ScilabBooleanStackAllocator & allocator) const;
 311
 312     void unwrapmatboolean(int id, const ScilabBooleanStackAllocator & allocator) const;
 313
 314     void unwrapstring(int id, const ScilabStringStackAllocator & allocator) const;
 315
 316     void unwraprowstring(int id, const ScilabStringStackAllocator & allocator) const;
 317
 318     void unwrapmatstring(int id, const ScilabStringStackAllocator & allocator) const;
 319
 320     void unwrapfloat(int id, const ScilabFloatStackAllocator & allocator) const;
 321
 322     void unwraprowfloat(int id, const ScilabFloatStackAllocator & allocator) const;
 323
 324     void unwrapmatfloat(int id, const ScilabFloatStackAllocator & allocator) const;
 325
 326 private:
 327
 328     template<typename T>
 329     inline int wrap(JavaVM * vm, T * x) const
 330     {
 331         return ScilabJavaObject::wrap(vm, *x);
 332     }
 333
 334     template<typename T, typename U>
 335     inline int wrap(JavaVM * vm, T * x) const
 336     {
 337         return ScilabJavaObject::wrap(vm, (U) * x);
 338     }
 339
 340     template<typename T>
 341     inline int wrap(JavaVM * vm, T * x, const int len) const
 342     {
 343         return ScilabJavaObject::wrap(vm, x, len);
 344     }
 345
 346     template<typename T, typename U>
 347     inline int wrap(JavaVM * vm, T * x, const int len) const
 348     {
 349         U * xx = new U[len];
 350         int i;
 351         for (i = 0; i < len; i++)
 352         {
 353             xx[i] = (U)x[i];
 354         }
 355
 356         i = ScilabJavaObject::wrap(vm, xx, len);
 357         delete[] xx;
 358
 359         return i;
 360     }
 361
 362     template<typename T>
 363     inline int wrap(JavaVM * vm, T * x, const int r, const int c) const
 364     {
 365         if (helper.getMethodOfConv())
 366         {
 367             T ** xx = new T*[r];
 368             int i, j;
 369             for (i = 0; i < r; i++)
 370             {
 371                 xx[i] = new T[c];
 372                 for (j = 0; j < c; j++)
 373                 {
 374                     xx[i][j] = x[j * r + i];
 375                 }
 376             }
 377             j = ScilabJavaObject::wrap(vm, xx, r, c);
 378             for (i = 0; i < r; delete[] xx[i++]);
 379             delete[] xx;
 380             return j;
 381         }
 382         else
 383         {
 384             T ** xx = new T*[c];
 385             int i;
 386             xx[0] = x;
 387             for (i = 1; i < c; xx[i] = xx[i++ - 1] + r);
 388             i = ScilabJavaObject::wrap(vm, xx, c, r);
 389             delete[] xx;
 390             return i;
 391         }
 392     }
 393
 394     template<typename T, typename U>
 395     inline int wrap(JavaVM * vm, T * x, const int r, const int c) const
 396     {
 397         if (helper.getMethodOfConv())
 398         {
 399             U ** xx = new U*[r];
 400             int i, j;
 401             for (i = 0; i < r; i++)
 402             {
 403                 xx[i] = new U[c];
 404                 for (j = 0; j < c; j++)
 405                 {
 406                     xx[i][j] = (U)(x[j * r + i]);
 407                 }
 408             }
 409             j = ScilabJavaObject::wrap(vm, xx, r, c);
 410             for (i = 0; i < r; delete[] xx[i++]);
 411             delete[] xx;
 412             return j;
 413         }
 414         else
 415         {
 416             U ** xx = new U*[c];
 417             int i, j;
 418             for (i = 0; i < c; i++)
 419             {
 420                 xx[i] = new U[r];
 421                 for (j = 0; j < r; j++)
 422                 {
 423                     xx[i][j] = (U)(x[i * r + j]);
 424                 }
 425             }
 426             j = ScilabJavaObject::wrap(vm, xx, c, r);
 427             for (i = 0; i < c; delete[] xx[i++]);
 428             delete[] xx;
 429             return j;
 430         }
 431     }
 432
 433     inline const jmethodID getSingleMethod(const char * x) const
 434     {
 435         return unwrapByteID_;
 436     }
 437     inline const jmethodID getSingleMethod(const short * x) const
 438     {
 439         return unwrapShortID_;
 440     }
 441     inline const jmethodID getSingleMethod(const unsigned short * x) const
 442     {
 443         return unwrapCharID_;
 444     }
 445     inline const jmethodID getSingleMethod(const int * x) const
 446     {
 447         return unwrapIntID_;
 448     }
 449     inline const jmethodID getSingleMethod(const long long * x) const
 450     {
 451         return unwrapLongID_;
 452     }
 453     inline const jmethodID getSingleMethod(const double * x) const
 454     {
 455         return unwrapDoubleID_;
 456     }
 457     inline const jmethodID getSingleMethod(const bool * x) const
 458     {
 459         return unwrapBooleanID_;
 460     }
 461     inline const jmethodID getSingleMethod(const float * x) const
 462     {
 463         return unwrapFloatID_;
 464     }
 465
 466     inline const jmethodID getRowMethod(const char * x) const
 467     {
 468         return unwrapRowByteID_;
 469     }
 470     inline const jmethodID getRowMethod(const short * x) const
 471     {
 472         return unwrapRowShortID_;
 473     }
 474     inline const jmethodID getRowMethod(const unsigned short * x) const
 475     {
 476         return unwrapRowCharID_;
 477     }
 478     inline const jmethodID getRowMethod(const int * x) const
 479     {
 480         return unwrapRowIntID_;
 481     }
 482     inline const jmethodID getRowMethod(const long long * x) const
 483     {
 484         return unwrapRowLongID_;
 485     }
 486     inline const jmethodID getRowMethod(const double * x) const
 487     {
 488         return unwrapRowDoubleID_;
 489     }
 490     inline const jmethodID getRowMethod(const bool * x) const
 491     {
 492         return unwrapRowBooleanID_;
 493     }
 494     inline const jmethodID getRowMethod(const float * x) const
 495     {
 496         return unwrapRowFloatID_;
 497     }
 498
 499     inline const jmethodID getMatMethod(const char * x) const
 500     {
 501         return unwrapMatByteID_;
 502     }
 503     inline const jmethodID getMatMethod(const short * x) const
 504     {
 505         return unwrapMatShortID_;
 506     }
 507     inline const jmethodID getMatMethod(const unsigned short * x) const
 508     {
 509         return unwrapMatCharID_;
 510     }
 511     inline const jmethodID getMatMethod(const int * x) const
 512     {
 513         return unwrapMatIntID_;
 514     }
 515     inline const jmethodID getMatMethod(const long long * x) const
 516     {
 517         return unwrapMatLongID_;
 518     }
 519     inline const jmethodID getMatMethod(const double * x) const
 520     {
 521         return unwrapMatDoubleID_;
 522     }
 523     inline const jmethodID getMatMethod(const bool * x) const
 524     {
 525         return unwrapMatBooleanID_;
 526     }
 527     inline const jmethodID getMatMethod(const float * x) const
 528     {
 529         return unwrapMatFloatID_;
 530     }
 531
 532     inline const jmethodID getDBMethod(const char * x) const
 533     {
 534         return wrapAsDirectByteBufferID_;
 535     }
 536     inline const jmethodID getDBMethod(const double * x) const
 537     {
 538         return wrapAsDirectDoubleBufferID_;
 539     }
 540     inline const jmethodID getDBMethod(const int * x) const
 541     {
 542         return wrapAsDirectIntBufferID_;
 543     }
 544     inline const jmethodID getDBMethod(const float * x) const
 545     {
 546         return wrapAsDirectFloatBufferID_;
 547     }
 548     inline const jmethodID getDBMethod(const long long * x) const
 549     {
 550         return wrapAsDirectLongBufferID_;
 551     }
 552     inline const jmethodID getDBMethod(const short * x) const
 553     {
 554         return wrapAsDirectShortBufferID_;
 555     }
 556
 557     template <typename T>
 558     inline T CallStatic(JNIEnv * env_, const char * x, int javaID) const
 559     {
 560         return static_cast<T>(env_->CallStaticByteMethod(ScilabJavaObjectClass_, getSingleMethod(x), javaID));
 561     }
 562
 563     template <typename T>
 564     inline T CallStatic(JNIEnv * env_, const short * x, int javaID) const
 565     {
 566         return static_cast<T>(env_->CallStaticShortMethod(ScilabJavaObjectClass_, getSingleMethod(x), javaID));
 567     }
 568
 569     template <typename T>
 570     inline T CallStatic(JNIEnv * env_, const unsigned short * x, int javaID) const
 571     {
 572         return static_cast<T>(env_->CallStaticShortMethod(ScilabJavaObjectClass_, getSingleMethod(x), javaID));
 573     }
 574
 575     template <typename T>
 576     inline T CallStatic(JNIEnv * env_, const int * x, int javaID) const
 577     {
 578         return static_cast<T>(env_->CallStaticIntMethod(ScilabJavaObjectClass_, getSingleMethod(x), javaID));
 579     }
 580
 581     template <typename T>
 582     inline T CallStatic(JNIEnv * env_, const long long * x, int javaID) const
 583     {
 584         return static_cast<T>(env_->CallStaticLongMethod(ScilabJavaObjectClass_, getSingleMethod(x), javaID));
 585     }
 586
 587     template <typename T>
 588     inline T CallStatic(JNIEnv * env_, const double * x, int javaID) const
 589     {
 590         return static_cast<T>(env_->CallStaticDoubleMethod(ScilabJavaObjectClass_, getSingleMethod(x), javaID));
 591     }
 592
 593     template <typename T>
 594     inline T CallStatic(JNIEnv * env_, const bool * x, int javaID) const
 595     {
 596         return static_cast<T>(env_->CallStaticBooleanMethod(ScilabJavaObjectClass_, getSingleMethod(x), javaID));
 597     }
 598
 599     template <typename T>
 600     inline T CallStatic(JNIEnv * env_, const float * x, int javaID) const
 601     {
 602         return static_cast<T>(env_->CallStaticFloatMethod(ScilabJavaObjectClass_, getSingleMethod(x), javaID));
 603     }
 604
 605     template <typename T, typename U, class V>
 606     inline void unwrapSingle(JavaVM * jvm_, const int javaID, const V & allocator) const
 607     {
 608         unwrapSingle<T, U, U>(jvm_, javaID, allocator);
 609     }
 610
 611     template <typename T, typename U, typename V, class W>
 612     inline void unwrapSingle(JavaVM * jvm_, const int javaID, const W & allocator, const bool mustAlloc = false) const
 613     {
 614         JNIEnv * curEnv = NULL;
 615         U* addr = 0;
 616
 617
 618         jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 619
 620         T res = CallStatic<T>(curEnv, (V *)addr, javaID);
 621         if (curEnv->ExceptionCheck())
 622         {
 623             throw GiwsException::JniCallMethodException(curEnv);
 624         }
 625
 626         if (mustAlloc)
 627         {
 628             addr = reinterpret_cast<U *>(allocator.allocate(1, 1, 0));
 629             *addr = static_cast<U>(res);
 630         }
 631         else
 632         {
 633             allocator.allocate(1, 1, reinterpret_cast<V *>(&res));
 634         }
 635     }
 636
 637     template <typename T, typename U, class V>
 638     inline void unwrapRow(JavaVM * jvm_, const int javaID, const V & allocator) const
 639     {
 640         unwrapRow<T, U, U>(jvm_, javaID, allocator);
 641     }
 642
 643     template <typename T, typename U, typename V, class W>
 644     inline void unwrapRow(JavaVM * jvm_, const int javaID, const W & allocator, const bool mustAlloc = false) const
 645     {
 646         jint lenRow;
 647         jboolean isCopy = JNI_FALSE;
 648         JNIEnv * curEnv = NULL;
 649         U* addr = 0;
 650         jobject res = 0;
 651         jobjectArray array = 0;
 652         void * buffer = 0;
 653
 654         jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 655
 656         res = curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, getRowMethod((V *)addr), javaID);
 657         if (curEnv->ExceptionCheck())
 658         {
 659             curEnv->DeleteLocalRef(res);
 660             throw GiwsException::JniCallMethodException(curEnv);
 661         }
 662
 663         buffer = curEnv->GetDirectBufferAddress(res);
 664         if (buffer)
 665         {
 666             const jlong len = curEnv->GetDirectBufferCapacity(res);
 667             V * resultsArray = (V *)buffer;
 668             if (mustAlloc)
 669             {
 670                 try
 671                 {
 672                     addr = reinterpret_cast<U* >(allocator.allocate(1, len, 0));
 673                     for (jlong i = 0; i < len; i++)
 674                     {
 675                         addr[i] = static_cast<U>(resultsArray[i]);
 676                     }
 677                 }
 678                 catch (const ScilabAbstractEnvironmentException & e)
 679                 {
 680                     curEnv->DeleteLocalRef(res);
 681                     throw;
 682                 }
 683             }
 684             else
 685             {
 686                 try
 687                 {
 688                     allocator.allocate(1, len, reinterpret_cast<V *>(resultsArray));
 689                 }
 690                 catch (const ScilabAbstractEnvironmentException & e)
 691                 {
 692                     curEnv->DeleteLocalRef(res);
 693                     throw;
 694                 }
 695             }
 696         }
 697         else
 698         {
 699             array = static_cast<jobjectArray>(res);
 700             lenRow = curEnv->GetArrayLength(array);
 701
 702             if (mustAlloc)
 703             {
 704                 try
 705                 {
 706                     addr = reinterpret_cast<U *>(allocator.allocate(1, lenRow, 0));
 707                 }
 708                 catch (const ScilabAbstractEnvironmentException & e)
 709                 {
 710                     curEnv->DeleteLocalRef(array);
 711                     throw;
 712                 }
 713             }
 714
 715             T * resultsArray = static_cast<T *>(curEnv->GetPrimitiveArrayCritical(array, &isCopy));
 716
 717             if (mustAlloc)
 718             {
 719                 for (int i = 0; i < lenRow; i++)
 720                 {
 721                     addr[i] = static_cast<U>(resultsArray[i]);
 722                 }
 723             }
 724             else
 725             {
 726                 try
 727                 {
 728                     allocator.allocate(1, lenRow, reinterpret_cast<V *>(resultsArray));
 729                 }
 730                 catch (const ScilabAbstractEnvironmentException & e)
 731                 {
 732                     curEnv->ReleasePrimitiveArrayCritical(array, resultsArray, JNI_ABORT);
 733                     curEnv->DeleteLocalRef(array);
 734                     throw;
 735                 }
 736             }
 737
 738             curEnv->ReleasePrimitiveArrayCritical(array, resultsArray, JNI_ABORT);
 739             curEnv->DeleteLocalRef(array);
 740         }
 741         if (curEnv->ExceptionCheck())
 742         {
 743             throw GiwsException::JniCallMethodException(curEnv);
 744         }
 745     }
 746
 747     template <typename T, typename U, class V>
 748     inline void unwrapMat(JavaVM * jvm_, const int javaID, const V & allocator) const
 749     {
 750         unwrapMat<T, U, U>(jvm_, javaID, allocator);
 751     }
 752
 753     template <typename T, typename U, typename V, class W>
 754     inline void unwrapMat(JavaVM * jvm_, const int javaID, const W & allocator) const
 755     {
 756         jint lenRow, lenCol;
 757         jboolean isCopy = JNI_FALSE;
 758         jarray oneDim;
 759         JNIEnv * curEnv = NULL;
 760         U* addr = 0;
 761
 762         jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 763
 764         jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, getMatMethod((V *)addr), javaID));
 765         if (curEnv->ExceptionCheck())
 766         {
 767             throw GiwsException::JniCallMethodException(curEnv);
 768         }
 769
 770         lenRow = curEnv->GetArrayLength(res);
 771         oneDim = reinterpret_cast<jarray>(curEnv->GetObjectArrayElement(res, 0));
 772         lenCol = curEnv->GetArrayLength(oneDim);
 773         curEnv->DeleteLocalRef(oneDim);
 774
 775         try
 776         {
 777             if (helper.getMethodOfConv())
 778             {
 779                 addr = (U *)allocator.allocate(lenRow, lenCol, 0);
 780             }
 781             else
 782             {
 783                 addr = (U *)allocator.allocate(lenCol, lenRow, 0);
 784             }
 785         }
 786         catch (const ScilabAbstractEnvironmentException & e)
 787         {
 788             curEnv->DeleteLocalRef(res);
 789             throw;
 790         }
 791
 792         T * resultsArray;
 793         for (int i = 0; i < lenRow; i++)
 794         {
 795             oneDim = reinterpret_cast<jarray>(curEnv->GetObjectArrayElement(res, i));
 796             resultsArray = static_cast<T *>(curEnv->GetPrimitiveArrayCritical(oneDim, &isCopy));
 797             if (helper.getMethodOfConv())
 798             {
 799                 for (int j = 0; j < lenCol; j++)
 800                 {
 801                     addr[j * lenRow + i] = static_cast<U>(resultsArray[j]);
 802                 }
 803             }
 804             else
 805             {
 806                 for (int j = 0; j < lenCol; j++)
 807                 {
 808                     addr[i * lenCol + j] = static_cast<U>(resultsArray[j]);
 809                 }
 810             }
 811             curEnv->ReleasePrimitiveArrayCritical(oneDim, resultsArray, JNI_ABORT);
 812             curEnv->DeleteLocalRef(oneDim);
 813         }
 814
 815         curEnv->DeleteLocalRef(res);
 816         if (curEnv->ExceptionCheck())
 817         {
 818             throw GiwsException::JniCallMethodException(curEnv);
 819         }
 820     }
 821
 822     template<typename T>
 823     inline int wrapAsDirectBuffer(JavaVM * jvm_, T * data, const int size) const
 824     {
 825         JNIEnv * curEnv = NULL;
 826         jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
 827
 828         jobject dbuffer = curEnv->NewDirectByteBuffer((void*)data, (jlong)(size * sizeof(T)));
 829         int id = static_cast<jint>(curEnv->CallStaticIntMethod(ScilabJavaObjectClass_, getDBMethod(data), dbuffer));
 830
 831         curEnv->DeleteLocalRef(dbuffer);
 832         if (curEnv->ExceptionCheck())
 833         {
 834             throw GiwsException::JniCallMethodException(curEnv);
 835         }
 836
 837         return id;
 838     }
 839 };
 840 }
 841
 842 #endif // __SCILABJAVAENVIRONMENTWRAPPER_HXX__