Compilation: upgrade swig generated files to swig-3.0.7
[scilab.git] / scilab / modules / xcos / src / jni / JavaController_wrap.cxx
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 3.0.7
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10
11 #define SWIGJAVA
12 #define SWIG_DIRECTORS
13
14
15 #ifdef __cplusplus
16 /* SwigValueWrapper is described in swig.swg */
17 template<typename T> class SwigValueWrapper {
18   struct SwigMovePointer {
19     T *ptr;
20     SwigMovePointer(T *p) : ptr(p) { }
21     ~SwigMovePointer() { delete ptr; }
22     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
23   } pointer;
24   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
26 public:
27   SwigValueWrapper() : pointer(0) { }
28   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
29   operator T&() const { return *pointer.ptr; }
30   T *operator&() { return pointer.ptr; }
31 };
32
33 template <typename T> T SwigValueInit() {
34   return T();
35 }
36 #endif
37
38 /* -----------------------------------------------------------------------------
39  *  This section contains generic SWIG labels for method/variable
40  *  declarations/attributes, and other compiler dependent labels.
41  * ----------------------------------------------------------------------------- */
42
43 /* template workaround for compilers that cannot correctly implement the C++ standard */
44 #ifndef SWIGTEMPLATEDISAMBIGUATOR
45 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
46 #  define SWIGTEMPLATEDISAMBIGUATOR template
47 # elif defined(__HP_aCC)
48 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
49 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
50 #  define SWIGTEMPLATEDISAMBIGUATOR template
51 # else
52 #  define SWIGTEMPLATEDISAMBIGUATOR
53 # endif
54 #endif
55
56 /* inline attribute */
57 #ifndef SWIGINLINE
58 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
59 #   define SWIGINLINE inline
60 # else
61 #   define SWIGINLINE
62 # endif
63 #endif
64
65 /* attribute recognised by some compilers to avoid 'unused' warnings */
66 #ifndef SWIGUNUSED
67 # if defined(__GNUC__)
68 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
69 #     define SWIGUNUSED __attribute__ ((__unused__))
70 #   else
71 #     define SWIGUNUSED
72 #   endif
73 # elif defined(__ICC)
74 #   define SWIGUNUSED __attribute__ ((__unused__))
75 # else
76 #   define SWIGUNUSED
77 # endif
78 #endif
79
80 #ifndef SWIG_MSC_UNSUPPRESS_4505
81 # if defined(_MSC_VER)
82 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
83 # endif
84 #endif
85
86 #ifndef SWIGUNUSEDPARM
87 # ifdef __cplusplus
88 #   define SWIGUNUSEDPARM(p)
89 # else
90 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
91 # endif
92 #endif
93
94 /* internal SWIG method */
95 #ifndef SWIGINTERN
96 # define SWIGINTERN static SWIGUNUSED
97 #endif
98
99 /* internal inline SWIG method */
100 #ifndef SWIGINTERNINLINE
101 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
102 #endif
103
104 /* exporting methods */
105 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
106 #  ifndef GCC_HASCLASSVISIBILITY
107 #    define GCC_HASCLASSVISIBILITY
108 #  endif
109 #endif
110
111 #ifndef SWIGEXPORT
112 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
113 #   if defined(STATIC_LINKED)
114 #     define SWIGEXPORT
115 #   else
116 #     define SWIGEXPORT __declspec(dllexport)
117 #   endif
118 # else
119 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
120 #     define SWIGEXPORT __attribute__ ((visibility("default")))
121 #   else
122 #     define SWIGEXPORT
123 #   endif
124 # endif
125 #endif
126
127 /* calling conventions for Windows */
128 #ifndef SWIGSTDCALL
129 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
130 #   define SWIGSTDCALL __stdcall
131 # else
132 #   define SWIGSTDCALL
133 # endif
134 #endif
135
136 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
137 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
138 # define _CRT_SECURE_NO_DEPRECATE
139 #endif
140
141 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
142 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
143 # define _SCL_SECURE_NO_DEPRECATE
144 #endif
145
146 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
147 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
148 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
149 #endif
150
151 /* Intel's compiler complains if a variable which was never initialised is
152  * cast to void, which is a common idiom which we use to indicate that we
153  * are aware a variable isn't used.  So we just silence that warning.
154  * See: https://github.com/swig/swig/issues/192 for more discussion.
155  */
156 #ifdef __INTEL_COMPILER
157 # pragma warning disable 592
158 #endif
159
160
161 /* Fix for jlong on some versions of gcc on Windows */
162 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
163   typedef long long __int64;
164 #endif
165
166 /* Fix for jlong on 64-bit x86 Solaris */
167 #if defined(__x86_64)
168 # ifdef _LP64
169 #   undef _LP64
170 # endif
171 #endif
172
173 #include <jni.h>
174 #include <stdlib.h>
175 #include <string.h>
176
177
178 /* Support for throwing Java exceptions */
179 typedef enum {
180   SWIG_JavaOutOfMemoryError = 1, 
181   SWIG_JavaIOException, 
182   SWIG_JavaRuntimeException, 
183   SWIG_JavaIndexOutOfBoundsException,
184   SWIG_JavaArithmeticException,
185   SWIG_JavaIllegalArgumentException,
186   SWIG_JavaNullPointerException,
187   SWIG_JavaDirectorPureVirtual,
188   SWIG_JavaUnknownError
189 } SWIG_JavaExceptionCodes;
190
191 typedef struct {
192   SWIG_JavaExceptionCodes code;
193   const char *java_exception;
194 } SWIG_JavaExceptions_t;
195
196
197 static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
198   jclass excep;
199   static const SWIG_JavaExceptions_t java_exceptions[] = {
200     { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
201     { SWIG_JavaIOException, "java/io/IOException" },
202     { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
203     { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
204     { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
205     { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
206     { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
207     { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
208     { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
209     { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
210   };
211   const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
212
213   while (except_ptr->code != code && except_ptr->code)
214     except_ptr++;
215
216   jenv->ExceptionClear();
217   excep = jenv->FindClass(except_ptr->java_exception);
218   if (excep)
219     jenv->ThrowNew(excep, msg);
220 }
221
222
223 /* Contract support */
224
225 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else
226
227 /* -----------------------------------------------------------------------------
228  * director_common.swg
229  *
230  * This file contains support for director classes which is common between
231  * languages.
232  * ----------------------------------------------------------------------------- */
233
234 /*
235   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
236   'Swig' namespace. This could be useful for multi-modules projects.
237 */
238 #ifdef SWIG_DIRECTOR_STATIC
239 /* Force anonymous (static) namespace */
240 #define Swig
241 #endif
242 /* -----------------------------------------------------------------------------
243  * director.swg
244  *
245  * This file contains support for director classes so that Java proxy
246  * methods can be called from C++.
247  * ----------------------------------------------------------------------------- */
248
249 #if defined(DEBUG_DIRECTOR_OWNED) || defined(DEBUG_DIRECTOR_EXCEPTION)
250 #include <iostream>
251 #endif
252
253 #include <exception>
254
255 namespace Swig {
256
257   /* Java object wrapper */
258   class JObjectWrapper {
259   public:
260     JObjectWrapper() : jthis_(NULL), weak_global_(true) {
261     }
262
263     ~JObjectWrapper() {
264       jthis_ = NULL;
265       weak_global_ = true;
266     }
267
268     bool set(JNIEnv *jenv, jobject jobj, bool mem_own, bool weak_global) {
269       if (!jthis_) {
270         weak_global_ = weak_global || !mem_own; // hold as weak global if explicitly requested or not owned
271         if (jobj)
272           jthis_ = weak_global_ ? jenv->NewWeakGlobalRef(jobj) : jenv->NewGlobalRef(jobj);
273 #if defined(DEBUG_DIRECTOR_OWNED)
274         std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> " << jthis_ << std::endl;
275 #endif
276         return true;
277       } else {
278 #if defined(DEBUG_DIRECTOR_OWNED)
279         std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> already set" << std::endl;
280 #endif
281         return false;
282       }
283     }
284
285     jobject get(JNIEnv *jenv) const {
286 #if defined(DEBUG_DIRECTOR_OWNED)
287       std::cout << "JObjectWrapper::get(";
288       if (jthis_)
289         std::cout << jthis_;
290       else
291         std::cout << "null";
292       std::cout << ") -> return new local ref" << std::endl;
293 #endif
294       return (jthis_ ? jenv->NewLocalRef(jthis_) : jthis_);
295     }
296
297     void release(JNIEnv *jenv) {
298 #if defined(DEBUG_DIRECTOR_OWNED)
299       std::cout << "JObjectWrapper::release(" << jthis_ << "): " << (weak_global_ ? "weak global ref" : "global ref") << std::endl;
300 #endif
301       if (jthis_) {
302         if (weak_global_) {
303           if (jenv->IsSameObject(jthis_, NULL) == JNI_FALSE)
304             jenv->DeleteWeakGlobalRef((jweak)jthis_);
305         } else
306           jenv->DeleteGlobalRef(jthis_);
307       }
308
309       jthis_ = NULL;
310       weak_global_ = true;
311     }
312
313     /* Only call peek if you know what you are doing wrt to weak/global references */
314     jobject peek() {
315       return jthis_;
316     }
317
318     /* Java proxy releases ownership of C++ object, C++ object is now
319        responsible for destruction (creates NewGlobalRef to pin Java proxy) */
320     void java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
321       if (take_or_release) {  /* Java takes ownership of C++ object's lifetime. */
322         if (!weak_global_) {
323           jenv->DeleteGlobalRef(jthis_);
324           jthis_ = jenv->NewWeakGlobalRef(jself);
325           weak_global_ = true;
326         }
327       } else {
328         /* Java releases ownership of C++ object's lifetime */
329         if (weak_global_) {
330           jenv->DeleteWeakGlobalRef((jweak)jthis_);
331           jthis_ = jenv->NewGlobalRef(jself);
332           weak_global_ = false;
333         }
334       }
335     }
336
337   private:
338     /* pointer to Java object */
339     jobject jthis_;
340     /* Local or global reference flag */
341     bool weak_global_;
342   };
343
344   /* Local JNI reference deleter */
345   class LocalRefGuard {
346     JNIEnv *jenv_;
347     jobject jobj_;
348
349     // non-copyable
350     LocalRefGuard(const LocalRefGuard &);
351     LocalRefGuard &operator=(const LocalRefGuard &);
352   public:
353     LocalRefGuard(JNIEnv *jenv, jobject jobj): jenv_(jenv), jobj_(jobj) {}
354     ~LocalRefGuard() {
355       if (jobj_)
356         jenv_->DeleteLocalRef(jobj_);
357     }
358   };
359
360   /* director base class */
361   class Director {
362     /* pointer to Java virtual machine */
363     JavaVM *swig_jvm_;
364
365   protected:
366 #if defined (_MSC_VER) && (_MSC_VER<1300)
367     class JNIEnvWrapper;
368     friend class JNIEnvWrapper;
369 #endif
370     /* Utility class for managing the JNI environment */
371     class JNIEnvWrapper {
372       const Director *director_;
373       JNIEnv *jenv_;
374       int env_status;
375     public:
376       JNIEnvWrapper(const Director *director) : director_(director), jenv_(0), env_status(0) {
377 #if defined(__ANDROID__)
378         JNIEnv **jenv = &jenv_;
379 #else
380         void **jenv = (void **)&jenv_;
381 #endif
382         env_status = director_->swig_jvm_->GetEnv((void **)&jenv_, JNI_VERSION_1_2);
383 #if defined(SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON)
384         // Attach a daemon thread to the JVM. Useful when the JVM should not wait for
385         // the thread to exit upon shutdown. Only for jdk-1.4 and later.
386         director_->swig_jvm_->AttachCurrentThreadAsDaemon(jenv, NULL);
387 #else
388         director_->swig_jvm_->AttachCurrentThread(jenv, NULL);
389 #endif
390       }
391       ~JNIEnvWrapper() {
392 #if !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD)
393         // Some JVMs, eg jdk-1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call.
394         // However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak.
395         if (env_status == JNI_EDETACHED)
396           director_->swig_jvm_->DetachCurrentThread();
397 #endif
398       }
399       JNIEnv *getJNIEnv() const {
400         return jenv_;
401       }
402     };
403
404     /* Java object wrapper */
405     JObjectWrapper swig_self_;
406
407     /* Disconnect director from Java object */
408     void swig_disconnect_director_self(const char *disconn_method) {
409       JNIEnvWrapper jnienv(this) ;
410       JNIEnv *jenv = jnienv.getJNIEnv() ;
411       jobject jobj = swig_self_.get(jenv);
412       LocalRefGuard ref_deleter(jenv, jobj);
413 #if defined(DEBUG_DIRECTOR_OWNED)
414       std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl;
415 #endif
416       if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) {
417         jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(jobj), disconn_method, "()V");
418         if (disconn_meth) {
419 #if defined(DEBUG_DIRECTOR_OWNED)
420           std::cout << "Swig::Director::disconnect_director_self upcall to " << disconn_method << std::endl;
421 #endif
422           jenv->CallVoidMethod(jobj, disconn_meth);
423         }
424       }
425     }
426
427   public:
428     Director(JNIEnv *jenv) : swig_jvm_((JavaVM *) NULL), swig_self_() {
429       /* Acquire the Java VM pointer */
430       jenv->GetJavaVM(&swig_jvm_);
431     }
432
433     virtual ~Director() {
434       JNIEnvWrapper jnienv(this) ;
435       JNIEnv *jenv = jnienv.getJNIEnv() ;
436       swig_self_.release(jenv);
437     }
438
439     bool swig_set_self(JNIEnv *jenv, jobject jself, bool mem_own, bool weak_global) {
440       return swig_self_.set(jenv, jself, mem_own, weak_global);
441     }
442
443     jobject swig_get_self(JNIEnv *jenv) const {
444       return swig_self_.get(jenv);
445     }
446
447     // Change C++ object's ownership, relative to Java
448     void swig_java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
449       swig_self_.java_change_ownership(jenv, jself, take_or_release);
450     }
451   };
452
453   // Zero initialized bool array
454   template<size_t N> class BoolArray {
455     bool array_[N];
456   public:
457     BoolArray() {
458       memset(array_, 0, sizeof(array_));
459     }
460     bool& operator[](size_t n) {
461       return array_[n];
462     }
463     bool operator[](size_t n) const {
464       return array_[n];
465     }
466   };
467
468   // Utility classes and functions for exception handling.
469
470   // Simple holder for a Java string during exception handling, providing access to a c-style string
471   class JavaString {
472   public:
473     JavaString(JNIEnv *jenv, jstring jstr) : jenv_(jenv), jstr_(jstr), cstr_(0) {
474       if (jenv_ && jstr_)
475         cstr_ = (const char *) jenv_->GetStringUTFChars(jstr_, NULL);
476     }
477
478     ~JavaString() {
479       if (jenv_ && jstr_ && cstr_)
480         jenv_->ReleaseStringUTFChars(jstr_, cstr_);
481     }
482
483     const char *c_str(const char *null_string = "null JavaString") const {
484       return cstr_ ? cstr_ : null_string;
485     }
486
487   private:
488     // non-copyable
489     JavaString(const JavaString &);
490     JavaString &operator=(const JavaString &);
491
492     JNIEnv *jenv_;
493     jstring jstr_;
494     const char *cstr_;
495   };
496
497   // Helper class to extract the exception message from a Java throwable
498   class JavaExceptionMessage {
499   public:
500     JavaExceptionMessage(JNIEnv *jenv, jthrowable throwable) : message_(jenv, exceptionMessageFromThrowable(jenv, throwable)) {
501     }
502
503     const char *message() const {
504       return message_.c_str("Could not get exception message in JavaExceptionMessage");
505     }
506
507   private:
508     // non-copyable
509     JavaExceptionMessage(const JavaExceptionMessage &);
510     JavaExceptionMessage &operator=(const JavaExceptionMessage &);
511
512     // Get exception message by calling Java method Throwable.getMessage()
513     static jstring exceptionMessageFromThrowable(JNIEnv *jenv, jthrowable throwable) {
514       jstring jmsg = NULL;
515       if (jenv && throwable) {
516         jenv->ExceptionClear(); // Cannot invoke methods with any pending exceptions
517         jclass throwclz = jenv->GetObjectClass(throwable);
518         if (throwclz) {
519           // All Throwable classes have a getMessage() method, so call it to extract the exception message
520           jmethodID getMessageMethodID = jenv->GetMethodID(throwclz, "getMessage", "()Ljava/lang/String;");
521           if (getMessageMethodID)
522             jmsg = (jstring)jenv->CallObjectMethod(throwable, getMessageMethodID);
523         }
524         if (jmsg == NULL && jenv->ExceptionCheck())
525           jenv->ExceptionClear();
526       }
527       return jmsg;
528     }
529
530     JavaString message_;
531   };
532
533   // C++ Exception class for handling Java exceptions thrown during a director method Java upcall
534   class DirectorException : public std::exception {
535   public:
536
537     // Construct exception from a Java throwable
538     DirectorException(JNIEnv *jenv, jthrowable throwable) : classname_(0), msg_(0) {
539
540       // Call Java method Object.getClass().getName() to obtain the throwable's class name (delimited by '/')
541       if (throwable) {
542         jclass throwclz = jenv->GetObjectClass(throwable);
543         if (throwclz) {
544           jclass clzclz = jenv->GetObjectClass(throwclz);
545           if (clzclz) {
546             jmethodID getNameMethodID = jenv->GetMethodID(clzclz, "getName", "()Ljava/lang/String;");
547             if (getNameMethodID) {
548               jstring jstr_classname = (jstring)(jenv->CallObjectMethod(throwclz, getNameMethodID));
549               // Copy strings, since there is no guarantee that jenv will be active when handled
550               if (jstr_classname) {
551                 JavaString jsclassname(jenv, jstr_classname);
552                 const char *classname = jsclassname.c_str(0);
553                 if (classname)
554                   classname_ = copypath(classname);
555               }
556             }
557           }
558         }
559       }
560
561       JavaExceptionMessage exceptionmsg(jenv, throwable);
562       msg_ = copystr(exceptionmsg.message());
563     }
564
565     // More general constructor for handling as a java.lang.RuntimeException
566     DirectorException(const char *msg) : classname_(0), msg_(copystr(msg ? msg : "Unspecified DirectorException message")) {
567     }
568
569     ~DirectorException() throw() {
570       delete[] classname_;
571       delete[] msg_;
572     }
573
574     const char *what() const throw() {
575       return msg_;
576     }
577
578     // Reconstruct and raise/throw the Java Exception that caused the DirectorException
579     // Note that any error in the JNI exception handling results in a Java RuntimeException
580     void raiseJavaException(JNIEnv *jenv) const {
581       if (jenv) {
582         jenv->ExceptionClear();
583
584         jmethodID ctorMethodID = 0;
585         jclass throwableclass = 0;
586         if (classname_) {
587           throwableclass = jenv->FindClass(classname_);
588           if (throwableclass)
589             ctorMethodID = jenv->GetMethodID(throwableclass, "<init>", "(Ljava/lang/String;)V");
590         }
591
592         if (ctorMethodID) {
593           jenv->ThrowNew(throwableclass, what());
594         } else {
595           SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, what());
596         }
597       }
598     }
599
600   private:
601     static char *copypath(const char *srcmsg) {
602       char *target = copystr(srcmsg);
603       for (char *c=target; *c; ++c) {
604         if ('.' == *c)
605           *c = '/';
606       }
607       return target;
608     }
609
610     static char *copystr(const char *srcmsg) {
611       char *target = 0;
612       if (srcmsg) {
613         size_t msglen = strlen(srcmsg) + 1;
614         target = new char[msglen];
615         strncpy(target, srcmsg, msglen);
616       }
617       return target;
618     }
619
620     const char *classname_;
621     const char *msg_;
622   };
623
624   // Helper method to determine if a Java throwable matches a particular Java class type
625   SWIGINTERN bool ExceptionMatches(JNIEnv *jenv, jthrowable throwable, const char *classname) {
626     bool matches = false;
627
628     if (throwable && jenv && classname) {
629       // Exceptions need to be cleared for correct behavior.
630       // The caller of ExceptionMatches should restore pending exceptions if desired -
631       // the caller already has the throwable.
632       jenv->ExceptionClear();
633
634       jclass clz = jenv->FindClass(classname);
635       if (clz) {
636         jclass classclz = jenv->GetObjectClass(clz);
637         jmethodID isInstanceMethodID = jenv->GetMethodID(classclz, "isInstance", "(Ljava/lang/Object;)Z");
638         if (isInstanceMethodID) {
639           matches = jenv->CallBooleanMethod(clz, isInstanceMethodID, throwable) != 0;
640         }
641       }
642
643 #if defined(DEBUG_DIRECTOR_EXCEPTION)
644       if (jenv->ExceptionCheck()) {
645         // Typically occurs when an invalid classname argument is passed resulting in a ClassNotFoundException
646         JavaExceptionMessage exc(jenv, jenv->ExceptionOccurred());
647         std::cout << "Error: ExceptionMatches: class '" << classname << "' : " << exc.message() << std::endl;
648       }
649 #endif
650     }
651     return matches;
652   }
653 }
654
655 namespace Swig {
656   namespace {
657     jclass jclass_JavaControllerJNI = NULL;
658     jmethodID director_method_ids[4];
659   }
660 }
661
662 #include <vector>
663 #include <string>
664
665 #include "utilities.hxx"
666 #include "View.hxx"
667 #include "Controller.hxx"
668
669
670 #include <stdexcept>
671
672
673 #include <vector>
674 #include <stdexcept>
675
676
677 #include <string>
678
679 SWIGINTERN std::vector< double >::const_reference std_vector_Sl_double_Sg__get(std::vector< double > *self,int i){
680                 int size = int(self->size());
681                 if (i>=0 && i<size)
682                     return (*self)[i];
683                 else
684                     throw std::out_of_range("vector index out of range");
685             }
686 SWIGINTERN void std_vector_Sl_double_Sg__set(std::vector< double > *self,int i,std::vector< double >::value_type const &val){
687                 int size = int(self->size());
688                 if (i>=0 && i<size)
689                     (*self)[i] = val;
690                 else
691                     throw std::out_of_range("vector index out of range");
692             }
693 SWIGINTERN std::vector< int >::const_reference std_vector_Sl_int_Sg__get(std::vector< int > *self,int i){
694                 int size = int(self->size());
695                 if (i>=0 && i<size)
696                     return (*self)[i];
697                 else
698                     throw std::out_of_range("vector index out of range");
699             }
700 SWIGINTERN void std_vector_Sl_int_Sg__set(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
701                 int size = int(self->size());
702                 if (i>=0 && i<size)
703                     (*self)[i] = val;
704                 else
705                     throw std::out_of_range("vector index out of range");
706             }
707 SWIGINTERN bool std_vector_Sl_bool_Sg__get(std::vector< bool > *self,int i){
708                 int size = int(self->size());
709                 if (i>=0 && i<size)
710                     return (*self)[i];
711                 else
712                     throw std::out_of_range("vector index out of range");
713             }
714 SWIGINTERN void std_vector_Sl_bool_Sg__set(std::vector< bool > *self,int i,std::vector< bool >::value_type const &val){
715                 int size = int(self->size());
716                 if (i>=0 && i<size)
717                     (*self)[i] = val;
718                 else
719                     throw std::out_of_range("vector index out of range");
720             }
721 SWIGINTERN std::vector< std::string >::const_reference std_vector_Sl_std_string_Sg__get(std::vector< std::string > *self,int i){
722                 int size = int(self->size());
723                 if (i>=0 && i<size)
724                     return (*self)[i];
725                 else
726                     throw std::out_of_range("vector index out of range");
727             }
728 SWIGINTERN void std_vector_Sl_std_string_Sg__set(std::vector< std::string > *self,int i,std::vector< std::string >::value_type const &val){
729                 int size = int(self->size());
730                 if (i>=0 && i<size)
731                     (*self)[i] = val;
732                 else
733                     throw std::out_of_range("vector index out of range");
734             }
735 SWIGINTERN std::vector< long long >::const_reference std_vector_Sl_ScicosID_Sg__get(std::vector< ScicosID > *self,int i){
736                 int size = int(self->size());
737                 if (i>=0 && i<size)
738                     return (*self)[i];
739                 else
740                     throw std::out_of_range("vector index out of range");
741             }
742 SWIGINTERN void std_vector_Sl_ScicosID_Sg__set(std::vector< ScicosID > *self,int i,std::vector< long long >::value_type const &val){
743                 int size = int(self->size());
744                 if (i>=0 && i<size)
745                     (*self)[i] = val;
746                 else
747                     throw std::out_of_range("vector index out of range");
748             }
749
750 static void register_view(const std::string& name, org_scilab_modules_scicos::View* view) {
751         org_scilab_modules_scicos::Controller::register_view(name, view);
752 };
753
754
755
756 /* ---------------------------------------------------
757  * C++ director class methods
758  * --------------------------------------------------- */
759
760 #include "JavaController_wrap.h"
761
762 SwigDirector_View::SwigDirector_View(JNIEnv *jenv) : org_scilab_modules_scicos::View(), Swig::Director(jenv) {
763 }
764
765 SwigDirector_View::~SwigDirector_View() {
766   swig_disconnect_director_self("swigDirectorDisconnect");
767 }
768
769
770 void SwigDirector_View::objectCreated(ScicosID const &uid, kind_t k) {
771   JNIEnvWrapper swigjnienv(this) ;
772   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
773   jobject swigjobj = (jobject) NULL ;
774   jlong juid = 0 ;
775   jint jk  ;
776   
777   if (!swig_override[0]) {
778     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectCreated.");
779     return;
780   }
781   swigjobj = swig_get_self(jenv);
782   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
783     juid = (jlong)uid;
784     jk = (jint) k;
785     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[0], swigjobj, juid, jk);
786     jthrowable swigerror = jenv->ExceptionOccurred();
787     if (swigerror) {
788       jenv->ExceptionClear();
789       throw Swig::DirectorException(jenv, swigerror);
790     }
791     
792   } else {
793     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectCreated ");
794   }
795   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
796 }
797
798 void SwigDirector_View::objectDeleted(ScicosID const &uid, kind_t k) {
799   JNIEnvWrapper swigjnienv(this) ;
800   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
801   jobject swigjobj = (jobject) NULL ;
802   jlong juid = 0 ;
803   jint jk  ;
804   
805   if (!swig_override[1]) {
806     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectDeleted.");
807     return;
808   }
809   swigjobj = swig_get_self(jenv);
810   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
811     juid = (jlong)uid;
812     jk = (jint) k;
813     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[1], swigjobj, juid, jk);
814     jthrowable swigerror = jenv->ExceptionOccurred();
815     if (swigerror) {
816       jenv->ExceptionClear();
817       throw Swig::DirectorException(jenv, swigerror);
818     }
819     
820   } else {
821     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectDeleted ");
822   }
823   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
824 }
825
826 void SwigDirector_View::objectUpdated(ScicosID const &uid, kind_t k) {
827   JNIEnvWrapper swigjnienv(this) ;
828   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
829   jobject swigjobj = (jobject) NULL ;
830   jlong juid = 0 ;
831   jint jk  ;
832   
833   if (!swig_override[2]) {
834     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectUpdated.");
835     return;
836   }
837   swigjobj = swig_get_self(jenv);
838   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
839     juid = (jlong)uid;
840     jk = (jint) k;
841     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[2], swigjobj, juid, jk);
842     jthrowable swigerror = jenv->ExceptionOccurred();
843     if (swigerror) {
844       jenv->ExceptionClear();
845       throw Swig::DirectorException(jenv, swigerror);
846     }
847     
848   } else {
849     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectUpdated ");
850   }
851   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
852 }
853
854 void SwigDirector_View::propertyUpdated(ScicosID const &uid, kind_t k, object_properties_t p) {
855   JNIEnvWrapper swigjnienv(this) ;
856   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
857   jobject swigjobj = (jobject) NULL ;
858   jlong juid = 0 ;
859   jint jk  ;
860   jint jp  ;
861   
862   if (!swig_override[3]) {
863     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::propertyUpdated.");
864     return;
865   }
866   swigjobj = swig_get_self(jenv);
867   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
868     juid = (jlong)uid;
869     jk = (jint) k;
870     jp = (jint) p;
871     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[3], swigjobj, juid, jk, jp);
872     jthrowable swigerror = jenv->ExceptionOccurred();
873     if (swigerror) {
874       jenv->ExceptionClear();
875       throw Swig::DirectorException(jenv, swigerror);
876     }
877     
878   } else {
879     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::propertyUpdated ");
880   }
881   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
882 }
883
884 void SwigDirector_View::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
885   static struct {
886     const char *mname;
887     const char *mdesc;
888     jmethodID base_methid;
889   } methods[] = {
890     {
891       "objectCreated", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
892     },
893     {
894       "objectDeleted", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
895     },
896     {
897       "objectUpdated", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
898     },
899     {
900       "propertyUpdated", "(JLorg/scilab/modules/xcos/Kind;Lorg/scilab/modules/xcos/ObjectProperties;)V", NULL 
901     }
902   };
903   
904   static jclass baseclass = 0 ;
905   
906   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
907     if (!baseclass) {
908       baseclass = jenv->FindClass("org/scilab/modules/xcos/View");
909       if (!baseclass) return;
910       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
911     }
912     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
913     for (int i = 0; i < 4; ++i) {
914       if (!methods[i].base_methid) {
915         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
916         if (!methods[i].base_methid) return;
917       }
918       swig_override[i] = derived;
919     }
920   }
921 }
922
923
924
925 #ifdef __cplusplus
926 extern "C" {
927 #endif
928
929 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1View(JNIEnv *jenv, jclass jcls) {
930   jlong jresult = 0 ;
931   org_scilab_modules_scicos::View *result = 0 ;
932   
933   (void)jenv;
934   (void)jcls;
935   result = (org_scilab_modules_scicos::View *)new SwigDirector_View(jenv);
936   *(org_scilab_modules_scicos::View **)&jresult = result; 
937   return jresult;
938 }
939
940
941 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1View(JNIEnv *jenv, jclass jcls, jlong jarg1) {
942   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
943   
944   (void)jenv;
945   (void)jcls;
946   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
947   delete arg1;
948 }
949
950
951 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectCreated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
952   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
953   ScicosID *arg2 = 0 ;
954   kind_t arg3 ;
955   ScicosID temp2 ;
956   
957   (void)jenv;
958   (void)jcls;
959   (void)jarg1_;
960   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
961   temp2 = (ScicosID)jarg2; 
962   arg2 = &temp2; 
963   arg3 = (kind_t)jarg3; 
964   (arg1)->objectCreated((ScicosID const &)*arg2,arg3);
965 }
966
967
968 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectDeleted(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
969   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
970   ScicosID *arg2 = 0 ;
971   kind_t arg3 ;
972   ScicosID temp2 ;
973   
974   (void)jenv;
975   (void)jcls;
976   (void)jarg1_;
977   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
978   temp2 = (ScicosID)jarg2; 
979   arg2 = &temp2; 
980   arg3 = (kind_t)jarg3; 
981   (arg1)->objectDeleted((ScicosID const &)*arg2,arg3);
982 }
983
984
985 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectUpdated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
986   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
987   ScicosID *arg2 = 0 ;
988   kind_t arg3 ;
989   ScicosID temp2 ;
990   
991   (void)jenv;
992   (void)jcls;
993   (void)jarg1_;
994   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
995   temp2 = (ScicosID)jarg2; 
996   arg2 = &temp2; 
997   arg3 = (kind_t)jarg3; 
998   (arg1)->objectUpdated((ScicosID const &)*arg2,arg3);
999 }
1000
1001
1002 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1propertyUpdated_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4) {
1003   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1004   ScicosID *arg2 = 0 ;
1005   kind_t arg3 ;
1006   object_properties_t arg4 ;
1007   ScicosID temp2 ;
1008   
1009   (void)jenv;
1010   (void)jcls;
1011   (void)jarg1_;
1012   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1013   temp2 = (ScicosID)jarg2; 
1014   arg2 = &temp2; 
1015   arg3 = (kind_t)jarg3; 
1016   arg4 = (object_properties_t)jarg4; 
1017   (arg1)->propertyUpdated((ScicosID const &)*arg2,arg3,arg4);
1018 }
1019
1020
1021 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1propertyUpdated_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jint jarg5) {
1022   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1023   ScicosID *arg2 = 0 ;
1024   kind_t arg3 ;
1025   object_properties_t arg4 ;
1026   update_status_t arg5 ;
1027   ScicosID temp2 ;
1028   
1029   (void)jenv;
1030   (void)jcls;
1031   (void)jarg1_;
1032   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1033   temp2 = (ScicosID)jarg2; 
1034   arg2 = &temp2; 
1035   arg3 = (kind_t)jarg3; 
1036   arg4 = (object_properties_t)jarg4; 
1037   arg5 = (update_status_t)jarg5; 
1038   (arg1)->propertyUpdated((ScicosID const &)*arg2,arg3,arg4,arg5);
1039 }
1040
1041
1042 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
1043   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1044   (void)jcls;
1045   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1046   if (director) {
1047     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
1048   }
1049 }
1050
1051
1052 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
1053   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1054   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1055   (void)jcls;
1056   if (director) {
1057     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
1058   }
1059 }
1060
1061
1062 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1Controller(JNIEnv *jenv, jclass jcls) {
1063   jlong jresult = 0 ;
1064   org_scilab_modules_scicos::Controller *result = 0 ;
1065   
1066   (void)jenv;
1067   (void)jcls;
1068   result = (org_scilab_modules_scicos::Controller *)new org_scilab_modules_scicos::Controller();
1069   *(org_scilab_modules_scicos::Controller **)&jresult = result; 
1070   return jresult;
1071 }
1072
1073
1074 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1Controller(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1075   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1076   
1077   (void)jenv;
1078   (void)jcls;
1079   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1080   delete arg1;
1081 }
1082
1083
1084 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1createObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1085   jlong jresult = 0 ;
1086   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1087   kind_t arg2 ;
1088   ScicosID result;
1089   
1090   (void)jenv;
1091   (void)jcls;
1092   (void)jarg1_;
1093   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1094   arg2 = (kind_t)jarg2; 
1095   result = (ScicosID)(arg1)->createObject(arg2);
1096   jresult = (jlong)result; 
1097   return jresult;
1098 }
1099
1100
1101 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1referenceObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1102   jlong jresult = 0 ;
1103   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1104   ScicosID arg2 ;
1105   unsigned int result;
1106   
1107   (void)jenv;
1108   (void)jcls;
1109   (void)jarg1_;
1110   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1111   arg2 = (ScicosID)jarg2; 
1112   result = (unsigned int)((org_scilab_modules_scicos::Controller const *)arg1)->referenceObject(arg2);
1113   jresult = (jlong)result; 
1114   return jresult;
1115 }
1116
1117
1118 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1deleteObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1119   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1120   ScicosID arg2 ;
1121   
1122   (void)jenv;
1123   (void)jcls;
1124   (void)jarg1_;
1125   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1126   arg2 = (ScicosID)jarg2; 
1127   (arg1)->deleteObject(arg2);
1128 }
1129
1130
1131 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1cloneObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jboolean jarg3) {
1132   jlong jresult = 0 ;
1133   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1134   ScicosID arg2 ;
1135   bool arg3 ;
1136   ScicosID result;
1137   
1138   (void)jenv;
1139   (void)jcls;
1140   (void)jarg1_;
1141   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1142   arg2 = (ScicosID)jarg2; 
1143   arg3 = jarg3 ? true : false; 
1144   result = (ScicosID)(arg1)->cloneObject(arg2,arg3);
1145   jresult = (jlong)result; 
1146   return jresult;
1147 }
1148
1149
1150 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jintArray jarg5) {
1151   jboolean jresult = 0 ;
1152   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1153   ScicosID arg2 ;
1154   kind_t arg3 ;
1155   object_properties_t arg4 ;
1156   int *arg5 = 0 ;
1157   int temp5 ;
1158   bool result;
1159   
1160   (void)jenv;
1161   (void)jcls;
1162   (void)jarg1_;
1163   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1164   arg2 = (ScicosID)jarg2; 
1165   arg3 = (kind_t)jarg3; 
1166   arg4 = (object_properties_t)jarg4; 
1167   {
1168     if (!jarg5) {
1169       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1170       return 0;
1171     }
1172     if (jenv->GetArrayLength(jarg5) == 0) {
1173       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1174       return 0;
1175     }
1176     temp5 = (int)0;
1177     arg5 = &temp5; 
1178   }
1179   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< int >(arg2,arg3,arg4,*arg5);
1180   jresult = (jboolean)result; 
1181   {
1182     jint jvalue = (jint)temp5;
1183     jenv->SetIntArrayRegion(jarg5, 0, 1, &jvalue);
1184   }
1185   
1186   return jresult;
1187 }
1188
1189
1190 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jdoubleArray jarg5) {
1191   jboolean jresult = 0 ;
1192   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1193   ScicosID arg2 ;
1194   kind_t arg3 ;
1195   object_properties_t arg4 ;
1196   double *arg5 = 0 ;
1197   double temp5 ;
1198   bool result;
1199   
1200   (void)jenv;
1201   (void)jcls;
1202   (void)jarg1_;
1203   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1204   arg2 = (ScicosID)jarg2; 
1205   arg3 = (kind_t)jarg3; 
1206   arg4 = (object_properties_t)jarg4; 
1207   {
1208     if (!jarg5) {
1209       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1210       return 0;
1211     }
1212     if (jenv->GetArrayLength(jarg5) == 0) {
1213       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1214       return 0;
1215     }
1216     temp5 = (double)0;
1217     arg5 = &temp5; 
1218   }
1219   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< double >(arg2,arg3,arg4,*arg5);
1220   jresult = (jboolean)result; 
1221   {
1222     jdouble jvalue = (jdouble)temp5;
1223     jenv->SetDoubleArrayRegion(jarg5, 0, 1, &jvalue);
1224   }
1225   
1226   return jresult;
1227 }
1228
1229
1230 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jobjectArray jarg5) {
1231   jboolean jresult = 0 ;
1232   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1233   ScicosID arg2 ;
1234   kind_t arg3 ;
1235   object_properties_t arg4 ;
1236   std::string *arg5 = 0 ;
1237   std::string temp5 ;
1238   bool result;
1239   
1240   (void)jenv;
1241   (void)jcls;
1242   (void)jarg1_;
1243   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1244   arg2 = (ScicosID)jarg2; 
1245   arg3 = (kind_t)jarg3; 
1246   arg4 = (object_properties_t)jarg4; 
1247   {
1248     if (!jarg5) {
1249       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1250       return 0;
1251     }
1252     if (jenv->GetArrayLength(jarg5) == 0) {
1253       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1254       return 0;
1255     }
1256     arg5 = &temp5; 
1257     *arg5 = "";
1258   }
1259   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::string >(arg2,arg3,arg4,*arg5);
1260   jresult = (jboolean)result; 
1261   {
1262     jstring jnewstring = NULL;
1263     if (arg5) {
1264       jnewstring = jenv->NewStringUTF(arg5->c_str());
1265     }
1266     jenv->SetObjectArrayElement(jarg5, 0, jnewstring); 
1267   }
1268   return jresult;
1269 }
1270
1271
1272 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlongArray jarg5) {
1273   jboolean jresult = 0 ;
1274   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1275   ScicosID arg2 ;
1276   kind_t arg3 ;
1277   object_properties_t arg4 ;
1278   long long *arg5 = 0 ;
1279   long long temp5 ;
1280   bool result;
1281   
1282   (void)jenv;
1283   (void)jcls;
1284   (void)jarg1_;
1285   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1286   arg2 = (ScicosID)jarg2; 
1287   arg3 = (kind_t)jarg3; 
1288   arg4 = (object_properties_t)jarg4; 
1289   {
1290     if (!jarg5) {
1291       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1292       return 0;
1293     }
1294     if (jenv->GetArrayLength(jarg5) == 0) {
1295       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1296       return 0;
1297     }
1298     temp5 = (long long)0;
1299     arg5 = &temp5; 
1300   }
1301   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< ScicosID >(arg2,arg3,arg4,*arg5);
1302   jresult = (jboolean)result; 
1303   {
1304     jlong jvalue = (jlong)temp5;
1305     jenv->SetLongArrayRegion(jarg5, 0, 1, &jvalue);
1306   }
1307   
1308   return jresult;
1309 }
1310
1311
1312 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1313   jboolean jresult = 0 ;
1314   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1315   ScicosID arg2 ;
1316   kind_t arg3 ;
1317   object_properties_t arg4 ;
1318   std::vector< int > *arg5 = 0 ;
1319   bool result;
1320   
1321   (void)jenv;
1322   (void)jcls;
1323   (void)jarg1_;
1324   (void)jarg5_;
1325   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1326   arg2 = (ScicosID)jarg2; 
1327   arg3 = (kind_t)jarg3; 
1328   arg4 = (object_properties_t)jarg4; 
1329   arg5 = *(std::vector< int > **)&jarg5;
1330   if (!arg5) {
1331     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > & reference is null");
1332     return 0;
1333   } 
1334   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< int > >(arg2,arg3,arg4,*arg5);
1335   jresult = (jboolean)result; 
1336   return jresult;
1337 }
1338
1339
1340 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_16(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1341   jboolean jresult = 0 ;
1342   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1343   ScicosID arg2 ;
1344   kind_t arg3 ;
1345   object_properties_t arg4 ;
1346   std::vector< double > *arg5 = 0 ;
1347   bool result;
1348   
1349   (void)jenv;
1350   (void)jcls;
1351   (void)jarg1_;
1352   (void)jarg5_;
1353   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1354   arg2 = (ScicosID)jarg2; 
1355   arg3 = (kind_t)jarg3; 
1356   arg4 = (object_properties_t)jarg4; 
1357   arg5 = *(std::vector< double > **)&jarg5;
1358   if (!arg5) {
1359     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< double > & reference is null");
1360     return 0;
1361   } 
1362   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< double > >(arg2,arg3,arg4,*arg5);
1363   jresult = (jboolean)result; 
1364   return jresult;
1365 }
1366
1367
1368 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_17(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1369   jboolean jresult = 0 ;
1370   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1371   ScicosID arg2 ;
1372   kind_t arg3 ;
1373   object_properties_t arg4 ;
1374   std::vector< std::string > *arg5 = 0 ;
1375   bool result;
1376   
1377   (void)jenv;
1378   (void)jcls;
1379   (void)jarg1_;
1380   (void)jarg5_;
1381   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1382   arg2 = (ScicosID)jarg2; 
1383   arg3 = (kind_t)jarg3; 
1384   arg4 = (object_properties_t)jarg4; 
1385   arg5 = *(std::vector< std::string > **)&jarg5;
1386   if (!arg5) {
1387     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > & reference is null");
1388     return 0;
1389   } 
1390   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< std::string > >(arg2,arg3,arg4,*arg5);
1391   jresult = (jboolean)result; 
1392   return jresult;
1393 }
1394
1395
1396 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_18(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1397   jboolean jresult = 0 ;
1398   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1399   ScicosID arg2 ;
1400   kind_t arg3 ;
1401   object_properties_t arg4 ;
1402   std::vector< long long > *arg5 = 0 ;
1403   bool result;
1404   
1405   (void)jenv;
1406   (void)jcls;
1407   (void)jarg1_;
1408   (void)jarg5_;
1409   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1410   arg2 = (ScicosID)jarg2; 
1411   arg3 = (kind_t)jarg3; 
1412   arg4 = (object_properties_t)jarg4; 
1413   arg5 = *(std::vector< long long > **)&jarg5;
1414   if (!arg5) {
1415     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< long long > & reference is null");
1416     return 0;
1417   } 
1418   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< ScicosID > >(arg2,arg3,arg4,*arg5);
1419   jresult = (jboolean)result; 
1420   return jresult;
1421 }
1422
1423
1424 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jint jarg5) {
1425   jint jresult = 0 ;
1426   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1427   ScicosID arg2 ;
1428   kind_t arg3 ;
1429   object_properties_t arg4 ;
1430   int arg5 ;
1431   update_status_t result;
1432   
1433   (void)jenv;
1434   (void)jcls;
1435   (void)jarg1_;
1436   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1437   arg2 = (ScicosID)jarg2; 
1438   arg3 = (kind_t)jarg3; 
1439   arg4 = (object_properties_t)jarg4; 
1440   arg5 = (int)jarg5; 
1441   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< int >(arg2,arg3,arg4,arg5);
1442   jresult = (jint)result; 
1443   return jresult;
1444 }
1445
1446
1447 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jdouble jarg5) {
1448   jint jresult = 0 ;
1449   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1450   ScicosID arg2 ;
1451   kind_t arg3 ;
1452   object_properties_t arg4 ;
1453   double arg5 ;
1454   update_status_t result;
1455   
1456   (void)jenv;
1457   (void)jcls;
1458   (void)jarg1_;
1459   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1460   arg2 = (ScicosID)jarg2; 
1461   arg3 = (kind_t)jarg3; 
1462   arg4 = (object_properties_t)jarg4; 
1463   arg5 = (double)jarg5; 
1464   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< double >(arg2,arg3,arg4,arg5);
1465   jresult = (jint)result; 
1466   return jresult;
1467 }
1468
1469
1470 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jstring jarg5) {
1471   jint jresult = 0 ;
1472   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1473   ScicosID arg2 ;
1474   kind_t arg3 ;
1475   object_properties_t arg4 ;
1476   std::string arg5 ;
1477   update_status_t result;
1478   
1479   (void)jenv;
1480   (void)jcls;
1481   (void)jarg1_;
1482   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1483   arg2 = (ScicosID)jarg2; 
1484   arg3 = (kind_t)jarg3; 
1485   arg4 = (object_properties_t)jarg4; 
1486   if(!jarg5) {
1487     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
1488     return 0;
1489   } 
1490   const char *arg5_pstr = (const char *)jenv->GetStringUTFChars(jarg5, 0); 
1491   if (!arg5_pstr) return 0;
1492   (&arg5)->assign(arg5_pstr);
1493   jenv->ReleaseStringUTFChars(jarg5, arg5_pstr); 
1494   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::string >(arg2,arg3,arg4,arg5);
1495   jresult = (jint)result; 
1496   return jresult;
1497 }
1498
1499
1500 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5) {
1501   jint jresult = 0 ;
1502   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1503   ScicosID arg2 ;
1504   kind_t arg3 ;
1505   object_properties_t arg4 ;
1506   long long arg5 ;
1507   update_status_t result;
1508   
1509   (void)jenv;
1510   (void)jcls;
1511   (void)jarg1_;
1512   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1513   arg2 = (ScicosID)jarg2; 
1514   arg3 = (kind_t)jarg3; 
1515   arg4 = (object_properties_t)jarg4; 
1516   arg5 = (long long)jarg5; 
1517   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< ScicosID >(arg2,arg3,arg4,arg5);
1518   jresult = (jint)result; 
1519   return jresult;
1520 }
1521
1522
1523 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1524   jint jresult = 0 ;
1525   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1526   ScicosID arg2 ;
1527   kind_t arg3 ;
1528   object_properties_t arg4 ;
1529   std::vector< int > arg5 ;
1530   std::vector< int > *argp5 ;
1531   update_status_t result;
1532   
1533   (void)jenv;
1534   (void)jcls;
1535   (void)jarg1_;
1536   (void)jarg5_;
1537   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1538   arg2 = (ScicosID)jarg2; 
1539   arg3 = (kind_t)jarg3; 
1540   arg4 = (object_properties_t)jarg4; 
1541   argp5 = *(std::vector< int > **)&jarg5; 
1542   if (!argp5) {
1543     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< int >");
1544     return 0;
1545   }
1546   arg5 = *argp5; 
1547   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< int > >(arg2,arg3,arg4,arg5);
1548   jresult = (jint)result; 
1549   return jresult;
1550 }
1551
1552
1553 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_16(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1554   jint jresult = 0 ;
1555   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1556   ScicosID arg2 ;
1557   kind_t arg3 ;
1558   object_properties_t arg4 ;
1559   std::vector< double > arg5 ;
1560   std::vector< double > *argp5 ;
1561   update_status_t result;
1562   
1563   (void)jenv;
1564   (void)jcls;
1565   (void)jarg1_;
1566   (void)jarg5_;
1567   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1568   arg2 = (ScicosID)jarg2; 
1569   arg3 = (kind_t)jarg3; 
1570   arg4 = (object_properties_t)jarg4; 
1571   argp5 = *(std::vector< double > **)&jarg5; 
1572   if (!argp5) {
1573     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< double >");
1574     return 0;
1575   }
1576   arg5 = *argp5; 
1577   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< double > >(arg2,arg3,arg4,arg5);
1578   jresult = (jint)result; 
1579   return jresult;
1580 }
1581
1582
1583 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_17(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1584   jint jresult = 0 ;
1585   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1586   ScicosID arg2 ;
1587   kind_t arg3 ;
1588   object_properties_t arg4 ;
1589   std::vector< std::string > arg5 ;
1590   std::vector< std::string > *argp5 ;
1591   update_status_t result;
1592   
1593   (void)jenv;
1594   (void)jcls;
1595   (void)jarg1_;
1596   (void)jarg5_;
1597   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1598   arg2 = (ScicosID)jarg2; 
1599   arg3 = (kind_t)jarg3; 
1600   arg4 = (object_properties_t)jarg4; 
1601   argp5 = *(std::vector< std::string > **)&jarg5; 
1602   if (!argp5) {
1603     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::string >");
1604     return 0;
1605   }
1606   arg5 = *argp5; 
1607   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< std::string > >(arg2,arg3,arg4,arg5);
1608   jresult = (jint)result; 
1609   return jresult;
1610 }
1611
1612
1613 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_18(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1614   jint jresult = 0 ;
1615   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1616   ScicosID arg2 ;
1617   kind_t arg3 ;
1618   object_properties_t arg4 ;
1619   std::vector< long long > arg5 ;
1620   std::vector< long long > *argp5 ;
1621   update_status_t result;
1622   
1623   (void)jenv;
1624   (void)jcls;
1625   (void)jarg1_;
1626   (void)jarg5_;
1627   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1628   arg2 = (ScicosID)jarg2; 
1629   arg3 = (kind_t)jarg3; 
1630   arg4 = (object_properties_t)jarg4; 
1631   argp5 = *(std::vector< long long > **)&jarg5; 
1632   if (!argp5) {
1633     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< long long >");
1634     return 0;
1635   }
1636   arg5 = *argp5; 
1637   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< ScicosID > >(arg2,arg3,arg4,arg5);
1638   jresult = (jint)result; 
1639   return jresult;
1640 }
1641
1642
1643 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
1644   jlong jresult = 0 ;
1645   std::vector< double > *result = 0 ;
1646   
1647   (void)jenv;
1648   (void)jcls;
1649   result = (std::vector< double > *)new std::vector< double >();
1650   *(std::vector< double > **)&jresult = result; 
1651   return jresult;
1652 }
1653
1654
1655 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1656   jlong jresult = 0 ;
1657   std::vector< double >::size_type arg1 ;
1658   std::vector< double > *result = 0 ;
1659   
1660   (void)jenv;
1661   (void)jcls;
1662   arg1 = (std::vector< double >::size_type)jarg1; 
1663   result = (std::vector< double > *)new std::vector< double >(arg1);
1664   *(std::vector< double > **)&jresult = result; 
1665   return jresult;
1666 }
1667
1668
1669 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1670   jlong jresult = 0 ;
1671   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1672   std::vector< double >::size_type result;
1673   
1674   (void)jenv;
1675   (void)jcls;
1676   (void)jarg1_;
1677   arg1 = *(std::vector< double > **)&jarg1; 
1678   result = ((std::vector< double > const *)arg1)->size();
1679   jresult = (jlong)result; 
1680   return jresult;
1681 }
1682
1683
1684 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1685   jlong jresult = 0 ;
1686   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1687   std::vector< double >::size_type result;
1688   
1689   (void)jenv;
1690   (void)jcls;
1691   (void)jarg1_;
1692   arg1 = *(std::vector< double > **)&jarg1; 
1693   result = ((std::vector< double > const *)arg1)->capacity();
1694   jresult = (jlong)result; 
1695   return jresult;
1696 }
1697
1698
1699 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1700   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1701   std::vector< double >::size_type arg2 ;
1702   
1703   (void)jenv;
1704   (void)jcls;
1705   (void)jarg1_;
1706   arg1 = *(std::vector< double > **)&jarg1; 
1707   arg2 = (std::vector< double >::size_type)jarg2; 
1708   (arg1)->reserve(arg2);
1709 }
1710
1711
1712 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1713   jboolean jresult = 0 ;
1714   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1715   bool result;
1716   
1717   (void)jenv;
1718   (void)jcls;
1719   (void)jarg1_;
1720   arg1 = *(std::vector< double > **)&jarg1; 
1721   result = (bool)((std::vector< double > const *)arg1)->empty();
1722   jresult = (jboolean)result; 
1723   return jresult;
1724 }
1725
1726
1727 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1728   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1729   
1730   (void)jenv;
1731   (void)jcls;
1732   (void)jarg1_;
1733   arg1 = *(std::vector< double > **)&jarg1; 
1734   (arg1)->clear();
1735 }
1736
1737
1738 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
1739   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1740   std::vector< double >::value_type *arg2 = 0 ;
1741   std::vector< double >::value_type temp2 ;
1742   
1743   (void)jenv;
1744   (void)jcls;
1745   (void)jarg1_;
1746   arg1 = *(std::vector< double > **)&jarg1; 
1747   temp2 = (std::vector< double >::value_type)jarg2; 
1748   arg2 = &temp2; 
1749   (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
1750 }
1751
1752
1753 SWIGEXPORT jdouble JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1754   jdouble jresult = 0 ;
1755   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1756   int arg2 ;
1757   std::vector< double >::value_type *result = 0 ;
1758   
1759   (void)jenv;
1760   (void)jcls;
1761   (void)jarg1_;
1762   arg1 = *(std::vector< double > **)&jarg1; 
1763   arg2 = (int)jarg2; 
1764   try {
1765     result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__get(arg1,arg2);
1766   }
1767   catch(std::out_of_range &_e) {
1768     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
1769     return 0;
1770   }
1771   
1772   jresult = (jdouble)*result; 
1773   return jresult;
1774 }
1775
1776
1777 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) {
1778   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1779   int arg2 ;
1780   std::vector< double >::value_type *arg3 = 0 ;
1781   std::vector< double >::value_type temp3 ;
1782   
1783   (void)jenv;
1784   (void)jcls;
1785   (void)jarg1_;
1786   arg1 = *(std::vector< double > **)&jarg1; 
1787   arg2 = (int)jarg2; 
1788   temp3 = (std::vector< double >::value_type)jarg3; 
1789   arg3 = &temp3; 
1790   try {
1791     std_vector_Sl_double_Sg__set(arg1,arg2,(double const &)*arg3);
1792   }
1793   catch(std::out_of_range &_e) {
1794     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
1795     return ;
1796   }
1797   
1798 }
1799
1800
1801 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfDouble(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1802   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1803   
1804   (void)jenv;
1805   (void)jcls;
1806   arg1 = *(std::vector< double > **)&jarg1; 
1807   delete arg1;
1808 }
1809
1810
1811 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
1812   jlong jresult = 0 ;
1813   std::vector< int > *result = 0 ;
1814   
1815   (void)jenv;
1816   (void)jcls;
1817   result = (std::vector< int > *)new std::vector< int >();
1818   *(std::vector< int > **)&jresult = result; 
1819   return jresult;
1820 }
1821
1822
1823 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1824   jlong jresult = 0 ;
1825   std::vector< int >::size_type arg1 ;
1826   std::vector< int > *result = 0 ;
1827   
1828   (void)jenv;
1829   (void)jcls;
1830   arg1 = (std::vector< int >::size_type)jarg1; 
1831   result = (std::vector< int > *)new std::vector< int >(arg1);
1832   *(std::vector< int > **)&jresult = result; 
1833   return jresult;
1834 }
1835
1836
1837 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1838   jlong jresult = 0 ;
1839   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1840   std::vector< int >::size_type result;
1841   
1842   (void)jenv;
1843   (void)jcls;
1844   (void)jarg1_;
1845   arg1 = *(std::vector< int > **)&jarg1; 
1846   result = ((std::vector< int > const *)arg1)->size();
1847   jresult = (jlong)result; 
1848   return jresult;
1849 }
1850
1851
1852 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1853   jlong jresult = 0 ;
1854   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1855   std::vector< int >::size_type result;
1856   
1857   (void)jenv;
1858   (void)jcls;
1859   (void)jarg1_;
1860   arg1 = *(std::vector< int > **)&jarg1; 
1861   result = ((std::vector< int > const *)arg1)->capacity();
1862   jresult = (jlong)result; 
1863   return jresult;
1864 }
1865
1866
1867 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1868   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1869   std::vector< int >::size_type arg2 ;
1870   
1871   (void)jenv;
1872   (void)jcls;
1873   (void)jarg1_;
1874   arg1 = *(std::vector< int > **)&jarg1; 
1875   arg2 = (std::vector< int >::size_type)jarg2; 
1876   (arg1)->reserve(arg2);
1877 }
1878
1879
1880 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1881   jboolean jresult = 0 ;
1882   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1883   bool result;
1884   
1885   (void)jenv;
1886   (void)jcls;
1887   (void)jarg1_;
1888   arg1 = *(std::vector< int > **)&jarg1; 
1889   result = (bool)((std::vector< int > const *)arg1)->empty();
1890   jresult = (jboolean)result; 
1891   return jresult;
1892 }
1893
1894
1895 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1896   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1897   
1898   (void)jenv;
1899   (void)jcls;
1900   (void)jarg1_;
1901   arg1 = *(std::vector< int > **)&jarg1; 
1902   (arg1)->clear();
1903 }
1904
1905
1906 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1907   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1908   std::vector< int >::value_type *arg2 = 0 ;
1909   std::vector< int >::value_type temp2 ;
1910   
1911   (void)jenv;
1912   (void)jcls;
1913   (void)jarg1_;
1914   arg1 = *(std::vector< int > **)&jarg1; 
1915   temp2 = (std::vector< int >::value_type)jarg2; 
1916   arg2 = &temp2; 
1917   (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
1918 }
1919
1920
1921 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1922   jint jresult = 0 ;
1923   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1924   int arg2 ;
1925   std::vector< int >::value_type *result = 0 ;
1926   
1927   (void)jenv;
1928   (void)jcls;
1929   (void)jarg1_;
1930   arg1 = *(std::vector< int > **)&jarg1; 
1931   arg2 = (int)jarg2; 
1932   try {
1933     result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__get(arg1,arg2);
1934   }
1935   catch(std::out_of_range &_e) {
1936     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
1937     return 0;
1938   }
1939   
1940   jresult = (jint)*result; 
1941   return jresult;
1942 }
1943
1944
1945 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
1946   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1947   int arg2 ;
1948   std::vector< int >::value_type *arg3 = 0 ;
1949   std::vector< int >::value_type temp3 ;
1950   
1951   (void)jenv;
1952   (void)jcls;
1953   (void)jarg1_;
1954   arg1 = *(std::vector< int > **)&jarg1; 
1955   arg2 = (int)jarg2; 
1956   temp3 = (std::vector< int >::value_type)jarg3; 
1957   arg3 = &temp3; 
1958   try {
1959     std_vector_Sl_int_Sg__set(arg1,arg2,(int const &)*arg3);
1960   }
1961   catch(std::out_of_range &_e) {
1962     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
1963     return ;
1964   }
1965   
1966 }
1967
1968
1969 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfInt(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1970   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1971   
1972   (void)jenv;
1973   (void)jcls;
1974   arg1 = *(std::vector< int > **)&jarg1; 
1975   delete arg1;
1976 }
1977
1978
1979 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
1980   jlong jresult = 0 ;
1981   std::vector< bool > *result = 0 ;
1982   
1983   (void)jenv;
1984   (void)jcls;
1985   result = (std::vector< bool > *)new std::vector< bool >();
1986   *(std::vector< bool > **)&jresult = result; 
1987   return jresult;
1988 }
1989
1990
1991 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1992   jlong jresult = 0 ;
1993   std::vector< bool >::size_type arg1 ;
1994   std::vector< bool > *result = 0 ;
1995   
1996   (void)jenv;
1997   (void)jcls;
1998   arg1 = (std::vector< bool >::size_type)jarg1; 
1999   result = (std::vector< bool > *)new std::vector< bool >(arg1);
2000   *(std::vector< bool > **)&jresult = result; 
2001   return jresult;
2002 }
2003
2004
2005 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2006   jlong jresult = 0 ;
2007   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2008   std::vector< bool >::size_type result;
2009   
2010   (void)jenv;
2011   (void)jcls;
2012   (void)jarg1_;
2013   arg1 = *(std::vector< bool > **)&jarg1; 
2014   result = ((std::vector< bool > const *)arg1)->size();
2015   jresult = (jlong)result; 
2016   return jresult;
2017 }
2018
2019
2020 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2021   jlong jresult = 0 ;
2022   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2023   std::vector< bool >::size_type result;
2024   
2025   (void)jenv;
2026   (void)jcls;
2027   (void)jarg1_;
2028   arg1 = *(std::vector< bool > **)&jarg1; 
2029   result = ((std::vector< bool > const *)arg1)->capacity();
2030   jresult = (jlong)result; 
2031   return jresult;
2032 }
2033
2034
2035 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2036   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2037   std::vector< bool >::size_type arg2 ;
2038   
2039   (void)jenv;
2040   (void)jcls;
2041   (void)jarg1_;
2042   arg1 = *(std::vector< bool > **)&jarg1; 
2043   arg2 = (std::vector< bool >::size_type)jarg2; 
2044   (arg1)->reserve(arg2);
2045 }
2046
2047
2048 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2049   jboolean jresult = 0 ;
2050   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2051   bool result;
2052   
2053   (void)jenv;
2054   (void)jcls;
2055   (void)jarg1_;
2056   arg1 = *(std::vector< bool > **)&jarg1; 
2057   result = (bool)((std::vector< bool > const *)arg1)->empty();
2058   jresult = (jboolean)result; 
2059   return jresult;
2060 }
2061
2062
2063 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2064   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2065   
2066   (void)jenv;
2067   (void)jcls;
2068   (void)jarg1_;
2069   arg1 = *(std::vector< bool > **)&jarg1; 
2070   (arg1)->clear();
2071 }
2072
2073
2074 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
2075   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2076   std::vector< bool >::value_type *arg2 = 0 ;
2077   std::vector< bool >::value_type temp2 ;
2078   
2079   (void)jenv;
2080   (void)jcls;
2081   (void)jarg1_;
2082   arg1 = *(std::vector< bool > **)&jarg1; 
2083   temp2 = jarg2 ? true : false; 
2084   arg2 = &temp2; 
2085   (arg1)->push_back((std::vector< bool >::value_type const &)*arg2);
2086 }
2087
2088
2089 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2090   jboolean jresult = 0 ;
2091   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2092   int arg2 ;
2093   bool result;
2094   
2095   (void)jenv;
2096   (void)jcls;
2097   (void)jarg1_;
2098   arg1 = *(std::vector< bool > **)&jarg1; 
2099   arg2 = (int)jarg2; 
2100   try {
2101     result = (bool)std_vector_Sl_bool_Sg__get(arg1,arg2);
2102   }
2103   catch(std::out_of_range &_e) {
2104     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2105     return 0;
2106   }
2107   
2108   jresult = (jboolean)result; 
2109   return jresult;
2110 }
2111
2112
2113 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
2114   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2115   int arg2 ;
2116   std::vector< bool >::value_type *arg3 = 0 ;
2117   std::vector< bool >::value_type temp3 ;
2118   
2119   (void)jenv;
2120   (void)jcls;
2121   (void)jarg1_;
2122   arg1 = *(std::vector< bool > **)&jarg1; 
2123   arg2 = (int)jarg2; 
2124   temp3 = jarg3 ? true : false; 
2125   arg3 = &temp3; 
2126   try {
2127     std_vector_Sl_bool_Sg__set(arg1,arg2,(bool const &)*arg3);
2128   }
2129   catch(std::out_of_range &_e) {
2130     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2131     return ;
2132   }
2133   
2134 }
2135
2136
2137 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfBool(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2138   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2139   
2140   (void)jenv;
2141   (void)jcls;
2142   arg1 = *(std::vector< bool > **)&jarg1; 
2143   delete arg1;
2144 }
2145
2146
2147 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2148   jlong jresult = 0 ;
2149   std::vector< std::string > *result = 0 ;
2150   
2151   (void)jenv;
2152   (void)jcls;
2153   result = (std::vector< std::string > *)new std::vector< std::string >();
2154   *(std::vector< std::string > **)&jresult = result; 
2155   return jresult;
2156 }
2157
2158
2159 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2160   jlong jresult = 0 ;
2161   std::vector< std::string >::size_type arg1 ;
2162   std::vector< std::string > *result = 0 ;
2163   
2164   (void)jenv;
2165   (void)jcls;
2166   arg1 = (std::vector< std::string >::size_type)jarg1; 
2167   result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
2168   *(std::vector< std::string > **)&jresult = result; 
2169   return jresult;
2170 }
2171
2172
2173 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2174   jlong jresult = 0 ;
2175   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2176   std::vector< std::string >::size_type result;
2177   
2178   (void)jenv;
2179   (void)jcls;
2180   (void)jarg1_;
2181   arg1 = *(std::vector< std::string > **)&jarg1; 
2182   result = ((std::vector< std::string > const *)arg1)->size();
2183   jresult = (jlong)result; 
2184   return jresult;
2185 }
2186
2187
2188 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2189   jlong jresult = 0 ;
2190   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2191   std::vector< std::string >::size_type result;
2192   
2193   (void)jenv;
2194   (void)jcls;
2195   (void)jarg1_;
2196   arg1 = *(std::vector< std::string > **)&jarg1; 
2197   result = ((std::vector< std::string > const *)arg1)->capacity();
2198   jresult = (jlong)result; 
2199   return jresult;
2200 }
2201
2202
2203 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2204   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2205   std::vector< std::string >::size_type arg2 ;
2206   
2207   (void)jenv;
2208   (void)jcls;
2209   (void)jarg1_;
2210   arg1 = *(std::vector< std::string > **)&jarg1; 
2211   arg2 = (std::vector< std::string >::size_type)jarg2; 
2212   (arg1)->reserve(arg2);
2213 }
2214
2215
2216 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2217   jboolean jresult = 0 ;
2218   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2219   bool result;
2220   
2221   (void)jenv;
2222   (void)jcls;
2223   (void)jarg1_;
2224   arg1 = *(std::vector< std::string > **)&jarg1; 
2225   result = (bool)((std::vector< std::string > const *)arg1)->empty();
2226   jresult = (jboolean)result; 
2227   return jresult;
2228 }
2229
2230
2231 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2232   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2233   
2234   (void)jenv;
2235   (void)jcls;
2236   (void)jarg1_;
2237   arg1 = *(std::vector< std::string > **)&jarg1; 
2238   (arg1)->clear();
2239 }
2240
2241
2242 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2243   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2244   std::vector< std::string >::value_type *arg2 = 0 ;
2245   
2246   (void)jenv;
2247   (void)jcls;
2248   (void)jarg1_;
2249   arg1 = *(std::vector< std::string > **)&jarg1; 
2250   if(!jarg2) {
2251     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2252     return ;
2253   }
2254   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2255   if (!arg2_pstr) return ;
2256   std::vector< std::string >::value_type arg2_str(arg2_pstr);
2257   arg2 = &arg2_str;
2258   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2259   (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
2260 }
2261
2262
2263 SWIGEXPORT jstring JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2264   jstring jresult = 0 ;
2265   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2266   int arg2 ;
2267   std::vector< std::string >::value_type *result = 0 ;
2268   
2269   (void)jenv;
2270   (void)jcls;
2271   (void)jarg1_;
2272   arg1 = *(std::vector< std::string > **)&jarg1; 
2273   arg2 = (int)jarg2; 
2274   try {
2275     result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__get(arg1,arg2);
2276   }
2277   catch(std::out_of_range &_e) {
2278     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2279     return 0;
2280   }
2281   
2282   jresult = jenv->NewStringUTF(result->c_str()); 
2283   return jresult;
2284 }
2285
2286
2287 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
2288   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2289   int arg2 ;
2290   std::vector< std::string >::value_type *arg3 = 0 ;
2291   
2292   (void)jenv;
2293   (void)jcls;
2294   (void)jarg1_;
2295   arg1 = *(std::vector< std::string > **)&jarg1; 
2296   arg2 = (int)jarg2; 
2297   if(!jarg3) {
2298     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2299     return ;
2300   }
2301   const char *arg3_pstr = (const char *)jenv->GetStringUTFChars(jarg3, 0); 
2302   if (!arg3_pstr) return ;
2303   std::vector< std::string >::value_type arg3_str(arg3_pstr);
2304   arg3 = &arg3_str;
2305   jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
2306   try {
2307     std_vector_Sl_std_string_Sg__set(arg1,arg2,(std::string const &)*arg3);
2308   }
2309   catch(std::out_of_range &_e) {
2310     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2311     return ;
2312   }
2313   
2314 }
2315
2316
2317 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfString(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2318   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2319   
2320   (void)jenv;
2321   (void)jcls;
2322   arg1 = *(std::vector< std::string > **)&jarg1; 
2323   delete arg1;
2324 }
2325
2326
2327 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2328   jlong jresult = 0 ;
2329   std::vector< ScicosID > *result = 0 ;
2330   
2331   (void)jenv;
2332   (void)jcls;
2333   result = (std::vector< ScicosID > *)new std::vector< ScicosID >();
2334   *(std::vector< ScicosID > **)&jresult = result; 
2335   return jresult;
2336 }
2337
2338
2339 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2340   jlong jresult = 0 ;
2341   std::vector< long long >::size_type arg1 ;
2342   std::vector< ScicosID > *result = 0 ;
2343   
2344   (void)jenv;
2345   (void)jcls;
2346   arg1 = (std::vector< long long >::size_type)jarg1; 
2347   result = (std::vector< ScicosID > *)new std::vector< ScicosID >(arg1);
2348   *(std::vector< ScicosID > **)&jresult = result; 
2349   return jresult;
2350 }
2351
2352
2353 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2354   jlong jresult = 0 ;
2355   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2356   std::vector< long long >::size_type result;
2357   
2358   (void)jenv;
2359   (void)jcls;
2360   (void)jarg1_;
2361   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2362   result = ((std::vector< ScicosID > const *)arg1)->size();
2363   jresult = (jlong)result; 
2364   return jresult;
2365 }
2366
2367
2368 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2369   jlong jresult = 0 ;
2370   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2371   std::vector< long long >::size_type result;
2372   
2373   (void)jenv;
2374   (void)jcls;
2375   (void)jarg1_;
2376   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2377   result = ((std::vector< ScicosID > const *)arg1)->capacity();
2378   jresult = (jlong)result; 
2379   return jresult;
2380 }
2381
2382
2383 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2384   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2385   std::vector< long long >::size_type arg2 ;
2386   
2387   (void)jenv;
2388   (void)jcls;
2389   (void)jarg1_;
2390   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2391   arg2 = (std::vector< long long >::size_type)jarg2; 
2392   (arg1)->reserve(arg2);
2393 }
2394
2395
2396 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2397   jboolean jresult = 0 ;
2398   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2399   bool result;
2400   
2401   (void)jenv;
2402   (void)jcls;
2403   (void)jarg1_;
2404   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2405   result = (bool)((std::vector< ScicosID > const *)arg1)->empty();
2406   jresult = (jboolean)result; 
2407   return jresult;
2408 }
2409
2410
2411 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2412   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2413   
2414   (void)jenv;
2415   (void)jcls;
2416   (void)jarg1_;
2417   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2418   (arg1)->clear();
2419 }
2420
2421
2422 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2423   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2424   std::vector< long long >::value_type *arg2 = 0 ;
2425   std::vector< long long >::value_type temp2 ;
2426   
2427   (void)jenv;
2428   (void)jcls;
2429   (void)jarg1_;
2430   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2431   temp2 = (std::vector< long long >::value_type)jarg2; 
2432   arg2 = &temp2; 
2433   (arg1)->push_back((std::vector< long long >::value_type const &)*arg2);
2434 }
2435
2436
2437 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2438   jlong jresult = 0 ;
2439   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2440   int arg2 ;
2441   std::vector< long long >::value_type *result = 0 ;
2442   
2443   (void)jenv;
2444   (void)jcls;
2445   (void)jarg1_;
2446   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2447   arg2 = (int)jarg2; 
2448   try {
2449     result = (std::vector< long long >::value_type *) &std_vector_Sl_ScicosID_Sg__get(arg1,arg2);
2450   }
2451   catch(std::out_of_range &_e) {
2452     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2453     return 0;
2454   }
2455   
2456   jresult = (jlong)*result; 
2457   return jresult;
2458 }
2459
2460
2461 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
2462   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2463   int arg2 ;
2464   std::vector< long long >::value_type *arg3 = 0 ;
2465   std::vector< long long >::value_type temp3 ;
2466   
2467   (void)jenv;
2468   (void)jcls;
2469   (void)jarg1_;
2470   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2471   arg2 = (int)jarg2; 
2472   temp3 = (std::vector< long long >::value_type)jarg3; 
2473   arg3 = &temp3; 
2474   try {
2475     std_vector_Sl_ScicosID_Sg__set(arg1,arg2,(long long const &)*arg3);
2476   }
2477   catch(std::out_of_range &_e) {
2478     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2479     return ;
2480   }
2481   
2482 }
2483
2484
2485 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfScicosID(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2486   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2487   
2488   (void)jenv;
2489   (void)jcls;
2490   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2491   delete arg1;
2492 }
2493
2494
2495 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_register_1view(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
2496   std::string *arg1 = 0 ;
2497   org_scilab_modules_scicos::View *arg2 = (org_scilab_modules_scicos::View *) 0 ;
2498   
2499   (void)jenv;
2500   (void)jcls;
2501   (void)jarg2_;
2502   if(!jarg1) {
2503     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2504     return ;
2505   }
2506   const char *arg1_pstr = (const char *)jenv->GetStringUTFChars(jarg1, 0); 
2507   if (!arg1_pstr) return ;
2508   std::string arg1_str(arg1_pstr);
2509   arg1 = &arg1_str;
2510   jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
2511   arg2 = *(org_scilab_modules_scicos::View **)&jarg2; 
2512   register_view((std::string const &)*arg1,arg2);
2513 }
2514
2515
2516 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) {
2517   int i;
2518   
2519   static struct {
2520     const char *method;
2521     const char *signature;
2522   } methods[4] = {
2523     {
2524       "SwigDirector_View_objectCreated", "(Lorg/scilab/modules/xcos/View;JI)V" 
2525     },
2526     {
2527       "SwigDirector_View_objectDeleted", "(Lorg/scilab/modules/xcos/View;JI)V" 
2528     },
2529     {
2530       "SwigDirector_View_objectUpdated", "(Lorg/scilab/modules/xcos/View;JI)V" 
2531     },
2532     {
2533       "SwigDirector_View_propertyUpdated__SWIG_0", "(Lorg/scilab/modules/xcos/View;JII)V" 
2534     }
2535   };
2536   Swig::jclass_JavaControllerJNI = (jclass) jenv->NewGlobalRef(jcls);
2537   if (!Swig::jclass_JavaControllerJNI) return;
2538   for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {
2539     Swig::director_method_ids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);
2540     if (!Swig::director_method_ids[i]) return;
2541   }
2542 }
2543
2544
2545 #ifdef __cplusplus
2546 }
2547 #endif
2548