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