e674c4b376985d8ef3872e4b4e84ae606a8a9442
[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 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__