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