6ef4ca5ee154cdf2b2766f43fa3db7d60203f0ce
[scilab.git] / scilab / modules / external_objects_java / src / jni / ScilabJavaObject.cpp
1 #include "ScilabJavaObject.hxx"
2 /* Generated by GIWS (version 2.0.2) with command:
3 giws --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/ScilabObjects.giws.xml
4 */
5 /*
6
7 This is generated code.
8
9 This software is a computer program whose purpose is to hide the complexity
10 of accessing Java objects/methods from C++ code.
11
12 This software is governed by the CeCILL-B license under French law and
13 abiding by the rules of distribution of free software.  You can  use,
14 modify and/ or redistribute the software under the terms of the CeCILL-B
15 license as circulated by CEA, CNRS and INRIA at the following URL
16 "http://www.cecill.info".
17
18 As a counterpart to the access to the source code and  rights to copy,
19 modify and redistribute granted by the license, users are provided only
20 with a limited warranty  and the software's author,  the holder of the
21 economic rights,  and the successive licensors  have only  limited
22 liability.
23
24 In this respect, the user's attention is drawn to the risks associated
25 with loading,  using,  modifying and/or developing or reproducing the
26 software by the user in light of its specific status of free software,
27 that may mean  that it is complicated to manipulate,  and  that  also
28 therefore means  that it is reserved for developers  and  experienced
29 professionals having in-depth computer knowledge. Users are therefore
30 encouraged to load and test the software's suitability as regards their
31 requirements in conditions enabling the security of their systems and/or
32 data to be ensured and,  more generally, to use and operate it in the
33 same conditions as regards security.
34
35 The fact that you are presently reading this means that you have had
36 knowledge of the CeCILL-B license and that you accept its terms.
37 */
38
39 namespace org_scilab_modules_external_objects_java {
40
41                 // Static declarations (if any)
42                 
43 // Returns the current env
44
45 JNIEnv * ScilabJavaObject::getCurrentEnv() {
46 JNIEnv * curEnv = NULL;
47 jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
48 if (res != JNI_OK) {
49 throw GiwsException::JniException(getCurrentEnv());
50 }
51 return curEnv;
52 }
53 // Destructor
54
55 ScilabJavaObject::~ScilabJavaObject() {
56 JNIEnv * curEnv = NULL;
57 this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
58 curEnv->DeleteGlobalRef(this->instance);
59 curEnv->DeleteGlobalRef(this->instanceClass);
60 curEnv->DeleteGlobalRef(this->stringArrayClass);}
61 // Constructors
62 ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_) {
63 jmethodID constructObject = NULL ;
64 jobject localInstance ;
65 jclass localClass ;
66
67 const std::string construct="<init>";
68 const std::string param="()V";
69 jvm=jvm_;
70
71 JNIEnv * curEnv = getCurrentEnv();
72
73 localClass = curEnv->FindClass( this->className().c_str() ) ;
74 if (localClass == NULL) {
75   throw GiwsException::JniClassNotFoundException(curEnv, this->className());
76 }
77
78 this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
79
80 /* localClass is not needed anymore */
81 curEnv->DeleteLocalRef(localClass);
82
83 if (this->instanceClass == NULL) {
84 throw GiwsException::JniObjectCreationException(curEnv, this->className());
85 }
86
87
88 constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
89 if(constructObject == NULL){
90 throw GiwsException::JniObjectCreationException(curEnv, this->className());
91 }
92
93 localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
94 if(localInstance == NULL){
95 throw GiwsException::JniObjectCreationException(curEnv, this->className());
96 }
97  
98 this->instance = curEnv->NewGlobalRef(localInstance) ;
99 if(this->instance == NULL){
100 throw GiwsException::JniObjectCreationException(curEnv, this->className());
101 }
102 /* localInstance not needed anymore */
103 curEnv->DeleteLocalRef(localInstance);
104
105                 /* Methods ID set to NULL */
106 jintinvokejintintjstringjava_lang_StringjintArray_intintID=NULL;
107 jintextractjintintjintArray_intintID=NULL;
108 voidinsertjintintjintArray_intintjintintID=NULL;
109 jobjectArray_getInfosID=NULL;
110 voidinitScilabJavaObjectID=NULL;
111 voidgarbageCollectID=NULL;
112 jstringgetRepresentationjintintID=NULL;
113 jbooleanisValidJavaObjectjintintID=NULL;
114 voidenableTracejstringjava_lang_StringID=NULL;
115 voiddisableTraceID=NULL;
116 voidwriteLogjstringjava_lang_StringID=NULL;
117 voidsetFieldjintintjstringjava_lang_StringjintintID=NULL;
118 jintgetFieldjintintjstringjava_lang_StringID=NULL;
119 jintgetFieldTypejintintjstringjava_lang_StringID=NULL;
120 jintjavaCastjintintjstringjava_lang_StringID=NULL;
121 jintjavaCastjintintjintintID=NULL;
122 jstringgetClassNamejintintID=NULL;
123 jintgetArrayElementjintintjintArray_intintID=NULL;
124 voidsetArrayElementjintintjintArray_intintjintintID=NULL;
125 voidremoveScilabJavaObjectjintintID=NULL;
126 voidremoveScilabJavaObjectjintArray_intintID=NULL;
127 voidlimitDirectBufferjintintID=NULL;
128 jintisUnwrappablejintintID=NULL;
129 jintwrapjdoubledoubleID=NULL;
130 jintwrapjdoubleArray_doubledoubleID=NULL;
131 jintwrapjobjectArray__doubledoubleID=NULL;
132 jintwrapjintintID=NULL;
133 jintwrapjintArray_intintID=NULL;
134 jintwrapjobjectArray__intintID=NULL;
135 jintwrapjbytebyteID=NULL;
136 jintwrapjbyteArray_bytebyteID=NULL;
137 jintwrapjobjectArray__bytebyteID=NULL;
138 jintwrapjshortshortID=NULL;
139 jintwrapjshortArray_shortshortID=NULL;
140 jintwrapjobjectArray__shortshortID=NULL;
141 jintwrapjstringjava_lang_StringID=NULL;
142 jintwrapjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
143 jintwrapjobjectArray__java_lang_Stringjava_lang_StringID=NULL;
144 jintwrapjbooleanbooleanID=NULL;
145 jintwrapjbooleanArray_booleanbooleanID=NULL;
146 jintwrapjobjectArray__booleanbooleanID=NULL;
147 jintwrapjcharcharID=NULL;
148 jintwrapjcharArray_charcharID=NULL;
149 jintwrapjobjectArray__charcharID=NULL;
150 jintwrapjfloatfloatID=NULL;
151 jintwrapjfloatArray_floatfloatID=NULL;
152 jintwrapjobjectArray__floatfloatID=NULL;
153 jintwrapjlonglongID=NULL;
154 jintwrapjlongArray_longlongID=NULL;
155 jintwrapjobjectArray__longlongID=NULL;
156 jobjectArray_getAccessibleFieldsjintintID=NULL;
157 jobjectArray_getAccessibleMethodsjintintID=NULL;
158 jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
159
160
161 }
162
163 ScilabJavaObject::ScilabJavaObject(JavaVM * jvm_, jobject JObj) {
164         jvm=jvm_;
165
166         JNIEnv * curEnv = getCurrentEnv();
167
168 jclass localClass = curEnv->GetObjectClass(JObj);
169         this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
170         curEnv->DeleteLocalRef(localClass);
171
172         if (this->instanceClass == NULL) {
173 throw GiwsException::JniObjectCreationException(curEnv, this->className());
174         }
175
176         this->instance = curEnv->NewGlobalRef(JObj) ;
177         if(this->instance == NULL){
178 throw GiwsException::JniObjectCreationException(curEnv, this->className());
179         }
180         /* Methods ID set to NULL */
181         jintinvokejintintjstringjava_lang_StringjintArray_intintID=NULL;
182 jintextractjintintjintArray_intintID=NULL;
183 voidinsertjintintjintArray_intintjintintID=NULL;
184 jobjectArray_getInfosID=NULL;
185 voidinitScilabJavaObjectID=NULL;
186 voidgarbageCollectID=NULL;
187 jstringgetRepresentationjintintID=NULL;
188 jbooleanisValidJavaObjectjintintID=NULL;
189 voidenableTracejstringjava_lang_StringID=NULL;
190 voiddisableTraceID=NULL;
191 voidwriteLogjstringjava_lang_StringID=NULL;
192 voidsetFieldjintintjstringjava_lang_StringjintintID=NULL;
193 jintgetFieldjintintjstringjava_lang_StringID=NULL;
194 jintgetFieldTypejintintjstringjava_lang_StringID=NULL;
195 jintjavaCastjintintjstringjava_lang_StringID=NULL;
196 jintjavaCastjintintjintintID=NULL;
197 jstringgetClassNamejintintID=NULL;
198 jintgetArrayElementjintintjintArray_intintID=NULL;
199 voidsetArrayElementjintintjintArray_intintjintintID=NULL;
200 voidremoveScilabJavaObjectjintintID=NULL;
201 voidremoveScilabJavaObjectjintArray_intintID=NULL;
202 voidlimitDirectBufferjintintID=NULL;
203 jintisUnwrappablejintintID=NULL;
204 jintwrapjdoubledoubleID=NULL;
205 jintwrapjdoubleArray_doubledoubleID=NULL;
206 jintwrapjobjectArray__doubledoubleID=NULL;
207 jintwrapjintintID=NULL;
208 jintwrapjintArray_intintID=NULL;
209 jintwrapjobjectArray__intintID=NULL;
210 jintwrapjbytebyteID=NULL;
211 jintwrapjbyteArray_bytebyteID=NULL;
212 jintwrapjobjectArray__bytebyteID=NULL;
213 jintwrapjshortshortID=NULL;
214 jintwrapjshortArray_shortshortID=NULL;
215 jintwrapjobjectArray__shortshortID=NULL;
216 jintwrapjstringjava_lang_StringID=NULL;
217 jintwrapjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
218 jintwrapjobjectArray__java_lang_Stringjava_lang_StringID=NULL;
219 jintwrapjbooleanbooleanID=NULL;
220 jintwrapjbooleanArray_booleanbooleanID=NULL;
221 jintwrapjobjectArray__booleanbooleanID=NULL;
222 jintwrapjcharcharID=NULL;
223 jintwrapjcharArray_charcharID=NULL;
224 jintwrapjobjectArray__charcharID=NULL;
225 jintwrapjfloatfloatID=NULL;
226 jintwrapjfloatArray_floatfloatID=NULL;
227 jintwrapjobjectArray__floatfloatID=NULL;
228 jintwrapjlonglongID=NULL;
229 jintwrapjlongArray_longlongID=NULL;
230 jintwrapjobjectArray__longlongID=NULL;
231 jobjectArray_getAccessibleFieldsjintintID=NULL;
232 jobjectArray_getAccessibleMethodsjintintID=NULL;
233 jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID=NULL;
234
235
236 }
237
238 // Generic methods
239
240 void ScilabJavaObject::synchronize() {
241 if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
242 throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
243 }
244 }
245
246 void ScilabJavaObject::endSynchronize() {
247 if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
248 throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabJavaObject");
249 }
250 }
251 // Method(s)
252
253 int ScilabJavaObject::invoke (JavaVM * jvm_, int id, char const* methodName, int const* args, int argsSize){
254
255 JNIEnv * curEnv = NULL;
256 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
257 jclass cls = initClass(curEnv);
258 if ( cls == NULL) {
259 throw GiwsException::JniCallMethodException(curEnv);
260 }
261
262 static jmethodID jintinvokejintintjstringjava_lang_StringjintArray_intintID = curEnv->GetStaticMethodID(cls, "invoke", "(ILjava/lang/String;[I)I" ) ;
263 if (jintinvokejintintjstringjava_lang_StringjintArray_intintID == NULL) {
264 throw GiwsException::JniMethodNotFoundException(curEnv, "invoke");
265 }
266
267 jstring methodName_ = curEnv->NewStringUTF( methodName );
268 if (methodName != NULL && methodName_ == NULL)
269 {
270 throw GiwsException::JniBadAllocException(curEnv);
271 }
272
273
274 jintArray args_ = curEnv->NewIntArray( argsSize ) ;
275
276 if (args_ == NULL)
277 {
278 // check that allocation succeed
279 throw GiwsException::JniBadAllocException(curEnv);
280 }
281
282 curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
283
284
285                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintinvokejintintjstringjava_lang_StringjintArray_intintID ,id, methodName_, args_));
286                         curEnv->DeleteLocalRef(methodName_);
287 curEnv->DeleteLocalRef(args_);
288 if (curEnv->ExceptionCheck()) {
289 throw GiwsException::JniCallMethodException(curEnv);
290 }
291 return res;
292
293 }
294
295 int ScilabJavaObject::extract (JavaVM * jvm_, int id, int const* args, int argsSize){
296
297 JNIEnv * curEnv = NULL;
298 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
299 jclass cls = initClass(curEnv);
300 if ( cls == NULL) {
301 throw GiwsException::JniCallMethodException(curEnv);
302 }
303
304 static jmethodID jintextractjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "extract", "(I[I)I" ) ;
305 if (jintextractjintintjintArray_intintID == NULL) {
306 throw GiwsException::JniMethodNotFoundException(curEnv, "extract");
307 }
308
309 jintArray args_ = curEnv->NewIntArray( argsSize ) ;
310
311 if (args_ == NULL)
312 {
313 // check that allocation succeed
314 throw GiwsException::JniBadAllocException(curEnv);
315 }
316
317 curEnv->SetIntArrayRegion( args_, 0, argsSize, (jint*)(args) ) ;
318
319
320                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintextractjintintjintArray_intintID ,id, args_));
321                         curEnv->DeleteLocalRef(args_);
322 if (curEnv->ExceptionCheck()) {
323 throw GiwsException::JniCallMethodException(curEnv);
324 }
325 return res;
326
327 }
328
329 void ScilabJavaObject::insert (JavaVM * jvm_, int id, int const* keys, int keysSize, int value){
330
331 JNIEnv * curEnv = NULL;
332 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
333 jclass cls = initClass(curEnv);
334 if ( cls == NULL) {
335 throw GiwsException::JniCallMethodException(curEnv);
336 }
337
338 static jmethodID voidinsertjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "insert", "(I[II)V" ) ;
339 if (voidinsertjintintjintArray_intintjintintID == NULL) {
340 throw GiwsException::JniMethodNotFoundException(curEnv, "insert");
341 }
342
343 jintArray keys_ = curEnv->NewIntArray( keysSize ) ;
344
345 if (keys_ == NULL)
346 {
347 // check that allocation succeed
348 throw GiwsException::JniBadAllocException(curEnv);
349 }
350
351 curEnv->SetIntArrayRegion( keys_, 0, keysSize, (jint*)(keys) ) ;
352
353
354                          curEnv->CallStaticVoidMethod(cls, voidinsertjintintjintArray_intintjintintID ,id, keys_, value);
355                         curEnv->DeleteLocalRef(keys_);
356 if (curEnv->ExceptionCheck()) {
357 throw GiwsException::JniCallMethodException(curEnv);
358 }
359 }
360
361 char** ScilabJavaObject::getInfos (JavaVM * jvm_, int *lenRow){
362
363 JNIEnv * curEnv = NULL;
364 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
365 jclass cls = initClass(curEnv);
366 if ( cls == NULL) {
367 throw GiwsException::JniCallMethodException(curEnv);
368 }
369
370 static jmethodID jobjectArray_getInfosID = curEnv->GetStaticMethodID(cls, "getInfos", "()[Ljava/lang/String;" ) ;
371 if (jobjectArray_getInfosID == NULL) {
372 throw GiwsException::JniMethodNotFoundException(curEnv, "getInfos");
373 }
374
375                         jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getInfosID ));
376                         if (curEnv->ExceptionCheck()) {
377 throw GiwsException::JniCallMethodException(curEnv);
378 }if (res != NULL) { 
379 * lenRow = curEnv->GetArrayLength(res);
380
381 char **arrayOfString;
382 arrayOfString = new char *[*lenRow];
383 for (jsize i = 0; i < *lenRow; i++){
384 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
385 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
386 arrayOfString[i] = new char[strlen(tempString) + 1];
387
388 strcpy(arrayOfString[i], tempString);
389 curEnv->ReleaseStringUTFChars(resString, tempString);
390 curEnv->DeleteLocalRef(resString);
391 }
392 if (curEnv->ExceptionCheck()) {
393 delete[] arrayOfString;
394                                 throw GiwsException::JniCallMethodException(curEnv);
395 }
396 curEnv->DeleteLocalRef(res);
397 return arrayOfString;
398  } else { 
399 curEnv->DeleteLocalRef(res);
400 return NULL;
401 }
402 }
403
404 void ScilabJavaObject::initScilabJavaObject (JavaVM * jvm_){
405
406 JNIEnv * curEnv = NULL;
407 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
408 jclass cls = initClass(curEnv);
409 if ( cls == NULL) {
410 throw GiwsException::JniCallMethodException(curEnv);
411 }
412
413 static jmethodID voidinitScilabJavaObjectID = curEnv->GetStaticMethodID(cls, "initScilabJavaObject", "()V" ) ;
414 if (voidinitScilabJavaObjectID == NULL) {
415 throw GiwsException::JniMethodNotFoundException(curEnv, "initScilabJavaObject");
416 }
417
418                          curEnv->CallStaticVoidMethod(cls, voidinitScilabJavaObjectID );
419                         if (curEnv->ExceptionCheck()) {
420 throw GiwsException::JniCallMethodException(curEnv);
421 }
422 }
423
424 void ScilabJavaObject::garbageCollect (JavaVM * jvm_){
425
426 JNIEnv * curEnv = NULL;
427 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
428 jclass cls = initClass(curEnv);
429 if ( cls == NULL) {
430 throw GiwsException::JniCallMethodException(curEnv);
431 }
432
433 static jmethodID voidgarbageCollectID = curEnv->GetStaticMethodID(cls, "garbageCollect", "()V" ) ;
434 if (voidgarbageCollectID == NULL) {
435 throw GiwsException::JniMethodNotFoundException(curEnv, "garbageCollect");
436 }
437
438                          curEnv->CallStaticVoidMethod(cls, voidgarbageCollectID );
439                         if (curEnv->ExceptionCheck()) {
440 throw GiwsException::JniCallMethodException(curEnv);
441 }
442 }
443
444 char* ScilabJavaObject::getRepresentation (JavaVM * jvm_, int id){
445
446 JNIEnv * curEnv = NULL;
447 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
448 jclass cls = initClass(curEnv);
449 if ( cls == NULL) {
450 throw GiwsException::JniCallMethodException(curEnv);
451 }
452
453 static jmethodID jstringgetRepresentationjintintID = curEnv->GetStaticMethodID(cls, "getRepresentation", "(I)Ljava/lang/String;" ) ;
454 if (jstringgetRepresentationjintintID == NULL) {
455 throw GiwsException::JniMethodNotFoundException(curEnv, "getRepresentation");
456 }
457
458                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetRepresentationjintintID ,id));
459                         if (curEnv->ExceptionCheck()) {
460 throw GiwsException::JniCallMethodException(curEnv);
461 }if (res != NULL) { 
462
463 const char *tempString = curEnv->GetStringUTFChars(res, 0);
464 char * myStringBuffer = new char[strlen(tempString) + 1];
465 strcpy(myStringBuffer, tempString);
466 curEnv->ReleaseStringUTFChars(res, tempString);
467 curEnv->DeleteLocalRef(res);
468 if (curEnv->ExceptionCheck()) {
469 delete[] myStringBuffer;
470                                 throw GiwsException::JniCallMethodException(curEnv);
471 }
472 return myStringBuffer;
473  } else { 
474 curEnv->DeleteLocalRef(res);
475 return NULL;
476 }
477 }
478
479 bool ScilabJavaObject::isValidJavaObject (JavaVM * jvm_, int id){
480
481 JNIEnv * curEnv = NULL;
482 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
483 jclass cls = initClass(curEnv);
484 if ( cls == NULL) {
485 throw GiwsException::JniCallMethodException(curEnv);
486 }
487
488 static jmethodID jbooleanisValidJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "isValidJavaObject", "(I)Z" ) ;
489 if (jbooleanisValidJavaObjectjintintID == NULL) {
490 throw GiwsException::JniMethodNotFoundException(curEnv, "isValidJavaObject");
491 }
492
493                         jboolean res =  static_cast<jboolean>( curEnv->CallStaticBooleanMethod(cls, jbooleanisValidJavaObjectjintintID ,id));
494                         if (curEnv->ExceptionCheck()) {
495 throw GiwsException::JniCallMethodException(curEnv);
496 }
497 return (res == JNI_TRUE);
498
499 }
500
501 void ScilabJavaObject::enableTrace (JavaVM * jvm_, char const* filename){
502
503 JNIEnv * curEnv = NULL;
504 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
505 jclass cls = initClass(curEnv);
506 if ( cls == NULL) {
507 throw GiwsException::JniCallMethodException(curEnv);
508 }
509
510 static jmethodID voidenableTracejstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "enableTrace", "(Ljava/lang/String;)V" ) ;
511 if (voidenableTracejstringjava_lang_StringID == NULL) {
512 throw GiwsException::JniMethodNotFoundException(curEnv, "enableTrace");
513 }
514
515 jstring filename_ = curEnv->NewStringUTF( filename );
516 if (filename != NULL && filename_ == NULL)
517 {
518 throw GiwsException::JniBadAllocException(curEnv);
519 }
520
521
522                          curEnv->CallStaticVoidMethod(cls, voidenableTracejstringjava_lang_StringID ,filename_);
523                         curEnv->DeleteLocalRef(filename_);
524 if (curEnv->ExceptionCheck()) {
525 throw GiwsException::JniCallMethodException(curEnv);
526 }
527 }
528
529 void ScilabJavaObject::disableTrace (JavaVM * jvm_){
530
531 JNIEnv * curEnv = NULL;
532 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
533 jclass cls = initClass(curEnv);
534 if ( cls == NULL) {
535 throw GiwsException::JniCallMethodException(curEnv);
536 }
537
538 static jmethodID voiddisableTraceID = curEnv->GetStaticMethodID(cls, "disableTrace", "()V" ) ;
539 if (voiddisableTraceID == NULL) {
540 throw GiwsException::JniMethodNotFoundException(curEnv, "disableTrace");
541 }
542
543                          curEnv->CallStaticVoidMethod(cls, voiddisableTraceID );
544                         if (curEnv->ExceptionCheck()) {
545 throw GiwsException::JniCallMethodException(curEnv);
546 }
547 }
548
549 void ScilabJavaObject::writeLog (JavaVM * jvm_, char const* s){
550
551 JNIEnv * curEnv = NULL;
552 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
553 jclass cls = initClass(curEnv);
554 if ( cls == NULL) {
555 throw GiwsException::JniCallMethodException(curEnv);
556 }
557
558 static jmethodID voidwriteLogjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "writeLog", "(Ljava/lang/String;)V" ) ;
559 if (voidwriteLogjstringjava_lang_StringID == NULL) {
560 throw GiwsException::JniMethodNotFoundException(curEnv, "writeLog");
561 }
562
563 jstring s_ = curEnv->NewStringUTF( s );
564 if (s != NULL && s_ == NULL)
565 {
566 throw GiwsException::JniBadAllocException(curEnv);
567 }
568
569
570                          curEnv->CallStaticVoidMethod(cls, voidwriteLogjstringjava_lang_StringID ,s_);
571                         curEnv->DeleteLocalRef(s_);
572 if (curEnv->ExceptionCheck()) {
573 throw GiwsException::JniCallMethodException(curEnv);
574 }
575 }
576
577 void ScilabJavaObject::setField (JavaVM * jvm_, int id, char const* fieldName, int idarg){
578
579 JNIEnv * curEnv = NULL;
580 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
581 jclass cls = initClass(curEnv);
582 if ( cls == NULL) {
583 throw GiwsException::JniCallMethodException(curEnv);
584 }
585
586 static jmethodID voidsetFieldjintintjstringjava_lang_StringjintintID = curEnv->GetStaticMethodID(cls, "setField", "(ILjava/lang/String;I)V" ) ;
587 if (voidsetFieldjintintjstringjava_lang_StringjintintID == NULL) {
588 throw GiwsException::JniMethodNotFoundException(curEnv, "setField");
589 }
590
591 jstring fieldName_ = curEnv->NewStringUTF( fieldName );
592 if (fieldName != NULL && fieldName_ == NULL)
593 {
594 throw GiwsException::JniBadAllocException(curEnv);
595 }
596
597
598                          curEnv->CallStaticVoidMethod(cls, voidsetFieldjintintjstringjava_lang_StringjintintID ,id, fieldName_, idarg);
599                         curEnv->DeleteLocalRef(fieldName_);
600 if (curEnv->ExceptionCheck()) {
601 throw GiwsException::JniCallMethodException(curEnv);
602 }
603 }
604
605 int ScilabJavaObject::getField (JavaVM * jvm_, int id, char const* fieldName){
606
607 JNIEnv * curEnv = NULL;
608 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
609 jclass cls = initClass(curEnv);
610 if ( cls == NULL) {
611 throw GiwsException::JniCallMethodException(curEnv);
612 }
613
614 static jmethodID jintgetFieldjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getField", "(ILjava/lang/String;)I" ) ;
615 if (jintgetFieldjintintjstringjava_lang_StringID == NULL) {
616 throw GiwsException::JniMethodNotFoundException(curEnv, "getField");
617 }
618
619 jstring fieldName_ = curEnv->NewStringUTF( fieldName );
620 if (fieldName != NULL && fieldName_ == NULL)
621 {
622 throw GiwsException::JniBadAllocException(curEnv);
623 }
624
625
626                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFieldjintintjstringjava_lang_StringID ,id, fieldName_));
627                         curEnv->DeleteLocalRef(fieldName_);
628 if (curEnv->ExceptionCheck()) {
629 throw GiwsException::JniCallMethodException(curEnv);
630 }
631 return res;
632
633 }
634
635 int ScilabJavaObject::getFieldType (JavaVM * jvm_, int id, char const* fieldName){
636
637 JNIEnv * curEnv = NULL;
638 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
639 jclass cls = initClass(curEnv);
640 if ( cls == NULL) {
641 throw GiwsException::JniCallMethodException(curEnv);
642 }
643
644 static jmethodID jintgetFieldTypejintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getFieldType", "(ILjava/lang/String;)I" ) ;
645 if (jintgetFieldTypejintintjstringjava_lang_StringID == NULL) {
646 throw GiwsException::JniMethodNotFoundException(curEnv, "getFieldType");
647 }
648
649 jstring fieldName_ = curEnv->NewStringUTF( fieldName );
650 if (fieldName != NULL && fieldName_ == NULL)
651 {
652 throw GiwsException::JniBadAllocException(curEnv);
653 }
654
655
656                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetFieldTypejintintjstringjava_lang_StringID ,id, fieldName_));
657                         curEnv->DeleteLocalRef(fieldName_);
658 if (curEnv->ExceptionCheck()) {
659 throw GiwsException::JniCallMethodException(curEnv);
660 }
661 return res;
662
663 }
664
665 int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, char const* objName){
666
667 JNIEnv * curEnv = NULL;
668 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
669 jclass cls = initClass(curEnv);
670 if ( cls == NULL) {
671 throw GiwsException::JniCallMethodException(curEnv);
672 }
673
674 static jmethodID jintjavaCastjintintjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "javaCast", "(ILjava/lang/String;)I" ) ;
675 if (jintjavaCastjintintjstringjava_lang_StringID == NULL) {
676 throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
677 }
678
679 jstring objName_ = curEnv->NewStringUTF( objName );
680 if (objName != NULL && objName_ == NULL)
681 {
682 throw GiwsException::JniBadAllocException(curEnv);
683 }
684
685
686                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintjavaCastjintintjstringjava_lang_StringID ,id, objName_));
687                         curEnv->DeleteLocalRef(objName_);
688 if (curEnv->ExceptionCheck()) {
689 throw GiwsException::JniCallMethodException(curEnv);
690 }
691 return res;
692
693 }
694
695 int ScilabJavaObject::javaCast (JavaVM * jvm_, int id, int classId){
696
697 JNIEnv * curEnv = NULL;
698 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
699 jclass cls = initClass(curEnv);
700 if ( cls == NULL) {
701 throw GiwsException::JniCallMethodException(curEnv);
702 }
703
704 static jmethodID jintjavaCastjintintjintintID = curEnv->GetStaticMethodID(cls, "javaCast", "(II)I" ) ;
705 if (jintjavaCastjintintjintintID == NULL) {
706 throw GiwsException::JniMethodNotFoundException(curEnv, "javaCast");
707 }
708
709                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintjavaCastjintintjintintID ,id, classId));
710                         if (curEnv->ExceptionCheck()) {
711 throw GiwsException::JniCallMethodException(curEnv);
712 }
713 return res;
714
715 }
716
717 char* ScilabJavaObject::getClassName (JavaVM * jvm_, int id){
718
719 JNIEnv * curEnv = NULL;
720 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
721 jclass cls = initClass(curEnv);
722 if ( cls == NULL) {
723 throw GiwsException::JniCallMethodException(curEnv);
724 }
725
726 static jmethodID jstringgetClassNamejintintID = curEnv->GetStaticMethodID(cls, "getClassName", "(I)Ljava/lang/String;" ) ;
727 if (jstringgetClassNamejintintID == NULL) {
728 throw GiwsException::JniMethodNotFoundException(curEnv, "getClassName");
729 }
730
731                         jstring res =  static_cast<jstring>( curEnv->CallStaticObjectMethod(cls, jstringgetClassNamejintintID ,id));
732                         if (curEnv->ExceptionCheck()) {
733 throw GiwsException::JniCallMethodException(curEnv);
734 }if (res != NULL) { 
735
736 const char *tempString = curEnv->GetStringUTFChars(res, 0);
737 char * myStringBuffer = new char[strlen(tempString) + 1];
738 strcpy(myStringBuffer, tempString);
739 curEnv->ReleaseStringUTFChars(res, tempString);
740 curEnv->DeleteLocalRef(res);
741 if (curEnv->ExceptionCheck()) {
742 delete[] myStringBuffer;
743                                 throw GiwsException::JniCallMethodException(curEnv);
744 }
745 return myStringBuffer;
746  } else { 
747 curEnv->DeleteLocalRef(res);
748 return NULL;
749 }
750 }
751
752 int ScilabJavaObject::getArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize){
753
754 JNIEnv * curEnv = NULL;
755 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
756 jclass cls = initClass(curEnv);
757 if ( cls == NULL) {
758 throw GiwsException::JniCallMethodException(curEnv);
759 }
760
761 static jmethodID jintgetArrayElementjintintjintArray_intintID = curEnv->GetStaticMethodID(cls, "getArrayElement", "(I[I)I" ) ;
762 if (jintgetArrayElementjintintjintArray_intintID == NULL) {
763 throw GiwsException::JniMethodNotFoundException(curEnv, "getArrayElement");
764 }
765
766 jintArray index_ = curEnv->NewIntArray( indexSize ) ;
767
768 if (index_ == NULL)
769 {
770 // check that allocation succeed
771 throw GiwsException::JniBadAllocException(curEnv);
772 }
773
774 curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
775
776
777                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintgetArrayElementjintintjintArray_intintID ,id, index_));
778                         curEnv->DeleteLocalRef(index_);
779 if (curEnv->ExceptionCheck()) {
780 throw GiwsException::JniCallMethodException(curEnv);
781 }
782 return res;
783
784 }
785
786 void ScilabJavaObject::setArrayElement (JavaVM * jvm_, int id, int const* index, int indexSize, int idArg){
787
788 JNIEnv * curEnv = NULL;
789 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
790 jclass cls = initClass(curEnv);
791 if ( cls == NULL) {
792 throw GiwsException::JniCallMethodException(curEnv);
793 }
794
795 static jmethodID voidsetArrayElementjintintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "setArrayElement", "(I[II)V" ) ;
796 if (voidsetArrayElementjintintjintArray_intintjintintID == NULL) {
797 throw GiwsException::JniMethodNotFoundException(curEnv, "setArrayElement");
798 }
799
800 jintArray index_ = curEnv->NewIntArray( indexSize ) ;
801
802 if (index_ == NULL)
803 {
804 // check that allocation succeed
805 throw GiwsException::JniBadAllocException(curEnv);
806 }
807
808 curEnv->SetIntArrayRegion( index_, 0, indexSize, (jint*)(index) ) ;
809
810
811                          curEnv->CallStaticVoidMethod(cls, voidsetArrayElementjintintjintArray_intintjintintID ,id, index_, idArg);
812                         curEnv->DeleteLocalRef(index_);
813 if (curEnv->ExceptionCheck()) {
814 throw GiwsException::JniCallMethodException(curEnv);
815 }
816 }
817
818 void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int id){
819
820 JNIEnv * curEnv = NULL;
821 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
822 jclass cls = initClass(curEnv);
823 if ( cls == NULL) {
824 throw GiwsException::JniCallMethodException(curEnv);
825 }
826
827 static jmethodID voidremoveScilabJavaObjectjintintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "(I)V" ) ;
828 if (voidremoveScilabJavaObjectjintintID == NULL) {
829 throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
830 }
831
832                          curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintintID ,id);
833                         if (curEnv->ExceptionCheck()) {
834 throw GiwsException::JniCallMethodException(curEnv);
835 }
836 }
837
838 void ScilabJavaObject::removeScilabJavaObject (JavaVM * jvm_, int const* id, int idSize){
839
840 JNIEnv * curEnv = NULL;
841 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
842 jclass cls = initClass(curEnv);
843 if ( cls == NULL) {
844 throw GiwsException::JniCallMethodException(curEnv);
845 }
846
847 static jmethodID voidremoveScilabJavaObjectjintArray_intintID = curEnv->GetStaticMethodID(cls, "removeScilabJavaObject", "([I)V" ) ;
848 if (voidremoveScilabJavaObjectjintArray_intintID == NULL) {
849 throw GiwsException::JniMethodNotFoundException(curEnv, "removeScilabJavaObject");
850 }
851
852 jintArray id_ = curEnv->NewIntArray( idSize ) ;
853
854 if (id_ == NULL)
855 {
856 // check that allocation succeed
857 throw GiwsException::JniBadAllocException(curEnv);
858 }
859
860 curEnv->SetIntArrayRegion( id_, 0, idSize, (jint*)(id) ) ;
861
862
863                          curEnv->CallStaticVoidMethod(cls, voidremoveScilabJavaObjectjintArray_intintID ,id_);
864                         curEnv->DeleteLocalRef(id_);
865 if (curEnv->ExceptionCheck()) {
866 throw GiwsException::JniCallMethodException(curEnv);
867 }
868 }
869
870 void ScilabJavaObject::limitDirectBuffer (JavaVM * jvm_, int id){
871
872 JNIEnv * curEnv = NULL;
873 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
874 jclass cls = initClass(curEnv);
875 if ( cls == NULL) {
876 throw GiwsException::JniCallMethodException(curEnv);
877 }
878
879 static jmethodID voidlimitDirectBufferjintintID = curEnv->GetStaticMethodID(cls, "limitDirectBuffer", "(I)V" ) ;
880 if (voidlimitDirectBufferjintintID == NULL) {
881 throw GiwsException::JniMethodNotFoundException(curEnv, "limitDirectBuffer");
882 }
883
884                          curEnv->CallStaticVoidMethod(cls, voidlimitDirectBufferjintintID ,id);
885                         if (curEnv->ExceptionCheck()) {
886 throw GiwsException::JniCallMethodException(curEnv);
887 }
888 }
889
890 int ScilabJavaObject::isUnwrappable (JavaVM * jvm_, int id){
891
892 JNIEnv * curEnv = NULL;
893 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
894 jclass cls = initClass(curEnv);
895 if ( cls == NULL) {
896 throw GiwsException::JniCallMethodException(curEnv);
897 }
898
899 static jmethodID jintisUnwrappablejintintID = curEnv->GetStaticMethodID(cls, "isUnwrappable", "(I)I" ) ;
900 if (jintisUnwrappablejintintID == NULL) {
901 throw GiwsException::JniMethodNotFoundException(curEnv, "isUnwrappable");
902 }
903
904                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintisUnwrappablejintintID ,id));
905                         if (curEnv->ExceptionCheck()) {
906 throw GiwsException::JniCallMethodException(curEnv);
907 }
908 return res;
909
910 }
911
912 int ScilabJavaObject::wrap (JavaVM * jvm_, double x){
913
914 JNIEnv * curEnv = NULL;
915 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
916 jclass cls = initClass(curEnv);
917 if ( cls == NULL) {
918 throw GiwsException::JniCallMethodException(curEnv);
919 }
920
921 static jmethodID jintwrapjdoubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "(D)I" ) ;
922 if (jintwrapjdoubledoubleID == NULL) {
923 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
924 }
925
926                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubledoubleID ,x));
927                         if (curEnv->ExceptionCheck()) {
928 throw GiwsException::JniCallMethodException(curEnv);
929 }
930 return res;
931
932 }
933
934 int ScilabJavaObject::wrap (JavaVM * jvm_, double const* x, int xSize){
935
936 JNIEnv * curEnv = NULL;
937 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
938 jclass cls = initClass(curEnv);
939 if ( cls == NULL) {
940 throw GiwsException::JniCallMethodException(curEnv);
941 }
942
943 static jmethodID jintwrapjdoubleArray_doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([D)I" ) ;
944 if (jintwrapjdoubleArray_doubledoubleID == NULL) {
945 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
946 }
947
948 jdoubleArray x_ = curEnv->NewDoubleArray( xSize ) ;
949
950 if (x_ == NULL)
951 {
952 // check that allocation succeed
953 throw GiwsException::JniBadAllocException(curEnv);
954 }
955
956 curEnv->SetDoubleArrayRegion( x_, 0, xSize, (jdouble*)(x) ) ;
957
958
959                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjdoubleArray_doubledoubleID ,x_));
960                         curEnv->DeleteLocalRef(x_);
961 if (curEnv->ExceptionCheck()) {
962 throw GiwsException::JniCallMethodException(curEnv);
963 }
964 return res;
965
966 }
967
968 int ScilabJavaObject::wrap (JavaVM * jvm_, double const* const* x, int xSize, int xSizeCol){
969
970 JNIEnv * curEnv = NULL;
971 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
972 jclass cls = initClass(curEnv);
973 if ( cls == NULL) {
974 throw GiwsException::JniCallMethodException(curEnv);
975 }
976
977 static jmethodID jintwrapjobjectArray__doubledoubleID = curEnv->GetStaticMethodID(cls, "wrap", "([[D)I" ) ;
978 if (jintwrapjobjectArray__doubledoubleID == NULL) {
979 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
980 }
981
982  jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[D"),NULL);
983
984 if (x_ == NULL)
985 {
986 // check that allocation succeed
987 throw GiwsException::JniBadAllocException(curEnv);
988 }
989
990  for (int i=0; i<xSize; i++){
991
992 jdoubleArray xLocal = curEnv->NewDoubleArray( xSizeCol ) ;
993
994 if (xLocal == NULL)
995 {
996 // check that allocation succeed
997 curEnv->DeleteLocalRef(x_);
998 throw GiwsException::JniBadAllocException(curEnv);
999 }
1000
1001 curEnv->SetDoubleArrayRegion( xLocal, 0, xSizeCol, (jdouble*)(x[i]) ) ;
1002 curEnv->SetObjectArrayElement(x_, i, xLocal);
1003 curEnv->DeleteLocalRef(xLocal);
1004 }
1005
1006                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__doubledoubleID ,x_));
1007                         curEnv->DeleteLocalRef(x_);
1008 if (curEnv->ExceptionCheck()) {
1009 throw GiwsException::JniCallMethodException(curEnv);
1010 }
1011 return res;
1012
1013 }
1014
1015 int ScilabJavaObject::wrap (JavaVM * jvm_, int x){
1016
1017 JNIEnv * curEnv = NULL;
1018 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1019 jclass cls = initClass(curEnv);
1020 if ( cls == NULL) {
1021 throw GiwsException::JniCallMethodException(curEnv);
1022 }
1023
1024 static jmethodID jintwrapjintintID = curEnv->GetStaticMethodID(cls, "wrap", "(I)I" ) ;
1025 if (jintwrapjintintID == NULL) {
1026 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1027 }
1028
1029                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintintID ,x));
1030                         if (curEnv->ExceptionCheck()) {
1031 throw GiwsException::JniCallMethodException(curEnv);
1032 }
1033 return res;
1034
1035 }
1036
1037 int ScilabJavaObject::wrap (JavaVM * jvm_, int const* x, int xSize){
1038
1039 JNIEnv * curEnv = NULL;
1040 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1041 jclass cls = initClass(curEnv);
1042 if ( cls == NULL) {
1043 throw GiwsException::JniCallMethodException(curEnv);
1044 }
1045
1046 static jmethodID jintwrapjintArray_intintID = curEnv->GetStaticMethodID(cls, "wrap", "([I)I" ) ;
1047 if (jintwrapjintArray_intintID == NULL) {
1048 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1049 }
1050
1051 jintArray x_ = curEnv->NewIntArray( xSize ) ;
1052
1053 if (x_ == NULL)
1054 {
1055 // check that allocation succeed
1056 throw GiwsException::JniBadAllocException(curEnv);
1057 }
1058
1059 curEnv->SetIntArrayRegion( x_, 0, xSize, (jint*)(x) ) ;
1060
1061
1062                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjintArray_intintID ,x_));
1063                         curEnv->DeleteLocalRef(x_);
1064 if (curEnv->ExceptionCheck()) {
1065 throw GiwsException::JniCallMethodException(curEnv);
1066 }
1067 return res;
1068
1069 }
1070
1071 int ScilabJavaObject::wrap (JavaVM * jvm_, int const* const* x, int xSize, int xSizeCol){
1072
1073 JNIEnv * curEnv = NULL;
1074 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1075 jclass cls = initClass(curEnv);
1076 if ( cls == NULL) {
1077 throw GiwsException::JniCallMethodException(curEnv);
1078 }
1079
1080 static jmethodID jintwrapjobjectArray__intintID = curEnv->GetStaticMethodID(cls, "wrap", "([[I)I" ) ;
1081 if (jintwrapjobjectArray__intintID == NULL) {
1082 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1083 }
1084
1085  jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[I"),NULL);
1086
1087 if (x_ == NULL)
1088 {
1089 // check that allocation succeed
1090 throw GiwsException::JniBadAllocException(curEnv);
1091 }
1092
1093  for (int i=0; i<xSize; i++){
1094
1095 jintArray xLocal = curEnv->NewIntArray( xSizeCol ) ;
1096
1097 if (xLocal == NULL)
1098 {
1099 // check that allocation succeed
1100 curEnv->DeleteLocalRef(x_);
1101 throw GiwsException::JniBadAllocException(curEnv);
1102 }
1103
1104 curEnv->SetIntArrayRegion( xLocal, 0, xSizeCol, (jint*)(x[i]) ) ;
1105 curEnv->SetObjectArrayElement(x_, i, xLocal);
1106 curEnv->DeleteLocalRef(xLocal);
1107 }
1108
1109                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__intintID ,x_));
1110                         curEnv->DeleteLocalRef(x_);
1111 if (curEnv->ExceptionCheck()) {
1112 throw GiwsException::JniCallMethodException(curEnv);
1113 }
1114 return res;
1115
1116 }
1117
1118 int ScilabJavaObject::wrap (JavaVM * jvm_, byte x){
1119
1120 JNIEnv * curEnv = NULL;
1121 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1122 jclass cls = initClass(curEnv);
1123 if ( cls == NULL) {
1124 throw GiwsException::JniCallMethodException(curEnv);
1125 }
1126
1127 static jmethodID jintwrapjbytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "(B)I" ) ;
1128 if (jintwrapjbytebyteID == NULL) {
1129 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1130 }
1131
1132                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbytebyteID ,x));
1133                         if (curEnv->ExceptionCheck()) {
1134 throw GiwsException::JniCallMethodException(curEnv);
1135 }
1136 return res;
1137
1138 }
1139
1140 int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* x, int xSize){
1141
1142 JNIEnv * curEnv = NULL;
1143 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1144 jclass cls = initClass(curEnv);
1145 if ( cls == NULL) {
1146 throw GiwsException::JniCallMethodException(curEnv);
1147 }
1148
1149 static jmethodID jintwrapjbyteArray_bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([B)I" ) ;
1150 if (jintwrapjbyteArray_bytebyteID == NULL) {
1151 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1152 }
1153
1154 jbyteArray x_ = curEnv->NewByteArray( xSize ) ;
1155
1156 if (x_ == NULL)
1157 {
1158 // check that allocation succeed
1159 throw GiwsException::JniBadAllocException(curEnv);
1160 }
1161
1162 curEnv->SetByteArrayRegion( x_, 0, xSize, (jbyte*)(x) ) ;
1163
1164
1165                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbyteArray_bytebyteID ,x_));
1166                         curEnv->DeleteLocalRef(x_);
1167 if (curEnv->ExceptionCheck()) {
1168 throw GiwsException::JniCallMethodException(curEnv);
1169 }
1170 return res;
1171
1172 }
1173
1174 int ScilabJavaObject::wrap (JavaVM * jvm_, byte const* const* x, int xSize, int xSizeCol){
1175
1176 JNIEnv * curEnv = NULL;
1177 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1178 jclass cls = initClass(curEnv);
1179 if ( cls == NULL) {
1180 throw GiwsException::JniCallMethodException(curEnv);
1181 }
1182
1183 static jmethodID jintwrapjobjectArray__bytebyteID = curEnv->GetStaticMethodID(cls, "wrap", "([[B)I" ) ;
1184 if (jintwrapjobjectArray__bytebyteID == NULL) {
1185 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1186 }
1187
1188  jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[B"),NULL);
1189
1190 if (x_ == NULL)
1191 {
1192 // check that allocation succeed
1193 throw GiwsException::JniBadAllocException(curEnv);
1194 }
1195
1196  for (int i=0; i<xSize; i++){
1197
1198 jbyteArray xLocal = curEnv->NewByteArray( xSizeCol ) ;
1199
1200 if (xLocal == NULL)
1201 {
1202 // check that allocation succeed
1203 curEnv->DeleteLocalRef(x_);
1204 throw GiwsException::JniBadAllocException(curEnv);
1205 }
1206
1207 curEnv->SetByteArrayRegion( xLocal, 0, xSizeCol, (jbyte*)(x[i]) ) ;
1208 curEnv->SetObjectArrayElement(x_, i, xLocal);
1209 curEnv->DeleteLocalRef(xLocal);
1210 }
1211
1212                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__bytebyteID ,x_));
1213                         curEnv->DeleteLocalRef(x_);
1214 if (curEnv->ExceptionCheck()) {
1215 throw GiwsException::JniCallMethodException(curEnv);
1216 }
1217 return res;
1218
1219 }
1220
1221 int ScilabJavaObject::wrap (JavaVM * jvm_, short x){
1222
1223 JNIEnv * curEnv = NULL;
1224 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1225 jclass cls = initClass(curEnv);
1226 if ( cls == NULL) {
1227 throw GiwsException::JniCallMethodException(curEnv);
1228 }
1229
1230 static jmethodID jintwrapjshortshortID = curEnv->GetStaticMethodID(cls, "wrap", "(S)I" ) ;
1231 if (jintwrapjshortshortID == NULL) {
1232 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1233 }
1234
1235                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortshortID ,x));
1236                         if (curEnv->ExceptionCheck()) {
1237 throw GiwsException::JniCallMethodException(curEnv);
1238 }
1239 return res;
1240
1241 }
1242
1243 int ScilabJavaObject::wrap (JavaVM * jvm_, short const* x, int xSize){
1244
1245 JNIEnv * curEnv = NULL;
1246 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1247 jclass cls = initClass(curEnv);
1248 if ( cls == NULL) {
1249 throw GiwsException::JniCallMethodException(curEnv);
1250 }
1251
1252 static jmethodID jintwrapjshortArray_shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([S)I" ) ;
1253 if (jintwrapjshortArray_shortshortID == NULL) {
1254 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1255 }
1256
1257 jshortArray x_ = curEnv->NewShortArray( xSize ) ;
1258
1259 if (x_ == NULL)
1260 {
1261 // check that allocation succeed
1262 throw GiwsException::JniBadAllocException(curEnv);
1263 }
1264
1265 curEnv->SetShortArrayRegion( x_, 0, xSize, (jshort*)(x) ) ;
1266
1267
1268                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjshortArray_shortshortID ,x_));
1269                         curEnv->DeleteLocalRef(x_);
1270 if (curEnv->ExceptionCheck()) {
1271 throw GiwsException::JniCallMethodException(curEnv);
1272 }
1273 return res;
1274
1275 }
1276
1277 int ScilabJavaObject::wrap (JavaVM * jvm_, short const* const* x, int xSize, int xSizeCol){
1278
1279 JNIEnv * curEnv = NULL;
1280 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1281 jclass cls = initClass(curEnv);
1282 if ( cls == NULL) {
1283 throw GiwsException::JniCallMethodException(curEnv);
1284 }
1285
1286 static jmethodID jintwrapjobjectArray__shortshortID = curEnv->GetStaticMethodID(cls, "wrap", "([[S)I" ) ;
1287 if (jintwrapjobjectArray__shortshortID == NULL) {
1288 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1289 }
1290
1291  jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[S"),NULL);
1292
1293 if (x_ == NULL)
1294 {
1295 // check that allocation succeed
1296 throw GiwsException::JniBadAllocException(curEnv);
1297 }
1298
1299  for (int i=0; i<xSize; i++){
1300
1301 jshortArray xLocal = curEnv->NewShortArray( xSizeCol ) ;
1302
1303 if (xLocal == NULL)
1304 {
1305 // check that allocation succeed
1306 curEnv->DeleteLocalRef(x_);
1307 throw GiwsException::JniBadAllocException(curEnv);
1308 }
1309
1310 curEnv->SetShortArrayRegion( xLocal, 0, xSizeCol, (jshort*)(x[i]) ) ;
1311 curEnv->SetObjectArrayElement(x_, i, xLocal);
1312 curEnv->DeleteLocalRef(xLocal);
1313 }
1314
1315                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__shortshortID ,x_));
1316                         curEnv->DeleteLocalRef(x_);
1317 if (curEnv->ExceptionCheck()) {
1318 throw GiwsException::JniCallMethodException(curEnv);
1319 }
1320 return res;
1321
1322 }
1323
1324 int ScilabJavaObject::wrap (JavaVM * jvm_, char const* x){
1325
1326 JNIEnv * curEnv = NULL;
1327 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1328 jclass cls = initClass(curEnv);
1329 if ( cls == NULL) {
1330 throw GiwsException::JniCallMethodException(curEnv);
1331 }
1332
1333 static jmethodID jintwrapjstringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "(Ljava/lang/String;)I" ) ;
1334 if (jintwrapjstringjava_lang_StringID == NULL) {
1335 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1336 }
1337
1338 jstring x_ = curEnv->NewStringUTF( x );
1339 if (x != NULL && x_ == NULL)
1340 {
1341 throw GiwsException::JniBadAllocException(curEnv);
1342 }
1343
1344
1345                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjstringjava_lang_StringID ,x_));
1346                         curEnv->DeleteLocalRef(x_);
1347 if (curEnv->ExceptionCheck()) {
1348 throw GiwsException::JniCallMethodException(curEnv);
1349 }
1350 return res;
1351
1352 }
1353
1354 int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* x, int xSize){
1355
1356 JNIEnv * curEnv = NULL;
1357 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1358 jclass cls = initClass(curEnv);
1359 if ( cls == NULL) {
1360 throw GiwsException::JniCallMethodException(curEnv);
1361 }
1362
1363 static jmethodID jintwrapjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "([Ljava/lang/String;)I" ) ;
1364 if (jintwrapjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
1365 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1366 }
1367 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
1368
1369 // create java array of strings.
1370 jobjectArray x_ = curEnv->NewObjectArray( xSize, stringArrayClass, NULL);
1371 if (x_ == NULL)
1372 {
1373 throw GiwsException::JniBadAllocException(curEnv);
1374 }
1375
1376 // convert each char * to java strings and fill the java array.
1377 for ( int i = 0; i < xSize; i++)
1378 {
1379 jstring TempString = curEnv->NewStringUTF( x[i] );
1380 if (TempString == NULL)
1381 {
1382 throw GiwsException::JniBadAllocException(curEnv);
1383 }
1384
1385 curEnv->SetObjectArrayElement( x_, i, TempString);
1386
1387 // avoid keeping reference on too many strings
1388 curEnv->DeleteLocalRef(TempString);
1389 }
1390                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray_java_lang_Stringjava_lang_StringID ,x_));
1391                         curEnv->DeleteLocalRef(stringArrayClass);
1392 curEnv->DeleteLocalRef(x_);
1393 if (curEnv->ExceptionCheck()) {
1394 throw GiwsException::JniCallMethodException(curEnv);
1395 }
1396 return res;
1397
1398 }
1399
1400 int ScilabJavaObject::wrap (JavaVM * jvm_, char const* const* const* x, int xSize, int xSizeCol){
1401
1402 JNIEnv * curEnv = NULL;
1403 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1404 jclass cls = initClass(curEnv);
1405 if ( cls == NULL) {
1406 throw GiwsException::JniCallMethodException(curEnv);
1407 }
1408
1409 static jmethodID jintwrapjobjectArray__java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "wrap", "([[Ljava/lang/String;)I" ) ;
1410 if (jintwrapjobjectArray__java_lang_Stringjava_lang_StringID == NULL) {
1411 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1412 }
1413 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
1414 // create java array of array of strings.
1415 jobjectArray x_ = curEnv->NewObjectArray( xSize, curEnv->FindClass("[Ljava/lang/String;"), NULL);
1416 if (x_ == NULL)
1417 {
1418 throw GiwsException::JniBadAllocException(curEnv);
1419 }
1420
1421 for ( int i = 0; i < xSize; i++)
1422 {
1423 jobjectArray xLocal = curEnv->NewObjectArray( xSizeCol, stringArrayClass, NULL);
1424 // convert each char * to java strings and fill the java array.
1425 for ( int j = 0; j < xSizeCol; j++) {
1426 jstring TempString = curEnv->NewStringUTF( x[i][j] );
1427
1428 if (TempString == NULL)
1429 {
1430 throw GiwsException::JniBadAllocException(curEnv);
1431 }
1432
1433 curEnv->SetObjectArrayElement( xLocal, j, TempString);
1434
1435 // avoid keeping reference on too many strings
1436 curEnv->DeleteLocalRef(TempString);
1437 }
1438 curEnv->SetObjectArrayElement(x_, i, xLocal);
1439 curEnv->DeleteLocalRef(xLocal);
1440
1441 }
1442                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__java_lang_Stringjava_lang_StringID ,x_));
1443                         curEnv->DeleteLocalRef(stringArrayClass);
1444 curEnv->DeleteLocalRef(x_);
1445 if (curEnv->ExceptionCheck()) {
1446 throw GiwsException::JniCallMethodException(curEnv);
1447 }
1448 return res;
1449
1450 }
1451
1452 int ScilabJavaObject::wrap (JavaVM * jvm_, bool x){
1453
1454 JNIEnv * curEnv = NULL;
1455 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1456 jclass cls = initClass(curEnv);
1457 if ( cls == NULL) {
1458 throw GiwsException::JniCallMethodException(curEnv);
1459 }
1460
1461 static jmethodID jintwrapjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "(Z)I" ) ;
1462 if (jintwrapjbooleanbooleanID == NULL) {
1463 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1464 }
1465
1466 jboolean x_ = (static_cast<bool>(x) ? JNI_TRUE : JNI_FALSE);
1467
1468                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanbooleanID ,x_));
1469                         if (curEnv->ExceptionCheck()) {
1470 throw GiwsException::JniCallMethodException(curEnv);
1471 }
1472 return res;
1473
1474 }
1475
1476 int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* x, int xSize){
1477
1478 JNIEnv * curEnv = NULL;
1479 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1480 jclass cls = initClass(curEnv);
1481 if ( cls == NULL) {
1482 throw GiwsException::JniCallMethodException(curEnv);
1483 }
1484
1485 static jmethodID jintwrapjbooleanArray_booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([Z)I" ) ;
1486 if (jintwrapjbooleanArray_booleanbooleanID == NULL) {
1487 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1488 }
1489
1490 jbooleanArray x_ = curEnv->NewBooleanArray( xSize ) ;
1491 curEnv->SetBooleanArrayRegion( x_, 0, xSize, (jboolean*)x ) ;
1492
1493                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjbooleanArray_booleanbooleanID ,x_));
1494                         curEnv->DeleteLocalRef(x_);
1495 if (curEnv->ExceptionCheck()) {
1496 throw GiwsException::JniCallMethodException(curEnv);
1497 }
1498 return res;
1499
1500 }
1501
1502 int ScilabJavaObject::wrap (JavaVM * jvm_, bool const* const* x, int xSize, int xSizeCol){
1503
1504 JNIEnv * curEnv = NULL;
1505 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1506 jclass cls = initClass(curEnv);
1507 if ( cls == NULL) {
1508 throw GiwsException::JniCallMethodException(curEnv);
1509 }
1510
1511 static jmethodID jintwrapjobjectArray__booleanbooleanID = curEnv->GetStaticMethodID(cls, "wrap", "([[Z)I" ) ;
1512 if (jintwrapjobjectArray__booleanbooleanID == NULL) {
1513 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1514 }
1515
1516 jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[Z"),NULL);
1517 for (int i=0; i<xSize; i++){
1518                         jbooleanArray xLocal = curEnv->NewBooleanArray( xSizeCol ) ;
1519                         curEnv->SetBooleanArrayRegion( xLocal, 0, xSizeCol, (jboolean*)(x[i]) ) ;
1520                         curEnv->SetObjectArrayElement(x_, i, xLocal);
1521                         curEnv->DeleteLocalRef(xLocal);
1522                         }
1523
1524                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__booleanbooleanID ,x_));
1525                         curEnv->DeleteLocalRef(x_);
1526 if (curEnv->ExceptionCheck()) {
1527 throw GiwsException::JniCallMethodException(curEnv);
1528 }
1529 return res;
1530
1531 }
1532
1533 int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short x){
1534
1535 JNIEnv * curEnv = NULL;
1536 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1537 jclass cls = initClass(curEnv);
1538 if ( cls == NULL) {
1539 throw GiwsException::JniCallMethodException(curEnv);
1540 }
1541
1542 static jmethodID jintwrapjcharcharID = curEnv->GetStaticMethodID(cls, "wrap", "(C)I" ) ;
1543 if (jintwrapjcharcharID == NULL) {
1544 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1545 }
1546
1547                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharcharID ,x));
1548                         if (curEnv->ExceptionCheck()) {
1549 throw GiwsException::JniCallMethodException(curEnv);
1550 }
1551 return res;
1552
1553 }
1554
1555 int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* x, int xSize){
1556
1557 JNIEnv * curEnv = NULL;
1558 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1559 jclass cls = initClass(curEnv);
1560 if ( cls == NULL) {
1561 throw GiwsException::JniCallMethodException(curEnv);
1562 }
1563
1564 static jmethodID jintwrapjcharArray_charcharID = curEnv->GetStaticMethodID(cls, "wrap", "([C)I" ) ;
1565 if (jintwrapjcharArray_charcharID == NULL) {
1566 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1567 }
1568
1569 jcharArray x_ = curEnv->NewCharArray( xSize ) ;
1570
1571 if (x_ == NULL)
1572 {
1573 // check that allocation succeed
1574 throw GiwsException::JniBadAllocException(curEnv);
1575 }
1576
1577 curEnv->SetCharArrayRegion( x_, 0, xSize, (jchar*)(x) ) ;
1578
1579
1580                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjcharArray_charcharID ,x_));
1581                         curEnv->DeleteLocalRef(x_);
1582 if (curEnv->ExceptionCheck()) {
1583 throw GiwsException::JniCallMethodException(curEnv);
1584 }
1585 return res;
1586
1587 }
1588
1589 int ScilabJavaObject::wrap (JavaVM * jvm_, unsigned short const* const* x, int xSize, int xSizeCol){
1590
1591 JNIEnv * curEnv = NULL;
1592 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1593 jclass cls = initClass(curEnv);
1594 if ( cls == NULL) {
1595 throw GiwsException::JniCallMethodException(curEnv);
1596 }
1597
1598 static jmethodID jintwrapjobjectArray__charcharID = curEnv->GetStaticMethodID(cls, "wrap", "([[C)I" ) ;
1599 if (jintwrapjobjectArray__charcharID == NULL) {
1600 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1601 }
1602
1603  jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[C"),NULL);
1604
1605 if (x_ == NULL)
1606 {
1607 // check that allocation succeed
1608 throw GiwsException::JniBadAllocException(curEnv);
1609 }
1610
1611  for (int i=0; i<xSize; i++){
1612
1613 jcharArray xLocal = curEnv->NewCharArray( xSizeCol ) ;
1614
1615 if (xLocal == NULL)
1616 {
1617 // check that allocation succeed
1618 curEnv->DeleteLocalRef(x_);
1619 throw GiwsException::JniBadAllocException(curEnv);
1620 }
1621
1622 curEnv->SetCharArrayRegion( xLocal, 0, xSizeCol, (jchar*)(x[i]) ) ;
1623 curEnv->SetObjectArrayElement(x_, i, xLocal);
1624 curEnv->DeleteLocalRef(xLocal);
1625 }
1626
1627                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__charcharID ,x_));
1628                         curEnv->DeleteLocalRef(x_);
1629 if (curEnv->ExceptionCheck()) {
1630 throw GiwsException::JniCallMethodException(curEnv);
1631 }
1632 return res;
1633
1634 }
1635
1636 int ScilabJavaObject::wrap (JavaVM * jvm_, float x){
1637
1638 JNIEnv * curEnv = NULL;
1639 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1640 jclass cls = initClass(curEnv);
1641 if ( cls == NULL) {
1642 throw GiwsException::JniCallMethodException(curEnv);
1643 }
1644
1645 static jmethodID jintwrapjfloatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "(F)I" ) ;
1646 if (jintwrapjfloatfloatID == NULL) {
1647 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1648 }
1649
1650                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatfloatID ,x));
1651                         if (curEnv->ExceptionCheck()) {
1652 throw GiwsException::JniCallMethodException(curEnv);
1653 }
1654 return res;
1655
1656 }
1657
1658 int ScilabJavaObject::wrap (JavaVM * jvm_, float const* x, int xSize){
1659
1660 JNIEnv * curEnv = NULL;
1661 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1662 jclass cls = initClass(curEnv);
1663 if ( cls == NULL) {
1664 throw GiwsException::JniCallMethodException(curEnv);
1665 }
1666
1667 static jmethodID jintwrapjfloatArray_floatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "([F)I" ) ;
1668 if (jintwrapjfloatArray_floatfloatID == NULL) {
1669 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1670 }
1671
1672 jfloatArray x_ = curEnv->NewFloatArray( xSize ) ;
1673
1674 if (x_ == NULL)
1675 {
1676 // check that allocation succeed
1677 throw GiwsException::JniBadAllocException(curEnv);
1678 }
1679
1680 curEnv->SetFloatArrayRegion( x_, 0, xSize, (jfloat*)(x) ) ;
1681
1682
1683                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjfloatArray_floatfloatID ,x_));
1684                         curEnv->DeleteLocalRef(x_);
1685 if (curEnv->ExceptionCheck()) {
1686 throw GiwsException::JniCallMethodException(curEnv);
1687 }
1688 return res;
1689
1690 }
1691
1692 int ScilabJavaObject::wrap (JavaVM * jvm_, float const* const* x, int xSize, int xSizeCol){
1693
1694 JNIEnv * curEnv = NULL;
1695 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1696 jclass cls = initClass(curEnv);
1697 if ( cls == NULL) {
1698 throw GiwsException::JniCallMethodException(curEnv);
1699 }
1700
1701 static jmethodID jintwrapjobjectArray__floatfloatID = curEnv->GetStaticMethodID(cls, "wrap", "([[F)I" ) ;
1702 if (jintwrapjobjectArray__floatfloatID == NULL) {
1703 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1704 }
1705
1706  jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[F"),NULL);
1707
1708 if (x_ == NULL)
1709 {
1710 // check that allocation succeed
1711 throw GiwsException::JniBadAllocException(curEnv);
1712 }
1713
1714  for (int i=0; i<xSize; i++){
1715
1716 jfloatArray xLocal = curEnv->NewFloatArray( xSizeCol ) ;
1717
1718 if (xLocal == NULL)
1719 {
1720 // check that allocation succeed
1721 curEnv->DeleteLocalRef(x_);
1722 throw GiwsException::JniBadAllocException(curEnv);
1723 }
1724
1725 curEnv->SetFloatArrayRegion( xLocal, 0, xSizeCol, (jfloat*)(x[i]) ) ;
1726 curEnv->SetObjectArrayElement(x_, i, xLocal);
1727 curEnv->DeleteLocalRef(xLocal);
1728 }
1729
1730                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__floatfloatID ,x_));
1731                         curEnv->DeleteLocalRef(x_);
1732 if (curEnv->ExceptionCheck()) {
1733 throw GiwsException::JniCallMethodException(curEnv);
1734 }
1735 return res;
1736
1737 }
1738
1739 int ScilabJavaObject::wrap (JavaVM * jvm_, long long x){
1740
1741 JNIEnv * curEnv = NULL;
1742 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1743 jclass cls = initClass(curEnv);
1744 if ( cls == NULL) {
1745 throw GiwsException::JniCallMethodException(curEnv);
1746 }
1747
1748 static jmethodID jintwrapjlonglongID = curEnv->GetStaticMethodID(cls, "wrap", "(J)I" ) ;
1749 if (jintwrapjlonglongID == NULL) {
1750 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1751 }
1752
1753                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlonglongID ,x));
1754                         if (curEnv->ExceptionCheck()) {
1755 throw GiwsException::JniCallMethodException(curEnv);
1756 }
1757 return res;
1758
1759 }
1760
1761 int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* x, int xSize){
1762
1763 JNIEnv * curEnv = NULL;
1764 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1765 jclass cls = initClass(curEnv);
1766 if ( cls == NULL) {
1767 throw GiwsException::JniCallMethodException(curEnv);
1768 }
1769
1770 static jmethodID jintwrapjlongArray_longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([J)I" ) ;
1771 if (jintwrapjlongArray_longlongID == NULL) {
1772 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1773 }
1774
1775 jlongArray x_ = curEnv->NewLongArray( xSize ) ;
1776
1777 if (x_ == NULL)
1778 {
1779 // check that allocation succeed
1780 throw GiwsException::JniBadAllocException(curEnv);
1781 }
1782
1783 curEnv->SetLongArrayRegion( x_, 0, xSize, (jlong*)(x) ) ;
1784
1785
1786                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjlongArray_longlongID ,x_));
1787                         curEnv->DeleteLocalRef(x_);
1788 if (curEnv->ExceptionCheck()) {
1789 throw GiwsException::JniCallMethodException(curEnv);
1790 }
1791 return res;
1792
1793 }
1794
1795 int ScilabJavaObject::wrap (JavaVM * jvm_, long long const* const* x, int xSize, int xSizeCol){
1796
1797 JNIEnv * curEnv = NULL;
1798 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1799 jclass cls = initClass(curEnv);
1800 if ( cls == NULL) {
1801 throw GiwsException::JniCallMethodException(curEnv);
1802 }
1803
1804 static jmethodID jintwrapjobjectArray__longlongID = curEnv->GetStaticMethodID(cls, "wrap", "([[J)I" ) ;
1805 if (jintwrapjobjectArray__longlongID == NULL) {
1806 throw GiwsException::JniMethodNotFoundException(curEnv, "wrap");
1807 }
1808
1809  jobjectArray x_ = curEnv->NewObjectArray(xSize, curEnv->FindClass("[J"),NULL);
1810
1811 if (x_ == NULL)
1812 {
1813 // check that allocation succeed
1814 throw GiwsException::JniBadAllocException(curEnv);
1815 }
1816
1817  for (int i=0; i<xSize; i++){
1818
1819 jlongArray xLocal = curEnv->NewLongArray( xSizeCol ) ;
1820
1821 if (xLocal == NULL)
1822 {
1823 // check that allocation succeed
1824 curEnv->DeleteLocalRef(x_);
1825 throw GiwsException::JniBadAllocException(curEnv);
1826 }
1827
1828 curEnv->SetLongArrayRegion( xLocal, 0, xSizeCol, (jlong*)(x[i]) ) ;
1829 curEnv->SetObjectArrayElement(x_, i, xLocal);
1830 curEnv->DeleteLocalRef(xLocal);
1831 }
1832
1833                         jint res =  static_cast<jint>( curEnv->CallStaticIntMethod(cls, jintwrapjobjectArray__longlongID ,x_));
1834                         curEnv->DeleteLocalRef(x_);
1835 if (curEnv->ExceptionCheck()) {
1836 throw GiwsException::JniCallMethodException(curEnv);
1837 }
1838 return res;
1839
1840 }
1841
1842 char** ScilabJavaObject::getAccessibleFields (JavaVM * jvm_, int id, int *lenRow){
1843
1844 JNIEnv * curEnv = NULL;
1845 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1846 jclass cls = initClass(curEnv);
1847 if ( cls == NULL) {
1848 throw GiwsException::JniCallMethodException(curEnv);
1849 }
1850
1851 static jmethodID jobjectArray_getAccessibleFieldsjintintID = curEnv->GetStaticMethodID(cls, "getAccessibleFields", "(I)[Ljava/lang/String;" ) ;
1852 if (jobjectArray_getAccessibleFieldsjintintID == NULL) {
1853 throw GiwsException::JniMethodNotFoundException(curEnv, "getAccessibleFields");
1854 }
1855
1856                         jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getAccessibleFieldsjintintID ,id));
1857                         if (curEnv->ExceptionCheck()) {
1858 throw GiwsException::JniCallMethodException(curEnv);
1859 }if (res != NULL) { 
1860 * lenRow = curEnv->GetArrayLength(res);
1861
1862 char **arrayOfString;
1863 arrayOfString = new char *[*lenRow];
1864 for (jsize i = 0; i < *lenRow; i++){
1865 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
1866 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
1867 arrayOfString[i] = new char[strlen(tempString) + 1];
1868
1869 strcpy(arrayOfString[i], tempString);
1870 curEnv->ReleaseStringUTFChars(resString, tempString);
1871 curEnv->DeleteLocalRef(resString);
1872 }
1873 if (curEnv->ExceptionCheck()) {
1874 delete[] arrayOfString;
1875                                 throw GiwsException::JniCallMethodException(curEnv);
1876 }
1877 curEnv->DeleteLocalRef(res);
1878 return arrayOfString;
1879  } else { 
1880 curEnv->DeleteLocalRef(res);
1881 return NULL;
1882 }
1883 }
1884
1885 char** ScilabJavaObject::getAccessibleMethods (JavaVM * jvm_, int id, int *lenRow){
1886
1887 JNIEnv * curEnv = NULL;
1888 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1889 jclass cls = initClass(curEnv);
1890 if ( cls == NULL) {
1891 throw GiwsException::JniCallMethodException(curEnv);
1892 }
1893
1894 static jmethodID jobjectArray_getAccessibleMethodsjintintID = curEnv->GetStaticMethodID(cls, "getAccessibleMethods", "(I)[Ljava/lang/String;" ) ;
1895 if (jobjectArray_getAccessibleMethodsjintintID == NULL) {
1896 throw GiwsException::JniMethodNotFoundException(curEnv, "getAccessibleMethods");
1897 }
1898
1899                         jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getAccessibleMethodsjintintID ,id));
1900                         if (curEnv->ExceptionCheck()) {
1901 throw GiwsException::JniCallMethodException(curEnv);
1902 }if (res != NULL) { 
1903 * lenRow = curEnv->GetArrayLength(res);
1904
1905 char **arrayOfString;
1906 arrayOfString = new char *[*lenRow];
1907 for (jsize i = 0; i < *lenRow; i++){
1908 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
1909 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
1910 arrayOfString[i] = new char[strlen(tempString) + 1];
1911
1912 strcpy(arrayOfString[i], tempString);
1913 curEnv->ReleaseStringUTFChars(resString, tempString);
1914 curEnv->DeleteLocalRef(resString);
1915 }
1916 if (curEnv->ExceptionCheck()) {
1917 delete[] arrayOfString;
1918                                 throw GiwsException::JniCallMethodException(curEnv);
1919 }
1920 curEnv->DeleteLocalRef(res);
1921 return arrayOfString;
1922  } else { 
1923 curEnv->DeleteLocalRef(res);
1924 return NULL;
1925 }
1926 }
1927
1928 char** ScilabJavaObject::getCompletion (JavaVM * jvm_, int id, char const* const* fieldPath, int fieldPathSize, int *lenRow){
1929
1930 JNIEnv * curEnv = NULL;
1931 jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
1932 jclass cls = initClass(curEnv);
1933 if ( cls == NULL) {
1934 throw GiwsException::JniCallMethodException(curEnv);
1935 }
1936
1937 static jmethodID jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID = curEnv->GetStaticMethodID(cls, "getCompletion", "(I[Ljava/lang/String;)[Ljava/lang/String;" ) ;
1938 if (jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID == NULL) {
1939 throw GiwsException::JniMethodNotFoundException(curEnv, "getCompletion");
1940 }
1941 jclass stringArrayClass = curEnv->FindClass("java/lang/String");
1942
1943 // create java array of strings.
1944 jobjectArray fieldPath_ = curEnv->NewObjectArray( fieldPathSize, stringArrayClass, NULL);
1945 if (fieldPath_ == NULL)
1946 {
1947 throw GiwsException::JniBadAllocException(curEnv);
1948 }
1949
1950 // convert each char * to java strings and fill the java array.
1951 for ( int i = 0; i < fieldPathSize; i++)
1952 {
1953 jstring TempString = curEnv->NewStringUTF( fieldPath[i] );
1954 if (TempString == NULL)
1955 {
1956 throw GiwsException::JniBadAllocException(curEnv);
1957 }
1958
1959 curEnv->SetObjectArrayElement( fieldPath_, i, TempString);
1960
1961 // avoid keeping reference on too many strings
1962 curEnv->DeleteLocalRef(TempString);
1963 }
1964                         jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getCompletionjintintjobjectArray_java_lang_Stringjava_lang_StringID ,id, fieldPath_));
1965                         if (curEnv->ExceptionCheck()) {
1966 throw GiwsException::JniCallMethodException(curEnv);
1967 }if (res != NULL) { 
1968 * lenRow = curEnv->GetArrayLength(res);
1969
1970 char **arrayOfString;
1971 arrayOfString = new char *[*lenRow];
1972 for (jsize i = 0; i < *lenRow; i++){
1973 jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
1974 const char *tempString = curEnv->GetStringUTFChars(resString, 0);
1975 arrayOfString[i] = new char[strlen(tempString) + 1];
1976
1977 strcpy(arrayOfString[i], tempString);
1978 curEnv->ReleaseStringUTFChars(resString, tempString);
1979 curEnv->DeleteLocalRef(resString);
1980 }
1981 curEnv->DeleteLocalRef(stringArrayClass);
1982 curEnv->DeleteLocalRef(fieldPath_);
1983 if (curEnv->ExceptionCheck()) {
1984 delete[] arrayOfString;
1985                                 throw GiwsException::JniCallMethodException(curEnv);
1986 }
1987 curEnv->DeleteLocalRef(res);
1988 return arrayOfString;
1989  } else { 
1990 curEnv->DeleteLocalRef(res);
1991 return NULL;
1992 }
1993 }
1994
1995 }