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