JIMS: forgot jchar unwrappers
[scilab.git] / 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__