JIMS: plug extraction
[scilab.git] / scilab / modules / external_objects_java / src / cpp / ScilabJavaEnvironmentWrapper.cpp
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  * Copyright (C) 2013 - Scilab Enterprises - Sylvestre Ledru
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
12  *
13  */
14
15 #ifdef _MSC_VER
16 #include "windows.h"
17 #endif
18
19 #include "ScilabJavaEnvironmentWrapper.hxx"
20
21 extern "C" {
22 #include "getScilabJavaVM.h"
23 }
24
25 namespace org_scilab_modules_external_objects_java
26 {
27
28 VariableType ScilabJavaEnvironmentWrapper::isunwrappable(int id) const
29 {
30     JavaVM * vm = getScilabJavaVM();
31     int type = ScilabJavaObject::isUnwrappable(vm, id);
32
33     return (VariableType)type;
34 }
35
36 int ScilabJavaEnvironmentWrapper::wrap(double * x, const bool isRef) const
37 {
38     JavaVM * vm = getScilabJavaVM();
39     return wrap(vm, x);
40 }
41
42 int ScilabJavaEnvironmentWrapper::wrap(double * x, int xSize, const bool isRef) const
43 {
44     JavaVM * vm = getScilabJavaVM();
45     return wrap(vm, x, xSize);
46 }
47
48 int ScilabJavaEnvironmentWrapper::wrap(double * x, int xSize, int xSizeCol, const bool isRef) const
49 {
50     JavaVM * vm = getScilabJavaVM();
51     return wrap(vm, x, xSize, xSizeCol);
52 }
53
54 int ScilabJavaEnvironmentWrapper::wrap(double * re, double * im, const bool isRef) const
55 {
56     //if (helper.getWrapSingleWithNumpy())
57     //{
58     //    return wrapData(re, im, 1, isRef);
59     //}
60     //else
61     //{
62     //    return wrapData(re, im, isRef);
63     //}
64     return 0;
65 }
66
67 int ScilabJavaEnvironmentWrapper::wrap(double * re, double * im, int xSize, const bool isRef) const
68 {
69     //    return wrapData(re, im, xSize, isRef);
70     return 0;
71 }
72
73 int ScilabJavaEnvironmentWrapper::wrap(double * re, double * im, int xSize, int xSizeCol, const bool isRef) const
74 {
75     //    return wrapData(re, im, xSize, xSizeCol, isRef);
76     return 0;
77 }
78
79 int ScilabJavaEnvironmentWrapper::wrap(char * x, const bool isRef) const
80 {
81     JavaVM * vm = getScilabJavaVM();
82     return wrap<char>(vm, x);
83 }
84
85 int ScilabJavaEnvironmentWrapper::wrap(char * x, int xSize, const bool isRef) const
86 {
87     JavaVM * vm = getScilabJavaVM();
88     return wrap(vm, (byte *)x, xSize);
89 }
90
91 int ScilabJavaEnvironmentWrapper::wrap(char * x, int xSize, int xSizeCol, const bool isRef) const
92 {
93     JavaVM * vm = getScilabJavaVM();
94     return wrap(vm, (byte *)x, xSize, xSizeCol);
95 }
96
97 int ScilabJavaEnvironmentWrapper::wrap(unsigned char * x, const bool isRef) const
98 {
99     JavaVM * vm = getScilabJavaVM();
100     return wrap(vm, (byte *)x);
101 }
102
103 int ScilabJavaEnvironmentWrapper::wrap(unsigned char * x, int xSize, const bool isRef) const
104 {
105     JavaVM * vm = getScilabJavaVM();
106     return wrap(vm, (byte *)x, xSize);
107 }
108
109 int ScilabJavaEnvironmentWrapper::wrap(unsigned char * x, int xSize, int xSizeCol, const bool isRef) const
110 {
111     JavaVM * vm = getScilabJavaVM();
112     return wrap(vm, (byte *)x, xSize, xSizeCol);
113 }
114
115 int ScilabJavaEnvironmentWrapper::wrap(short * x, const bool isRef) const
116 {
117     JavaVM * vm = getScilabJavaVM();
118     return wrap(vm, x);
119 }
120
121 int ScilabJavaEnvironmentWrapper::wrap(short * x, int xSize, const bool isRef) const
122 {
123     JavaVM * vm = getScilabJavaVM();
124     return wrap(vm, x, xSize);
125 }
126
127 int ScilabJavaEnvironmentWrapper::wrap(short * x, int xSize, int xSizeCol, const bool isRef) const
128 {
129     JavaVM * vm = getScilabJavaVM();
130     return wrap(vm, x, xSize, xSizeCol);
131 }
132
133 int ScilabJavaEnvironmentWrapper::wrap(unsigned short * x, const bool isRef) const
134 {
135     JavaVM * vm = getScilabJavaVM();
136     return wrap(vm, (short *)x);
137 }
138
139 int ScilabJavaEnvironmentWrapper::wrap(unsigned short * x, int xSize, const bool isRef) const
140 {
141     JavaVM * vm = getScilabJavaVM();
142     return wrap(vm, (short *)x, xSize);
143 }
144
145 int ScilabJavaEnvironmentWrapper::wrap(unsigned short * x, int xSize, int xSizeCol, const bool isRef) const
146 {
147     JavaVM * vm = getScilabJavaVM();
148     return wrap(vm, (short *)x, xSize, xSizeCol);
149 }
150
151 int ScilabJavaEnvironmentWrapper::wrap(int * x, const bool isRef) const
152 {
153     JavaVM * vm = getScilabJavaVM();
154     return wrap(vm, x);
155 }
156
157 int ScilabJavaEnvironmentWrapper::wrap(int * x, int xSize, const bool isRef) const
158 {
159     JavaVM * vm = getScilabJavaVM();
160     return wrap(vm, x, xSize);
161 }
162
163 int ScilabJavaEnvironmentWrapper::wrap(int * x, int xSize, int xSizeCol, const bool isRef) const
164 {
165     JavaVM * vm = getScilabJavaVM();
166     return wrap(vm, x, xSize, xSizeCol);
167 }
168
169 int ScilabJavaEnvironmentWrapper::wrap(unsigned int * x, const bool isRef) const
170 {
171     JavaVM * vm = getScilabJavaVM();
172     return wrap(vm, (int *)x);
173 }
174
175 int ScilabJavaEnvironmentWrapper::wrap(unsigned int * x, int xSize, const bool isRef) const
176 {
177     JavaVM * vm = getScilabJavaVM();
178     return wrap(vm, (int *)x, xSize);
179 }
180
181 int ScilabJavaEnvironmentWrapper::wrap(unsigned int * x, int xSize, int xSizeCol, const bool isRef) const
182 {
183     JavaVM * vm = getScilabJavaVM();
184     return wrap(vm, (int *)x, xSize, xSizeCol);
185 }
186
187 #ifdef __SCILAB_INT64__
188
189 int ScilabJavaEnvironmentWrapper::wrap(long long * x, const bool isRef) const
190 {
191     JavaVM * vm = getScilabJavaVM();
192     return wrap(vm, x);
193 }
194
195 int ScilabJavaEnvironmentWrapper::wrap(long long * x, int xSize, const bool isRef) const
196 {
197     JavaVM * vm = getScilabJavaVM();
198     return wrap(vm, x, xSize);
199 }
200
201 int ScilabJavaEnvironmentWrapper::wrap(long long * x, int xSize, int xSizeCol, const bool isRef) const
202 {
203     JavaVM * vm = getScilabJavaVM();
204     return wrap(vm, x, xSize, xSizeCol);
205 }
206
207 int ScilabJavaEnvironmentWrapper::wrap(unsigned long long * x, const bool isRef) const
208 {
209     JavaVM * vm = getScilabJavaVM();
210     return wrap(vm, (long long *)x);
211 }
212
213 int ScilabJavaEnvironmentWrapper::wrap(unsigned long long * x, int xSize, const bool isRef) const
214 {
215     JavaVM * vm = getScilabJavaVM();
216     return wrap(vm, (long long *)x, xSize);
217 }
218
219 int ScilabJavaEnvironmentWrapper::wrap(unsigned long long * x, int xSize, int xSizeCol, const bool isRef) const
220 {
221     JavaVM * vm = getScilabJavaVM();
222     return wrap(vm, (long long *)x, xSize, xSizeCol);
223 }
224
225 #endif
226
227 int ScilabJavaEnvironmentWrapper::wrap(char ** x, const bool isRef) const
228 {
229     JavaVM * vm = getScilabJavaVM();
230     return wrap(vm, (char const**)x);
231 }
232
233 int ScilabJavaEnvironmentWrapper::wrap(char ** x, int xSize, const bool isRef) const
234 {
235     JavaVM * vm = getScilabJavaVM();
236     return wrap(vm, (char const**)x, xSize);
237 }
238
239 int ScilabJavaEnvironmentWrapper::wrap(char ** x, int xSize, int xSizeCol, const bool isRef) const
240 {
241     JavaVM * vm = getScilabJavaVM();
242     return wrap(vm, (char const**)x, xSize, xSizeCol);
243 }
244
245 int ScilabJavaEnvironmentWrapper::wrapBool(int * x, const bool isRef) const
246 {
247     JavaVM * vm = getScilabJavaVM();
248     return wrap<int, bool>(vm, x);
249 }
250
251 int ScilabJavaEnvironmentWrapper::wrapBool(int * x, int xSize, const bool isRef) const
252 {
253     JavaVM * vm = getScilabJavaVM();
254     return wrap<int, bool>(vm, x, xSize);
255 }
256
257 int ScilabJavaEnvironmentWrapper::wrapBool(int * x, int xSize, int xSizeCol, const bool isRef) const
258 {
259     JavaVM * vm = getScilabJavaVM();
260     return wrap<int, bool>(vm, x, xSize, xSizeCol);
261 }
262
263 int ScilabJavaEnvironmentWrapper::wrapFloat(double * x, const bool isRef) const
264 {
265     JavaVM * vm = getScilabJavaVM();
266     return wrap<double, float>(vm, x);
267 }
268
269 int ScilabJavaEnvironmentWrapper::wrapFloat(double * x, int xSize, const bool isRef) const
270 {
271     JavaVM * vm = getScilabJavaVM();
272     return wrap<double, float>(vm, x, xSize);
273 }
274
275 int ScilabJavaEnvironmentWrapper::wrapFloat(double * x, int xSize, int xSizeCol, const bool isRef) const
276 {
277     JavaVM * vm = getScilabJavaVM();
278     return wrap<double, float>(vm, x, xSize, xSizeCol);
279 }
280
281 void ScilabJavaEnvironmentWrapper::unwrapdouble(int id, const ScilabDoubleStackAllocator & allocator) const
282 {
283     JavaVM * vm = getScilabJavaVM();
284     unwrapSingle<jdouble, double>(vm, id, allocator);
285 }
286
287 void ScilabJavaEnvironmentWrapper::unwraprowdouble(int id, const ScilabDoubleStackAllocator & allocator) const
288 {
289     JavaVM * vm = getScilabJavaVM();
290     unwrapRow<jdouble, double>(vm, id, allocator);
291 }
292
293 void ScilabJavaEnvironmentWrapper::unwrapmatdouble(int id, const ScilabDoubleStackAllocator & allocator) const
294 {
295     JavaVM * vm = getScilabJavaVM();
296     unwrapMat<jdouble, double>(vm, id, allocator);
297 }
298
299 void ScilabJavaEnvironmentWrapper::unwrapchar(int id, const ScilabCharStackAllocator & allocator) const
300 {
301     JavaVM * vm = getScilabJavaVM();
302     unwrapSingle<jbyte, char>(vm, id, allocator);
303 }
304
305 void ScilabJavaEnvironmentWrapper::unwraprowchar(int id, const ScilabCharStackAllocator & allocator) const
306 {
307     JavaVM * vm = getScilabJavaVM();
308     unwrapRow<jbyte, char>(vm, id, allocator);
309 }
310
311 void ScilabJavaEnvironmentWrapper::unwrapmatchar(int id, const ScilabCharStackAllocator & allocator) const
312 {
313     JavaVM * vm = getScilabJavaVM();
314     unwrapMat<jbyte, char>(vm, id, allocator);
315 }
316
317 void ScilabJavaEnvironmentWrapper::unwrapuchar(int id, const ScilabUCharStackAllocator & allocator) const
318 {
319     // Not called
320 }
321
322 void ScilabJavaEnvironmentWrapper::unwraprowuchar(int id, const ScilabUCharStackAllocator & allocator) const
323 {
324     // Not called
325 }
326
327 void ScilabJavaEnvironmentWrapper::unwrapmatuchar(int id, const ScilabUCharStackAllocator & allocator) const
328 {
329     // Not called
330 }
331
332 void ScilabJavaEnvironmentWrapper::unwrapshort(int id, const ScilabShortStackAllocator & allocator) const
333 {
334     JavaVM * vm = getScilabJavaVM();
335     unwrapSingle<jshort, short>(vm, id, allocator);
336 }
337
338 void ScilabJavaEnvironmentWrapper::unwraprowshort(int id, const ScilabShortStackAllocator & allocator) const
339 {
340     JavaVM * vm = getScilabJavaVM();
341     unwrapRow<jshort, short>(vm, id, allocator);
342 }
343
344 void ScilabJavaEnvironmentWrapper::unwrapmatshort(int id, const ScilabShortStackAllocator & allocator) const
345 {
346     JavaVM * vm = getScilabJavaVM();
347     unwrapMat<jshort, short>(vm, id, allocator);
348 }
349
350 void ScilabJavaEnvironmentWrapper::unwrapushort(int id, const ScilabUShortStackAllocator & allocator) const
351 {
352     // Not called
353 }
354
355 void ScilabJavaEnvironmentWrapper::unwraprowushort(int id, const ScilabUShortStackAllocator & allocator) const
356 {
357     // Not called
358 }
359
360 void ScilabJavaEnvironmentWrapper::unwrapmatushort(int id, const ScilabUShortStackAllocator & allocator) const
361 {
362     // Not called
363 }
364
365 void ScilabJavaEnvironmentWrapper::unwrapint(int id, const ScilabIntStackAllocator & allocator) const
366 {
367     JavaVM * vm = getScilabJavaVM();
368     unwrapSingle<jint, int>(vm, id, allocator);
369 }
370
371 void ScilabJavaEnvironmentWrapper::unwraprowint(int id, const ScilabIntStackAllocator & allocator) const
372 {
373     JavaVM * vm = getScilabJavaVM();
374     unwrapRow<jint, int>(vm, id, allocator);
375 }
376
377 void ScilabJavaEnvironmentWrapper::unwrapmatint(int id, const ScilabIntStackAllocator & allocator) const
378 {
379     JavaVM * vm = getScilabJavaVM();
380     unwrapMat<jint, int>(vm, id, allocator);
381 }
382
383 void ScilabJavaEnvironmentWrapper::unwrapuint(int id, const ScilabUIntStackAllocator & allocator) const
384 {
385     // Not called
386 }
387
388 void ScilabJavaEnvironmentWrapper::unwraprowuint(int id, const ScilabUIntStackAllocator & allocator) const
389 {
390     // Not called
391 }
392
393 void ScilabJavaEnvironmentWrapper::unwrapmatuint(int id, const ScilabUIntStackAllocator & allocator) const
394 {
395     // Not called
396 }
397
398 void ScilabJavaEnvironmentWrapper::unwraplong(int id, const ScilabLongStackAllocator & allocator) const
399 {
400     JavaVM * vm = getScilabJavaVM();
401     unwrapSingle<jlong, long long, long long>(vm, id, allocator, false);
402 }
403
404 void ScilabJavaEnvironmentWrapper::unwraprowlong(int id, const ScilabLongStackAllocator & allocator) const
405 {
406     JavaVM * vm = getScilabJavaVM();
407     unwrapRow<jlong, long long, long long>(vm, id, allocator, false);
408 }
409
410 void ScilabJavaEnvironmentWrapper::unwrapmatlong(int id, const ScilabLongStackAllocator & allocator) const
411 {
412     JavaVM * vm = getScilabJavaVM();
413     unwrapMat<jlong, int, long long>(vm, id, allocator);
414 }
415
416 void ScilabJavaEnvironmentWrapper::unwrapulong(int id, const ScilabULongStackAllocator & allocator) const
417 {
418     // Not called
419 }
420
421 void ScilabJavaEnvironmentWrapper::unwraprowulong(int id, const ScilabULongStackAllocator & allocator) const
422 {
423     // Not called
424 }
425
426 void ScilabJavaEnvironmentWrapper::unwrapmatulong(int id, const ScilabULongStackAllocator & allocator) const
427 {
428     // Not called
429 }
430
431 void ScilabJavaEnvironmentWrapper::unwrapboolean(int id, const ScilabBooleanStackAllocator & allocator) const
432 {
433     JavaVM * vm = getScilabJavaVM();
434     unwrapSingle<jboolean, int, bool>(vm, id, allocator);
435 }
436
437 void ScilabJavaEnvironmentWrapper::unwraprowboolean(int id, const ScilabBooleanStackAllocator & allocator) const
438 {
439     JavaVM * vm = getScilabJavaVM();
440     unwrapRow<jboolean, int, bool>(vm, id, allocator);
441 }
442
443 void ScilabJavaEnvironmentWrapper::unwrapmatboolean(int id, const ScilabBooleanStackAllocator & allocator) const
444 {
445     JavaVM * vm = getScilabJavaVM();
446     unwrapMat<jboolean, int, bool>(vm, id, allocator);
447 }
448
449 void ScilabJavaEnvironmentWrapper::unwrapstring(int id, const ScilabStringStackAllocator & allocator) const
450 {
451     JNIEnv * curEnv = NULL;
452     JavaVM * vm = getScilabJavaVM();
453     vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
454
455     jstring res = static_cast<jstring>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapStringID_ , id));
456     char * addr = const_cast<char *>(curEnv->GetStringUTFChars(res, 0));
457
458     allocator.allocate(1, 1, &addr);
459
460     curEnv->ReleaseStringUTFChars(res, addr);
461     curEnv->DeleteLocalRef(res);
462     if (curEnv->ExceptionCheck())
463     {
464         throw GiwsException::JniCallMethodException(curEnv);
465     }
466 }
467
468 void ScilabJavaEnvironmentWrapper::unwraprowstring(int id, const ScilabStringStackAllocator & allocator) const
469 {
470     JNIEnv * curEnv = NULL;
471     JavaVM * vm = getScilabJavaVM();
472     vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
473
474     jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapRowStringID_ , id));
475     if (curEnv->ExceptionCheck())
476     {
477         throw GiwsException::JniCallMethodException(curEnv);
478     }
479
480     jint lenRow = curEnv->GetArrayLength(res);
481     jboolean isCopy = JNI_FALSE;
482     char ** addr = new char*[lenRow];
483     jstring * resString = new jstring[lenRow];
484
485     for (jsize i = 0; i < lenRow; i++)
486     {
487         resString[i] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
488         addr[i] = const_cast<char *>(curEnv->GetStringUTFChars(resString[i], &isCopy));
489     }
490
491     allocator.allocate(1, lenRow, addr);
492
493     for (jsize i = 0; i < lenRow; i++)
494     {
495         curEnv->ReleaseStringUTFChars(resString[i], addr[i]);
496         curEnv->DeleteLocalRef(resString[i]);
497     }
498     delete[] addr;
499     delete[] resString;
500
501     curEnv->DeleteLocalRef(res);
502     if (curEnv->ExceptionCheck())
503     {
504         throw GiwsException::JniCallMethodException(curEnv);
505     }
506 }
507
508 void ScilabJavaEnvironmentWrapper::unwrapmatstring(int id, const ScilabStringStackAllocator & allocator) const
509 {
510     JNIEnv * curEnv = NULL;
511     JavaVM * vm = getScilabJavaVM();
512     vm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
513
514     jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(ScilabJavaObjectClass_, unwrapMatStringID_, id));
515     if (curEnv->ExceptionCheck())
516     {
517         throw GiwsException::JniCallMethodException(curEnv);
518     }
519     jint lenRow = curEnv->GetArrayLength(res);
520     jboolean isCopy = JNI_FALSE;
521
522     jobjectArray oneDim = reinterpret_cast<jobjectArray>(curEnv->GetObjectArrayElement(res, 0));
523     jint lenCol = curEnv->GetArrayLength(oneDim);
524     char ** addr = new char*[lenRow * lenCol];
525     jstring * resString = new jstring[lenRow * lenCol];
526
527     for (int i = 0; i < lenRow; i++)
528     {
529         oneDim = reinterpret_cast<jobjectArray>(curEnv->GetObjectArrayElement(res, i));
530         if (helper.getMethodOfConv())
531         {
532             for (int j = 0; j < lenCol; j++)
533             {
534                 resString[j * lenRow + i] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(oneDim, j));
535                 addr[j * lenRow + i] = const_cast<char *>(curEnv->GetStringUTFChars(resString[j * lenRow + i], &isCopy));
536             }
537         }
538         else
539         {
540             for (int j = 0; j < lenCol; j++)
541             {
542                 resString[i * lenCol + j] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(oneDim, j));
543                 addr[i * lenCol + j] = const_cast<char *>(curEnv->GetStringUTFChars(resString[i * lenCol + j], &isCopy));
544             }
545         }
546         curEnv->DeleteLocalRef(oneDim);
547     }
548
549     if (helper.getMethodOfConv())
550     {
551         allocator.allocate(lenRow, lenCol, addr);
552     }
553     else
554     {
555         allocator.allocate(lenCol, lenRow, addr);
556     }
557
558     for (int i = 0; i < lenRow * lenCol; i++)
559     {
560         curEnv->ReleaseStringUTFChars(resString[i], addr[i]);
561         curEnv->DeleteLocalRef(resString[i]);
562     }
563     delete[] addr;
564     delete[] resString;
565
566     curEnv->DeleteLocalRef(res);
567     if (curEnv->ExceptionCheck())
568     {
569         throw GiwsException::JniCallMethodException(curEnv);
570     }
571 }
572
573 void ScilabJavaEnvironmentWrapper::unwrapcomplex(int id, const ScilabComplexStackAllocator & allocator) const
574 {
575     // never called
576 }
577
578 void ScilabJavaEnvironmentWrapper::unwraprowcomplex(int id, const ScilabComplexStackAllocator & allocator) const
579 {
580     // never called
581 }
582
583 void ScilabJavaEnvironmentWrapper::unwrapmatcomplex(int id, const ScilabComplexStackAllocator & allocator) const
584 {
585     // never called
586 }
587
588 void ScilabJavaEnvironmentWrapper::unwrapfloat(int id, const ScilabFloatStackAllocator & allocator) const
589 {
590     JavaVM * vm = getScilabJavaVM();
591     unwrapSingle<jfloat, float, float>(vm, id, allocator, false);
592 }
593
594 void ScilabJavaEnvironmentWrapper::unwraprowfloat(int id, const ScilabFloatStackAllocator & allocator) const
595 {
596     JavaVM * vm = getScilabJavaVM();
597     unwrapRow<jfloat, float, float>(vm, id, allocator, false);
598 }
599
600 void ScilabJavaEnvironmentWrapper::unwrapmatfloat(int id, const ScilabFloatStackAllocator & allocator) const
601 {
602     JavaVM * vm = getScilabJavaVM();
603     unwrapMat<jfloat, double, float>(vm, id, allocator);
604 }
605 }