3ae7cd4b97f42fc50fa1f85c46fb4caba8cbb128
[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[5];
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< int >::const_reference std_vector_Sl_int_Sg__get(std::vector< int > *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_int_Sg__set(std::vector< int > *self,int i,std::vector< int >::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 bool std_vector_Sl_bool_Sg__get(std::vector< bool > *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_bool_Sg__set(std::vector< bool > *self,int i,std::vector< bool >::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 std::vector< double >::const_reference std_vector_Sl_double_Sg__get(std::vector< double > *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_double_Sg__set(std::vector< double > *self,int i,std::vector< double >::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 static void unregister_view(org_scilab_modules_scicos::View* view) {
754   org_scilab_modules_scicos::Controller::unregister_view(view);
755 };
756
757
758
759 /* ---------------------------------------------------
760  * C++ director class methods
761  * --------------------------------------------------- */
762
763 #include "JavaController_wrap.h"
764
765 SwigDirector_View::SwigDirector_View(JNIEnv *jenv) : org_scilab_modules_scicos::View(), Swig::Director(jenv) {
766 }
767
768 SwigDirector_View::~SwigDirector_View() {
769   swig_disconnect_director_self("swigDirectorDisconnect");
770 }
771
772
773 void SwigDirector_View::objectCreated(ScicosID const &uid, kind_t kind) {
774   JNIEnvWrapper swigjnienv(this) ;
775   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
776   jobject swigjobj = (jobject) NULL ;
777   jlong juid = 0 ;
778   jint jkind  ;
779   
780   if (!swig_override[0]) {
781     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectCreated.");
782     return;
783   }
784   swigjobj = swig_get_self(jenv);
785   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
786     juid = (jlong)uid;
787     jkind = (jint) kind;
788     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[0], swigjobj, juid, jkind);
789     jthrowable swigerror = jenv->ExceptionOccurred();
790     if (swigerror) {
791       jenv->ExceptionClear();
792       throw Swig::DirectorException(jenv, swigerror);
793     }
794     
795   } else {
796     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectCreated ");
797   }
798   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
799 }
800
801 void SwigDirector_View::objectReferenced(ScicosID const &uid, kind_t kind) {
802   JNIEnvWrapper swigjnienv(this) ;
803   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
804   jobject swigjobj = (jobject) NULL ;
805   jlong juid = 0 ;
806   jint jkind  ;
807   
808   if (!swig_override[1]) {
809     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectReferenced.");
810     return;
811   }
812   swigjobj = swig_get_self(jenv);
813   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
814     juid = (jlong)uid;
815     jkind = (jint) kind;
816     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[1], swigjobj, juid, jkind);
817     jthrowable swigerror = jenv->ExceptionOccurred();
818     if (swigerror) {
819       jenv->ExceptionClear();
820       throw Swig::DirectorException(jenv, swigerror);
821     }
822     
823   } else {
824     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectReferenced ");
825   }
826   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
827 }
828
829 void SwigDirector_View::objectUnreferenced(ScicosID const &uid, kind_t kind) {
830   JNIEnvWrapper swigjnienv(this) ;
831   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
832   jobject swigjobj = (jobject) NULL ;
833   jlong juid = 0 ;
834   jint jkind  ;
835   
836   if (!swig_override[2]) {
837     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectUnreferenced.");
838     return;
839   }
840   swigjobj = swig_get_self(jenv);
841   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
842     juid = (jlong)uid;
843     jkind = (jint) kind;
844     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[2], swigjobj, juid, jkind);
845     jthrowable swigerror = jenv->ExceptionOccurred();
846     if (swigerror) {
847       jenv->ExceptionClear();
848       throw Swig::DirectorException(jenv, swigerror);
849     }
850     
851   } else {
852     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectUnreferenced ");
853   }
854   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
855 }
856
857 void SwigDirector_View::objectDeleted(ScicosID const &uid, kind_t kind) {
858   JNIEnvWrapper swigjnienv(this) ;
859   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
860   jobject swigjobj = (jobject) NULL ;
861   jlong juid = 0 ;
862   jint jkind  ;
863   
864   if (!swig_override[3]) {
865     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectDeleted.");
866     return;
867   }
868   swigjobj = swig_get_self(jenv);
869   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
870     juid = (jlong)uid;
871     jkind = (jint) kind;
872     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[3], swigjobj, juid, jkind);
873     jthrowable swigerror = jenv->ExceptionOccurred();
874     if (swigerror) {
875       jenv->ExceptionClear();
876       throw Swig::DirectorException(jenv, swigerror);
877     }
878     
879   } else {
880     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectDeleted ");
881   }
882   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
883 }
884
885 void SwigDirector_View::propertyUpdated(ScicosID const &uid, kind_t kind, object_properties_t property, update_status_t status) {
886   JNIEnvWrapper swigjnienv(this) ;
887   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
888   jobject swigjobj = (jobject) NULL ;
889   jlong juid = 0 ;
890   jint jkind  ;
891   jint jproperty  ;
892   jint jstatus  ;
893   
894   if (!swig_override[4]) {
895     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::propertyUpdated.");
896     return;
897   }
898   swigjobj = swig_get_self(jenv);
899   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
900     juid = (jlong)uid;
901     jkind = (jint) kind;
902     jproperty = (jint) property;
903     jstatus = (jint) status;
904     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[4], swigjobj, juid, jkind, jproperty, jstatus);
905     jthrowable swigerror = jenv->ExceptionOccurred();
906     if (swigerror) {
907       jenv->ExceptionClear();
908       throw Swig::DirectorException(jenv, swigerror);
909     }
910     
911   } else {
912     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::propertyUpdated ");
913   }
914   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
915 }
916
917 void SwigDirector_View::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
918   static struct {
919     const char *mname;
920     const char *mdesc;
921     jmethodID base_methid;
922   } methods[] = {
923     {
924       "objectCreated", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
925     },
926     {
927       "objectReferenced", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
928     },
929     {
930       "objectUnreferenced", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
931     },
932     {
933       "objectDeleted", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
934     },
935     {
936       "propertyUpdated", "(JLorg/scilab/modules/xcos/Kind;Lorg/scilab/modules/xcos/ObjectProperties;Lorg/scilab/modules/xcos/UpdateStatus;)V", NULL 
937     }
938   };
939   
940   static jclass baseclass = 0 ;
941   
942   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
943     if (!baseclass) {
944       baseclass = jenv->FindClass("org/scilab/modules/xcos/View");
945       if (!baseclass) return;
946       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
947     }
948     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
949     for (int i = 0; i < 5; ++i) {
950       if (!methods[i].base_methid) {
951         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
952         if (!methods[i].base_methid) return;
953       }
954       swig_override[i] = false;
955       if (derived) {
956         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
957         swig_override[i] = (methid != methods[i].base_methid);
958         jenv->ExceptionClear();
959       }
960     }
961   }
962 }
963
964
965
966 #ifdef __cplusplus
967 extern "C" {
968 #endif
969
970 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1View(JNIEnv *jenv, jclass jcls) {
971   jlong jresult = 0 ;
972   org_scilab_modules_scicos::View *result = 0 ;
973   
974   (void)jenv;
975   (void)jcls;
976   result = (org_scilab_modules_scicos::View *)new SwigDirector_View(jenv);
977   *(org_scilab_modules_scicos::View **)&jresult = result; 
978   return jresult;
979 }
980
981
982 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1View(JNIEnv *jenv, jclass jcls, jlong jarg1) {
983   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
984   
985   (void)jenv;
986   (void)jcls;
987   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
988   delete arg1;
989 }
990
991
992 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectCreated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
993   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
994   ScicosID *arg2 = 0 ;
995   kind_t arg3 ;
996   ScicosID temp2 ;
997   
998   (void)jenv;
999   (void)jcls;
1000   (void)jarg1_;
1001   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1002   temp2 = (ScicosID)jarg2; 
1003   arg2 = &temp2; 
1004   arg3 = (kind_t)jarg3; 
1005   (arg1)->objectCreated((ScicosID const &)*arg2,arg3);
1006 }
1007
1008
1009 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectReferenced(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1010   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1011   ScicosID *arg2 = 0 ;
1012   kind_t arg3 ;
1013   ScicosID temp2 ;
1014   
1015   (void)jenv;
1016   (void)jcls;
1017   (void)jarg1_;
1018   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1019   temp2 = (ScicosID)jarg2; 
1020   arg2 = &temp2; 
1021   arg3 = (kind_t)jarg3; 
1022   (arg1)->objectReferenced((ScicosID const &)*arg2,arg3);
1023 }
1024
1025
1026 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectUnreferenced(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1027   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1028   ScicosID *arg2 = 0 ;
1029   kind_t arg3 ;
1030   ScicosID temp2 ;
1031   
1032   (void)jenv;
1033   (void)jcls;
1034   (void)jarg1_;
1035   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1036   temp2 = (ScicosID)jarg2; 
1037   arg2 = &temp2; 
1038   arg3 = (kind_t)jarg3; 
1039   (arg1)->objectUnreferenced((ScicosID const &)*arg2,arg3);
1040 }
1041
1042
1043 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectDeleted(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1044   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1045   ScicosID *arg2 = 0 ;
1046   kind_t arg3 ;
1047   ScicosID temp2 ;
1048   
1049   (void)jenv;
1050   (void)jcls;
1051   (void)jarg1_;
1052   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1053   temp2 = (ScicosID)jarg2; 
1054   arg2 = &temp2; 
1055   arg3 = (kind_t)jarg3; 
1056   (arg1)->objectDeleted((ScicosID const &)*arg2,arg3);
1057 }
1058
1059
1060 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1propertyUpdated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jint jarg5) {
1061   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1062   ScicosID *arg2 = 0 ;
1063   kind_t arg3 ;
1064   object_properties_t arg4 ;
1065   update_status_t arg5 ;
1066   ScicosID temp2 ;
1067   
1068   (void)jenv;
1069   (void)jcls;
1070   (void)jarg1_;
1071   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1072   temp2 = (ScicosID)jarg2; 
1073   arg2 = &temp2; 
1074   arg3 = (kind_t)jarg3; 
1075   arg4 = (object_properties_t)jarg4; 
1076   arg5 = (update_status_t)jarg5; 
1077   (arg1)->propertyUpdated((ScicosID const &)*arg2,arg3,arg4,arg5);
1078 }
1079
1080
1081 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) {
1082   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1083   (void)jcls;
1084   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1085   if (director) {
1086     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
1087   }
1088 }
1089
1090
1091 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
1092   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1093   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1094   (void)jcls;
1095   if (director) {
1096     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
1097   }
1098 }
1099
1100
1101 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1look_1for_1view(JNIEnv *jenv, jclass jcls, jstring jarg1) {
1102   jlong jresult = 0 ;
1103   std::string *arg1 = 0 ;
1104   org_scilab_modules_scicos::View *result = 0 ;
1105   
1106   (void)jenv;
1107   (void)jcls;
1108   if(!jarg1) {
1109     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
1110     return 0;
1111   }
1112   const char *arg1_pstr = (const char *)jenv->GetStringUTFChars(jarg1, 0); 
1113   if (!arg1_pstr) return 0;
1114   std::string arg1_str(arg1_pstr);
1115   arg1 = &arg1_str;
1116   jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
1117   result = (org_scilab_modules_scicos::View *)org_scilab_modules_scicos::Controller::look_for_view((std::string const &)*arg1);
1118   *(org_scilab_modules_scicos::View **)&jresult = result; 
1119   return jresult;
1120 }
1121
1122
1123 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1Controller(JNIEnv *jenv, jclass jcls) {
1124   jlong jresult = 0 ;
1125   org_scilab_modules_scicos::Controller *result = 0 ;
1126   
1127   (void)jenv;
1128   (void)jcls;
1129   result = (org_scilab_modules_scicos::Controller *)new org_scilab_modules_scicos::Controller();
1130   *(org_scilab_modules_scicos::Controller **)&jresult = result; 
1131   return jresult;
1132 }
1133
1134
1135 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1Controller(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1136   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1137   
1138   (void)jenv;
1139   (void)jcls;
1140   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1141   delete arg1;
1142 }
1143
1144
1145 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1createObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1146   jlong jresult = 0 ;
1147   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1148   kind_t arg2 ;
1149   ScicosID result;
1150   
1151   (void)jenv;
1152   (void)jcls;
1153   (void)jarg1_;
1154   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1155   arg2 = (kind_t)jarg2; 
1156   result = (ScicosID)(arg1)->createObject(arg2);
1157   jresult = (jlong)result; 
1158   return jresult;
1159 }
1160
1161
1162 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1referenceObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1163   jlong jresult = 0 ;
1164   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1165   ScicosID arg2 ;
1166   unsigned int result;
1167   
1168   (void)jenv;
1169   (void)jcls;
1170   (void)jarg1_;
1171   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1172   arg2 = (ScicosID)jarg2; 
1173   result = (unsigned int)((org_scilab_modules_scicos::Controller const *)arg1)->referenceObject(arg2);
1174   jresult = (jlong)result; 
1175   return jresult;
1176 }
1177
1178
1179 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1deleteObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1180   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1181   ScicosID arg2 ;
1182   
1183   (void)jenv;
1184   (void)jcls;
1185   (void)jarg1_;
1186   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1187   arg2 = (ScicosID)jarg2; 
1188   (arg1)->deleteObject(arg2);
1189 }
1190
1191
1192 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1cloneObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jboolean jarg3) {
1193   jlong jresult = 0 ;
1194   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1195   ScicosID arg2 ;
1196   bool arg3 ;
1197   ScicosID result;
1198   
1199   (void)jenv;
1200   (void)jcls;
1201   (void)jarg1_;
1202   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1203   arg2 = (ScicosID)jarg2; 
1204   arg3 = jarg3 ? true : false; 
1205   result = (ScicosID)(arg1)->cloneObject(arg2,arg3);
1206   jresult = (jlong)result; 
1207   return jresult;
1208 }
1209
1210
1211 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getKind(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1212   jint jresult = 0 ;
1213   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1214   ScicosID arg2 ;
1215   kind_t result;
1216   
1217   (void)jenv;
1218   (void)jcls;
1219   (void)jarg1_;
1220   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1221   arg2 = (ScicosID)jarg2; 
1222   result = (kind_t)((org_scilab_modules_scicos::Controller const *)arg1)->getKind(arg2);
1223   jresult = (jint)result; 
1224   return jresult;
1225 }
1226
1227
1228 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getAll(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1229   jlong jresult = 0 ;
1230   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1231   kind_t arg2 ;
1232   std::vector< ScicosID > result;
1233   
1234   (void)jenv;
1235   (void)jcls;
1236   (void)jarg1_;
1237   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1238   arg2 = (kind_t)jarg2; 
1239   result = ((org_scilab_modules_scicos::Controller const *)arg1)->getAll(arg2);
1240   *(std::vector< ScicosID > **)&jresult = new std::vector< ScicosID >((const std::vector< ScicosID > &)result); 
1241   return jresult;
1242 }
1243
1244
1245 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) {
1246   jboolean jresult = 0 ;
1247   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1248   ScicosID arg2 ;
1249   kind_t arg3 ;
1250   object_properties_t arg4 ;
1251   int *arg5 = 0 ;
1252   int temp5 ;
1253   bool result;
1254   
1255   (void)jenv;
1256   (void)jcls;
1257   (void)jarg1_;
1258   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1259   arg2 = (ScicosID)jarg2; 
1260   arg3 = (kind_t)jarg3; 
1261   arg4 = (object_properties_t)jarg4; 
1262   {
1263     if (!jarg5) {
1264       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1265       return 0;
1266     }
1267     if (jenv->GetArrayLength(jarg5) == 0) {
1268       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1269       return 0;
1270     }
1271     temp5 = (int)0;
1272     arg5 = &temp5; 
1273   }
1274   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< int >(arg2,arg3,arg4,*arg5);
1275   jresult = (jboolean)result; 
1276   {
1277     jint jvalue = (jint)temp5;
1278     jenv->SetIntArrayRegion(jarg5, 0, 1, &jvalue);
1279   }
1280   
1281   return jresult;
1282 }
1283
1284
1285 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, jbooleanArray jarg5) {
1286   jboolean jresult = 0 ;
1287   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1288   ScicosID arg2 ;
1289   kind_t arg3 ;
1290   object_properties_t arg4 ;
1291   bool *arg5 = 0 ;
1292   bool temp5 ;
1293   bool result;
1294   
1295   (void)jenv;
1296   (void)jcls;
1297   (void)jarg1_;
1298   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1299   arg2 = (ScicosID)jarg2; 
1300   arg3 = (kind_t)jarg3; 
1301   arg4 = (object_properties_t)jarg4; 
1302   {
1303     if (!jarg5) {
1304       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1305       return 0;
1306     }
1307     if (jenv->GetArrayLength(jarg5) == 0) {
1308       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1309       return 0;
1310     }
1311     temp5 = false;
1312     arg5 = &temp5; 
1313   }
1314   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< bool >(arg2,arg3,arg4,*arg5);
1315   jresult = (jboolean)result; 
1316   {
1317     jboolean jvalue = (jboolean)temp5;
1318     jenv->SetBooleanArrayRegion(jarg5, 0, 1, &jvalue);
1319   }
1320   
1321   return jresult;
1322 }
1323
1324
1325 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, jdoubleArray jarg5) {
1326   jboolean jresult = 0 ;
1327   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1328   ScicosID arg2 ;
1329   kind_t arg3 ;
1330   object_properties_t arg4 ;
1331   double *arg5 = 0 ;
1332   double temp5 ;
1333   bool result;
1334   
1335   (void)jenv;
1336   (void)jcls;
1337   (void)jarg1_;
1338   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1339   arg2 = (ScicosID)jarg2; 
1340   arg3 = (kind_t)jarg3; 
1341   arg4 = (object_properties_t)jarg4; 
1342   {
1343     if (!jarg5) {
1344       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1345       return 0;
1346     }
1347     if (jenv->GetArrayLength(jarg5) == 0) {
1348       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1349       return 0;
1350     }
1351     temp5 = (double)0;
1352     arg5 = &temp5; 
1353   }
1354   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< double >(arg2,arg3,arg4,*arg5);
1355   jresult = (jboolean)result; 
1356   {
1357     jdouble jvalue = (jdouble)temp5;
1358     jenv->SetDoubleArrayRegion(jarg5, 0, 1, &jvalue);
1359   }
1360   
1361   return jresult;
1362 }
1363
1364
1365 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, jobjectArray jarg5) {
1366   jboolean jresult = 0 ;
1367   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1368   ScicosID arg2 ;
1369   kind_t arg3 ;
1370   object_properties_t arg4 ;
1371   std::string *arg5 = 0 ;
1372   std::string temp5 ;
1373   bool result;
1374   
1375   (void)jenv;
1376   (void)jcls;
1377   (void)jarg1_;
1378   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1379   arg2 = (ScicosID)jarg2; 
1380   arg3 = (kind_t)jarg3; 
1381   arg4 = (object_properties_t)jarg4; 
1382   {
1383     if (!jarg5) {
1384       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1385       return 0;
1386     }
1387     if (jenv->GetArrayLength(jarg5) == 0) {
1388       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1389       return 0;
1390     }
1391     arg5 = &temp5; 
1392     *arg5 = "";
1393   }
1394   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::string >(arg2,arg3,arg4,*arg5);
1395   jresult = (jboolean)result; 
1396   {
1397     jstring jnewstring = NULL;
1398     if (arg5) {
1399       jnewstring = jenv->NewStringUTF(arg5->c_str());
1400     }
1401     jenv->SetObjectArrayElement(jarg5, 0, jnewstring); 
1402   }
1403   return jresult;
1404 }
1405
1406
1407 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, jlongArray jarg5) {
1408   jboolean jresult = 0 ;
1409   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1410   ScicosID arg2 ;
1411   kind_t arg3 ;
1412   object_properties_t arg4 ;
1413   long long *arg5 = 0 ;
1414   long long temp5 ;
1415   bool result;
1416   
1417   (void)jenv;
1418   (void)jcls;
1419   (void)jarg1_;
1420   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1421   arg2 = (ScicosID)jarg2; 
1422   arg3 = (kind_t)jarg3; 
1423   arg4 = (object_properties_t)jarg4; 
1424   {
1425     if (!jarg5) {
1426       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1427       return 0;
1428     }
1429     if (jenv->GetArrayLength(jarg5) == 0) {
1430       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1431       return 0;
1432     }
1433     temp5 = (long long)0;
1434     arg5 = &temp5; 
1435   }
1436   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< ScicosID >(arg2,arg3,arg4,*arg5);
1437   jresult = (jboolean)result; 
1438   {
1439     jlong jvalue = (jlong)temp5;
1440     jenv->SetLongArrayRegion(jarg5, 0, 1, &jvalue);
1441   }
1442   
1443   return jresult;
1444 }
1445
1446
1447 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_) {
1448   jboolean 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   std::vector< int > *arg5 = 0 ;
1454   bool result;
1455   
1456   (void)jenv;
1457   (void)jcls;
1458   (void)jarg1_;
1459   (void)jarg5_;
1460   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1461   arg2 = (ScicosID)jarg2; 
1462   arg3 = (kind_t)jarg3; 
1463   arg4 = (object_properties_t)jarg4; 
1464   arg5 = *(std::vector< int > **)&jarg5;
1465   if (!arg5) {
1466     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > & reference is null");
1467     return 0;
1468   } 
1469   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< int > >(arg2,arg3,arg4,*arg5);
1470   jresult = (jboolean)result; 
1471   return jresult;
1472 }
1473
1474
1475 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_) {
1476   jboolean jresult = 0 ;
1477   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1478   ScicosID arg2 ;
1479   kind_t arg3 ;
1480   object_properties_t arg4 ;
1481   std::vector< bool > *arg5 = 0 ;
1482   bool result;
1483   
1484   (void)jenv;
1485   (void)jcls;
1486   (void)jarg1_;
1487   (void)jarg5_;
1488   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1489   arg2 = (ScicosID)jarg2; 
1490   arg3 = (kind_t)jarg3; 
1491   arg4 = (object_properties_t)jarg4; 
1492   arg5 = *(std::vector< bool > **)&jarg5;
1493   if (!arg5) {
1494     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< bool > & reference is null");
1495     return 0;
1496   } 
1497   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< bool > >(arg2,arg3,arg4,*arg5);
1498   jresult = (jboolean)result; 
1499   return jresult;
1500 }
1501
1502
1503 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_) {
1504   jboolean jresult = 0 ;
1505   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1506   ScicosID arg2 ;
1507   kind_t arg3 ;
1508   object_properties_t arg4 ;
1509   std::vector< double > *arg5 = 0 ;
1510   bool result;
1511   
1512   (void)jenv;
1513   (void)jcls;
1514   (void)jarg1_;
1515   (void)jarg5_;
1516   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1517   arg2 = (ScicosID)jarg2; 
1518   arg3 = (kind_t)jarg3; 
1519   arg4 = (object_properties_t)jarg4; 
1520   arg5 = *(std::vector< double > **)&jarg5;
1521   if (!arg5) {
1522     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< double > & reference is null");
1523     return 0;
1524   } 
1525   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< double > >(arg2,arg3,arg4,*arg5);
1526   jresult = (jboolean)result; 
1527   return jresult;
1528 }
1529
1530
1531 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_19(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1532   jboolean jresult = 0 ;
1533   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1534   ScicosID arg2 ;
1535   kind_t arg3 ;
1536   object_properties_t arg4 ;
1537   std::vector< std::string > *arg5 = 0 ;
1538   bool result;
1539   
1540   (void)jenv;
1541   (void)jcls;
1542   (void)jarg1_;
1543   (void)jarg5_;
1544   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1545   arg2 = (ScicosID)jarg2; 
1546   arg3 = (kind_t)jarg3; 
1547   arg4 = (object_properties_t)jarg4; 
1548   arg5 = *(std::vector< std::string > **)&jarg5;
1549   if (!arg5) {
1550     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > & reference is null");
1551     return 0;
1552   } 
1553   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< std::string > >(arg2,arg3,arg4,*arg5);
1554   jresult = (jboolean)result; 
1555   return jresult;
1556 }
1557
1558
1559 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_110(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1560   jboolean jresult = 0 ;
1561   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1562   ScicosID arg2 ;
1563   kind_t arg3 ;
1564   object_properties_t arg4 ;
1565   std::vector< long long > *arg5 = 0 ;
1566   bool result;
1567   
1568   (void)jenv;
1569   (void)jcls;
1570   (void)jarg1_;
1571   (void)jarg5_;
1572   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1573   arg2 = (ScicosID)jarg2; 
1574   arg3 = (kind_t)jarg3; 
1575   arg4 = (object_properties_t)jarg4; 
1576   arg5 = *(std::vector< long long > **)&jarg5;
1577   if (!arg5) {
1578     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< long long > & reference is null");
1579     return 0;
1580   } 
1581   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< ScicosID > >(arg2,arg3,arg4,*arg5);
1582   jresult = (jboolean)result; 
1583   return jresult;
1584 }
1585
1586
1587 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) {
1588   jint jresult = 0 ;
1589   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1590   ScicosID *arg2 = 0 ;
1591   kind_t arg3 ;
1592   object_properties_t arg4 ;
1593   int arg5 ;
1594   ScicosID temp2 ;
1595   update_status_t result;
1596   
1597   (void)jenv;
1598   (void)jcls;
1599   (void)jarg1_;
1600   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1601   temp2 = (ScicosID)jarg2; 
1602   arg2 = &temp2; 
1603   arg3 = (kind_t)jarg3; 
1604   arg4 = (object_properties_t)jarg4; 
1605   arg5 = (int)jarg5; 
1606   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< int >((ScicosID const &)*arg2,arg3,arg4,arg5);
1607   jresult = (jint)result; 
1608   return jresult;
1609 }
1610
1611
1612 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, jboolean jarg5) {
1613   jint jresult = 0 ;
1614   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1615   ScicosID *arg2 = 0 ;
1616   kind_t arg3 ;
1617   object_properties_t arg4 ;
1618   bool arg5 ;
1619   ScicosID temp2 ;
1620   update_status_t result;
1621   
1622   (void)jenv;
1623   (void)jcls;
1624   (void)jarg1_;
1625   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1626   temp2 = (ScicosID)jarg2; 
1627   arg2 = &temp2; 
1628   arg3 = (kind_t)jarg3; 
1629   arg4 = (object_properties_t)jarg4; 
1630   arg5 = jarg5 ? true : false; 
1631   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< bool >((ScicosID const &)*arg2,arg3,arg4,arg5);
1632   jresult = (jint)result; 
1633   return jresult;
1634 }
1635
1636
1637 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, jdouble jarg5) {
1638   jint jresult = 0 ;
1639   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1640   ScicosID *arg2 = 0 ;
1641   kind_t arg3 ;
1642   object_properties_t arg4 ;
1643   double arg5 ;
1644   ScicosID temp2 ;
1645   update_status_t result;
1646   
1647   (void)jenv;
1648   (void)jcls;
1649   (void)jarg1_;
1650   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1651   temp2 = (ScicosID)jarg2; 
1652   arg2 = &temp2; 
1653   arg3 = (kind_t)jarg3; 
1654   arg4 = (object_properties_t)jarg4; 
1655   arg5 = (double)jarg5; 
1656   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< double >((ScicosID const &)*arg2,arg3,arg4,arg5);
1657   jresult = (jint)result; 
1658   return jresult;
1659 }
1660
1661
1662 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, jstring jarg5) {
1663   jint jresult = 0 ;
1664   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1665   ScicosID *arg2 = 0 ;
1666   kind_t arg3 ;
1667   object_properties_t arg4 ;
1668   std::string arg5 ;
1669   ScicosID temp2 ;
1670   update_status_t result;
1671   
1672   (void)jenv;
1673   (void)jcls;
1674   (void)jarg1_;
1675   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1676   temp2 = (ScicosID)jarg2; 
1677   arg2 = &temp2; 
1678   arg3 = (kind_t)jarg3; 
1679   arg4 = (object_properties_t)jarg4; 
1680   if(!jarg5) {
1681     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
1682     return 0;
1683   } 
1684   const char *arg5_pstr = (const char *)jenv->GetStringUTFChars(jarg5, 0); 
1685   if (!arg5_pstr) return 0;
1686   (&arg5)->assign(arg5_pstr);
1687   jenv->ReleaseStringUTFChars(jarg5, arg5_pstr); 
1688   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::string >((ScicosID const &)*arg2,arg3,arg4,arg5);
1689   jresult = (jint)result; 
1690   return jresult;
1691 }
1692
1693
1694 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) {
1695   jint jresult = 0 ;
1696   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1697   ScicosID *arg2 = 0 ;
1698   kind_t arg3 ;
1699   object_properties_t arg4 ;
1700   long long arg5 ;
1701   ScicosID temp2 ;
1702   update_status_t result;
1703   
1704   (void)jenv;
1705   (void)jcls;
1706   (void)jarg1_;
1707   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1708   temp2 = (ScicosID)jarg2; 
1709   arg2 = &temp2; 
1710   arg3 = (kind_t)jarg3; 
1711   arg4 = (object_properties_t)jarg4; 
1712   arg5 = (long long)jarg5; 
1713   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< ScicosID >((ScicosID const &)*arg2,arg3,arg4,arg5);
1714   jresult = (jint)result; 
1715   return jresult;
1716 }
1717
1718
1719 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_) {
1720   jint jresult = 0 ;
1721   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1722   ScicosID *arg2 = 0 ;
1723   kind_t arg3 ;
1724   object_properties_t arg4 ;
1725   std::vector< int > arg5 ;
1726   ScicosID temp2 ;
1727   std::vector< int > *argp5 ;
1728   update_status_t result;
1729   
1730   (void)jenv;
1731   (void)jcls;
1732   (void)jarg1_;
1733   (void)jarg5_;
1734   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1735   temp2 = (ScicosID)jarg2; 
1736   arg2 = &temp2; 
1737   arg3 = (kind_t)jarg3; 
1738   arg4 = (object_properties_t)jarg4; 
1739   argp5 = *(std::vector< int > **)&jarg5; 
1740   if (!argp5) {
1741     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< int >");
1742     return 0;
1743   }
1744   arg5 = *argp5; 
1745   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< int > >((ScicosID const &)*arg2,arg3,arg4,arg5);
1746   jresult = (jint)result; 
1747   return jresult;
1748 }
1749
1750
1751 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_) {
1752   jint jresult = 0 ;
1753   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1754   ScicosID *arg2 = 0 ;
1755   kind_t arg3 ;
1756   object_properties_t arg4 ;
1757   std::vector< bool > arg5 ;
1758   ScicosID temp2 ;
1759   std::vector< bool > *argp5 ;
1760   update_status_t result;
1761   
1762   (void)jenv;
1763   (void)jcls;
1764   (void)jarg1_;
1765   (void)jarg5_;
1766   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1767   temp2 = (ScicosID)jarg2; 
1768   arg2 = &temp2; 
1769   arg3 = (kind_t)jarg3; 
1770   arg4 = (object_properties_t)jarg4; 
1771   argp5 = *(std::vector< bool > **)&jarg5; 
1772   if (!argp5) {
1773     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< bool >");
1774     return 0;
1775   }
1776   arg5 = *argp5; 
1777   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< bool > >((ScicosID const &)*arg2,arg3,arg4,arg5);
1778   jresult = (jint)result; 
1779   return jresult;
1780 }
1781
1782
1783 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_) {
1784   jint jresult = 0 ;
1785   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1786   ScicosID *arg2 = 0 ;
1787   kind_t arg3 ;
1788   object_properties_t arg4 ;
1789   std::vector< double > arg5 ;
1790   ScicosID temp2 ;
1791   std::vector< double > *argp5 ;
1792   update_status_t result;
1793   
1794   (void)jenv;
1795   (void)jcls;
1796   (void)jarg1_;
1797   (void)jarg5_;
1798   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1799   temp2 = (ScicosID)jarg2; 
1800   arg2 = &temp2; 
1801   arg3 = (kind_t)jarg3; 
1802   arg4 = (object_properties_t)jarg4; 
1803   argp5 = *(std::vector< double > **)&jarg5; 
1804   if (!argp5) {
1805     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< double >");
1806     return 0;
1807   }
1808   arg5 = *argp5; 
1809   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< double > >((ScicosID const &)*arg2,arg3,arg4,arg5);
1810   jresult = (jint)result; 
1811   return jresult;
1812 }
1813
1814
1815 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_19(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1816   jint jresult = 0 ;
1817   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1818   ScicosID *arg2 = 0 ;
1819   kind_t arg3 ;
1820   object_properties_t arg4 ;
1821   std::vector< std::string > arg5 ;
1822   ScicosID temp2 ;
1823   std::vector< std::string > *argp5 ;
1824   update_status_t result;
1825   
1826   (void)jenv;
1827   (void)jcls;
1828   (void)jarg1_;
1829   (void)jarg5_;
1830   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1831   temp2 = (ScicosID)jarg2; 
1832   arg2 = &temp2; 
1833   arg3 = (kind_t)jarg3; 
1834   arg4 = (object_properties_t)jarg4; 
1835   argp5 = *(std::vector< std::string > **)&jarg5; 
1836   if (!argp5) {
1837     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::string >");
1838     return 0;
1839   }
1840   arg5 = *argp5; 
1841   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< std::string > >((ScicosID const &)*arg2,arg3,arg4,arg5);
1842   jresult = (jint)result; 
1843   return jresult;
1844 }
1845
1846
1847 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_110(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1848   jint jresult = 0 ;
1849   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1850   ScicosID *arg2 = 0 ;
1851   kind_t arg3 ;
1852   object_properties_t arg4 ;
1853   std::vector< long long > arg5 ;
1854   ScicosID temp2 ;
1855   std::vector< long long > *argp5 ;
1856   update_status_t result;
1857   
1858   (void)jenv;
1859   (void)jcls;
1860   (void)jarg1_;
1861   (void)jarg5_;
1862   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1863   temp2 = (ScicosID)jarg2; 
1864   arg2 = &temp2; 
1865   arg3 = (kind_t)jarg3; 
1866   arg4 = (object_properties_t)jarg4; 
1867   argp5 = *(std::vector< long long > **)&jarg5; 
1868   if (!argp5) {
1869     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< long long >");
1870     return 0;
1871   }
1872   arg5 = *argp5; 
1873   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< ScicosID > >((ScicosID const &)*arg2,arg3,arg4,arg5);
1874   jresult = (jint)result; 
1875   return jresult;
1876 }
1877
1878
1879 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
1880   jlong jresult = 0 ;
1881   std::vector< int > *result = 0 ;
1882   
1883   (void)jenv;
1884   (void)jcls;
1885   result = (std::vector< int > *)new std::vector< int >();
1886   *(std::vector< int > **)&jresult = result; 
1887   return jresult;
1888 }
1889
1890
1891 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1892   jlong jresult = 0 ;
1893   std::vector< int >::size_type arg1 ;
1894   std::vector< int > *result = 0 ;
1895   
1896   (void)jenv;
1897   (void)jcls;
1898   arg1 = (std::vector< int >::size_type)jarg1; 
1899   result = (std::vector< int > *)new std::vector< int >(arg1);
1900   *(std::vector< int > **)&jresult = result; 
1901   return jresult;
1902 }
1903
1904
1905 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1906   jlong jresult = 0 ;
1907   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1908   std::vector< int >::size_type result;
1909   
1910   (void)jenv;
1911   (void)jcls;
1912   (void)jarg1_;
1913   arg1 = *(std::vector< int > **)&jarg1; 
1914   result = ((std::vector< int > const *)arg1)->size();
1915   jresult = (jlong)result; 
1916   return jresult;
1917 }
1918
1919
1920 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1921   jlong jresult = 0 ;
1922   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1923   std::vector< int >::size_type result;
1924   
1925   (void)jenv;
1926   (void)jcls;
1927   (void)jarg1_;
1928   arg1 = *(std::vector< int > **)&jarg1; 
1929   result = ((std::vector< int > const *)arg1)->capacity();
1930   jresult = (jlong)result; 
1931   return jresult;
1932 }
1933
1934
1935 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1936   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1937   std::vector< int >::size_type arg2 ;
1938   
1939   (void)jenv;
1940   (void)jcls;
1941   (void)jarg1_;
1942   arg1 = *(std::vector< int > **)&jarg1; 
1943   arg2 = (std::vector< int >::size_type)jarg2; 
1944   (arg1)->reserve(arg2);
1945 }
1946
1947
1948 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1949   jboolean jresult = 0 ;
1950   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1951   bool result;
1952   
1953   (void)jenv;
1954   (void)jcls;
1955   (void)jarg1_;
1956   arg1 = *(std::vector< int > **)&jarg1; 
1957   result = (bool)((std::vector< int > const *)arg1)->empty();
1958   jresult = (jboolean)result; 
1959   return jresult;
1960 }
1961
1962
1963 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1964   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1965   
1966   (void)jenv;
1967   (void)jcls;
1968   (void)jarg1_;
1969   arg1 = *(std::vector< int > **)&jarg1; 
1970   (arg1)->clear();
1971 }
1972
1973
1974 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1975   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1976   std::vector< int >::value_type *arg2 = 0 ;
1977   std::vector< int >::value_type temp2 ;
1978   
1979   (void)jenv;
1980   (void)jcls;
1981   (void)jarg1_;
1982   arg1 = *(std::vector< int > **)&jarg1; 
1983   temp2 = (std::vector< int >::value_type)jarg2; 
1984   arg2 = &temp2; 
1985   (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
1986 }
1987
1988
1989 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1990   jint jresult = 0 ;
1991   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1992   int arg2 ;
1993   std::vector< int >::value_type *result = 0 ;
1994   
1995   (void)jenv;
1996   (void)jcls;
1997   (void)jarg1_;
1998   arg1 = *(std::vector< int > **)&jarg1; 
1999   arg2 = (int)jarg2; 
2000   try {
2001     result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__get(arg1,arg2);
2002   }
2003   catch(std::out_of_range &_e) {
2004     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2005     return 0;
2006   }
2007   
2008   jresult = (jint)*result; 
2009   return jresult;
2010 }
2011
2012
2013 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2014   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2015   int arg2 ;
2016   std::vector< int >::value_type *arg3 = 0 ;
2017   std::vector< int >::value_type temp3 ;
2018   
2019   (void)jenv;
2020   (void)jcls;
2021   (void)jarg1_;
2022   arg1 = *(std::vector< int > **)&jarg1; 
2023   arg2 = (int)jarg2; 
2024   temp3 = (std::vector< int >::value_type)jarg3; 
2025   arg3 = &temp3; 
2026   try {
2027     std_vector_Sl_int_Sg__set(arg1,arg2,(int const &)*arg3);
2028   }
2029   catch(std::out_of_range &_e) {
2030     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2031     return ;
2032   }
2033   
2034 }
2035
2036
2037 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfInt(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2038   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2039   
2040   (void)jenv;
2041   (void)jcls;
2042   arg1 = *(std::vector< int > **)&jarg1; 
2043   delete arg1;
2044 }
2045
2046
2047 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2048   jlong jresult = 0 ;
2049   std::vector< bool > *result = 0 ;
2050   
2051   (void)jenv;
2052   (void)jcls;
2053   result = (std::vector< bool > *)new std::vector< bool >();
2054   *(std::vector< bool > **)&jresult = result; 
2055   return jresult;
2056 }
2057
2058
2059 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2060   jlong jresult = 0 ;
2061   std::vector< bool >::size_type arg1 ;
2062   std::vector< bool > *result = 0 ;
2063   
2064   (void)jenv;
2065   (void)jcls;
2066   arg1 = (std::vector< bool >::size_type)jarg1; 
2067   result = (std::vector< bool > *)new std::vector< bool >(arg1);
2068   *(std::vector< bool > **)&jresult = result; 
2069   return jresult;
2070 }
2071
2072
2073 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2074   jlong jresult = 0 ;
2075   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2076   std::vector< bool >::size_type result;
2077   
2078   (void)jenv;
2079   (void)jcls;
2080   (void)jarg1_;
2081   arg1 = *(std::vector< bool > **)&jarg1; 
2082   result = ((std::vector< bool > const *)arg1)->size();
2083   jresult = (jlong)result; 
2084   return jresult;
2085 }
2086
2087
2088 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2089   jlong jresult = 0 ;
2090   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2091   std::vector< bool >::size_type result;
2092   
2093   (void)jenv;
2094   (void)jcls;
2095   (void)jarg1_;
2096   arg1 = *(std::vector< bool > **)&jarg1; 
2097   result = ((std::vector< bool > const *)arg1)->capacity();
2098   jresult = (jlong)result; 
2099   return jresult;
2100 }
2101
2102
2103 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2104   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2105   std::vector< bool >::size_type arg2 ;
2106   
2107   (void)jenv;
2108   (void)jcls;
2109   (void)jarg1_;
2110   arg1 = *(std::vector< bool > **)&jarg1; 
2111   arg2 = (std::vector< bool >::size_type)jarg2; 
2112   (arg1)->reserve(arg2);
2113 }
2114
2115
2116 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2117   jboolean jresult = 0 ;
2118   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2119   bool result;
2120   
2121   (void)jenv;
2122   (void)jcls;
2123   (void)jarg1_;
2124   arg1 = *(std::vector< bool > **)&jarg1; 
2125   result = (bool)((std::vector< bool > const *)arg1)->empty();
2126   jresult = (jboolean)result; 
2127   return jresult;
2128 }
2129
2130
2131 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2132   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2133   
2134   (void)jenv;
2135   (void)jcls;
2136   (void)jarg1_;
2137   arg1 = *(std::vector< bool > **)&jarg1; 
2138   (arg1)->clear();
2139 }
2140
2141
2142 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
2143   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2144   std::vector< bool >::value_type *arg2 = 0 ;
2145   std::vector< bool >::value_type temp2 ;
2146   
2147   (void)jenv;
2148   (void)jcls;
2149   (void)jarg1_;
2150   arg1 = *(std::vector< bool > **)&jarg1; 
2151   temp2 = jarg2 ? true : false; 
2152   arg2 = &temp2; 
2153   (arg1)->push_back((std::vector< bool >::value_type const &)*arg2);
2154 }
2155
2156
2157 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2158   jboolean jresult = 0 ;
2159   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2160   int arg2 ;
2161   bool result;
2162   
2163   (void)jenv;
2164   (void)jcls;
2165   (void)jarg1_;
2166   arg1 = *(std::vector< bool > **)&jarg1; 
2167   arg2 = (int)jarg2; 
2168   try {
2169     result = (bool)std_vector_Sl_bool_Sg__get(arg1,arg2);
2170   }
2171   catch(std::out_of_range &_e) {
2172     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2173     return 0;
2174   }
2175   
2176   jresult = (jboolean)result; 
2177   return jresult;
2178 }
2179
2180
2181 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
2182   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2183   int arg2 ;
2184   std::vector< bool >::value_type *arg3 = 0 ;
2185   std::vector< bool >::value_type temp3 ;
2186   
2187   (void)jenv;
2188   (void)jcls;
2189   (void)jarg1_;
2190   arg1 = *(std::vector< bool > **)&jarg1; 
2191   arg2 = (int)jarg2; 
2192   temp3 = jarg3 ? true : false; 
2193   arg3 = &temp3; 
2194   try {
2195     std_vector_Sl_bool_Sg__set(arg1,arg2,(bool const &)*arg3);
2196   }
2197   catch(std::out_of_range &_e) {
2198     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2199     return ;
2200   }
2201   
2202 }
2203
2204
2205 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfBool(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2206   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2207   
2208   (void)jenv;
2209   (void)jcls;
2210   arg1 = *(std::vector< bool > **)&jarg1; 
2211   delete arg1;
2212 }
2213
2214
2215 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2216   jlong jresult = 0 ;
2217   std::vector< double > *result = 0 ;
2218   
2219   (void)jenv;
2220   (void)jcls;
2221   result = (std::vector< double > *)new std::vector< double >();
2222   *(std::vector< double > **)&jresult = result; 
2223   return jresult;
2224 }
2225
2226
2227 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2228   jlong jresult = 0 ;
2229   std::vector< double >::size_type arg1 ;
2230   std::vector< double > *result = 0 ;
2231   
2232   (void)jenv;
2233   (void)jcls;
2234   arg1 = (std::vector< double >::size_type)jarg1; 
2235   result = (std::vector< double > *)new std::vector< double >(arg1);
2236   *(std::vector< double > **)&jresult = result; 
2237   return jresult;
2238 }
2239
2240
2241 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2242   jlong jresult = 0 ;
2243   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2244   std::vector< double >::size_type result;
2245   
2246   (void)jenv;
2247   (void)jcls;
2248   (void)jarg1_;
2249   arg1 = *(std::vector< double > **)&jarg1; 
2250   result = ((std::vector< double > const *)arg1)->size();
2251   jresult = (jlong)result; 
2252   return jresult;
2253 }
2254
2255
2256 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2257   jlong jresult = 0 ;
2258   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2259   std::vector< double >::size_type result;
2260   
2261   (void)jenv;
2262   (void)jcls;
2263   (void)jarg1_;
2264   arg1 = *(std::vector< double > **)&jarg1; 
2265   result = ((std::vector< double > const *)arg1)->capacity();
2266   jresult = (jlong)result; 
2267   return jresult;
2268 }
2269
2270
2271 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2272   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2273   std::vector< double >::size_type arg2 ;
2274   
2275   (void)jenv;
2276   (void)jcls;
2277   (void)jarg1_;
2278   arg1 = *(std::vector< double > **)&jarg1; 
2279   arg2 = (std::vector< double >::size_type)jarg2; 
2280   (arg1)->reserve(arg2);
2281 }
2282
2283
2284 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2285   jboolean jresult = 0 ;
2286   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2287   bool result;
2288   
2289   (void)jenv;
2290   (void)jcls;
2291   (void)jarg1_;
2292   arg1 = *(std::vector< double > **)&jarg1; 
2293   result = (bool)((std::vector< double > const *)arg1)->empty();
2294   jresult = (jboolean)result; 
2295   return jresult;
2296 }
2297
2298
2299 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2300   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2301   
2302   (void)jenv;
2303   (void)jcls;
2304   (void)jarg1_;
2305   arg1 = *(std::vector< double > **)&jarg1; 
2306   (arg1)->clear();
2307 }
2308
2309
2310 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2311   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2312   std::vector< double >::value_type *arg2 = 0 ;
2313   std::vector< double >::value_type temp2 ;
2314   
2315   (void)jenv;
2316   (void)jcls;
2317   (void)jarg1_;
2318   arg1 = *(std::vector< double > **)&jarg1; 
2319   temp2 = (std::vector< double >::value_type)jarg2; 
2320   arg2 = &temp2; 
2321   (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
2322 }
2323
2324
2325 SWIGEXPORT jdouble JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2326   jdouble jresult = 0 ;
2327   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2328   int arg2 ;
2329   std::vector< double >::value_type *result = 0 ;
2330   
2331   (void)jenv;
2332   (void)jcls;
2333   (void)jarg1_;
2334   arg1 = *(std::vector< double > **)&jarg1; 
2335   arg2 = (int)jarg2; 
2336   try {
2337     result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__get(arg1,arg2);
2338   }
2339   catch(std::out_of_range &_e) {
2340     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2341     return 0;
2342   }
2343   
2344   jresult = (jdouble)*result; 
2345   return jresult;
2346 }
2347
2348
2349 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) {
2350   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2351   int arg2 ;
2352   std::vector< double >::value_type *arg3 = 0 ;
2353   std::vector< double >::value_type temp3 ;
2354   
2355   (void)jenv;
2356   (void)jcls;
2357   (void)jarg1_;
2358   arg1 = *(std::vector< double > **)&jarg1; 
2359   arg2 = (int)jarg2; 
2360   temp3 = (std::vector< double >::value_type)jarg3; 
2361   arg3 = &temp3; 
2362   try {
2363     std_vector_Sl_double_Sg__set(arg1,arg2,(double const &)*arg3);
2364   }
2365   catch(std::out_of_range &_e) {
2366     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2367     return ;
2368   }
2369   
2370 }
2371
2372
2373 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfDouble(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2374   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2375   
2376   (void)jenv;
2377   (void)jcls;
2378   arg1 = *(std::vector< double > **)&jarg1; 
2379   delete arg1;
2380 }
2381
2382
2383 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2384   jlong jresult = 0 ;
2385   std::vector< std::string > *result = 0 ;
2386   
2387   (void)jenv;
2388   (void)jcls;
2389   result = (std::vector< std::string > *)new std::vector< std::string >();
2390   *(std::vector< std::string > **)&jresult = result; 
2391   return jresult;
2392 }
2393
2394
2395 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2396   jlong jresult = 0 ;
2397   std::vector< std::string >::size_type arg1 ;
2398   std::vector< std::string > *result = 0 ;
2399   
2400   (void)jenv;
2401   (void)jcls;
2402   arg1 = (std::vector< std::string >::size_type)jarg1; 
2403   result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
2404   *(std::vector< std::string > **)&jresult = result; 
2405   return jresult;
2406 }
2407
2408
2409 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2410   jlong jresult = 0 ;
2411   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2412   std::vector< std::string >::size_type result;
2413   
2414   (void)jenv;
2415   (void)jcls;
2416   (void)jarg1_;
2417   arg1 = *(std::vector< std::string > **)&jarg1; 
2418   result = ((std::vector< std::string > const *)arg1)->size();
2419   jresult = (jlong)result; 
2420   return jresult;
2421 }
2422
2423
2424 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2425   jlong jresult = 0 ;
2426   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2427   std::vector< std::string >::size_type result;
2428   
2429   (void)jenv;
2430   (void)jcls;
2431   (void)jarg1_;
2432   arg1 = *(std::vector< std::string > **)&jarg1; 
2433   result = ((std::vector< std::string > const *)arg1)->capacity();
2434   jresult = (jlong)result; 
2435   return jresult;
2436 }
2437
2438
2439 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2440   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2441   std::vector< std::string >::size_type arg2 ;
2442   
2443   (void)jenv;
2444   (void)jcls;
2445   (void)jarg1_;
2446   arg1 = *(std::vector< std::string > **)&jarg1; 
2447   arg2 = (std::vector< std::string >::size_type)jarg2; 
2448   (arg1)->reserve(arg2);
2449 }
2450
2451
2452 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2453   jboolean jresult = 0 ;
2454   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2455   bool result;
2456   
2457   (void)jenv;
2458   (void)jcls;
2459   (void)jarg1_;
2460   arg1 = *(std::vector< std::string > **)&jarg1; 
2461   result = (bool)((std::vector< std::string > const *)arg1)->empty();
2462   jresult = (jboolean)result; 
2463   return jresult;
2464 }
2465
2466
2467 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2468   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2469   
2470   (void)jenv;
2471   (void)jcls;
2472   (void)jarg1_;
2473   arg1 = *(std::vector< std::string > **)&jarg1; 
2474   (arg1)->clear();
2475 }
2476
2477
2478 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2479   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2480   std::vector< std::string >::value_type *arg2 = 0 ;
2481   
2482   (void)jenv;
2483   (void)jcls;
2484   (void)jarg1_;
2485   arg1 = *(std::vector< std::string > **)&jarg1; 
2486   if(!jarg2) {
2487     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2488     return ;
2489   }
2490   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2491   if (!arg2_pstr) return ;
2492   std::vector< std::string >::value_type arg2_str(arg2_pstr);
2493   arg2 = &arg2_str;
2494   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2495   (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
2496 }
2497
2498
2499 SWIGEXPORT jstring JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2500   jstring jresult = 0 ;
2501   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2502   int arg2 ;
2503   std::vector< std::string >::value_type *result = 0 ;
2504   
2505   (void)jenv;
2506   (void)jcls;
2507   (void)jarg1_;
2508   arg1 = *(std::vector< std::string > **)&jarg1; 
2509   arg2 = (int)jarg2; 
2510   try {
2511     result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__get(arg1,arg2);
2512   }
2513   catch(std::out_of_range &_e) {
2514     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2515     return 0;
2516   }
2517   
2518   jresult = jenv->NewStringUTF(result->c_str()); 
2519   return jresult;
2520 }
2521
2522
2523 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
2524   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2525   int arg2 ;
2526   std::vector< std::string >::value_type *arg3 = 0 ;
2527   
2528   (void)jenv;
2529   (void)jcls;
2530   (void)jarg1_;
2531   arg1 = *(std::vector< std::string > **)&jarg1; 
2532   arg2 = (int)jarg2; 
2533   if(!jarg3) {
2534     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2535     return ;
2536   }
2537   const char *arg3_pstr = (const char *)jenv->GetStringUTFChars(jarg3, 0); 
2538   if (!arg3_pstr) return ;
2539   std::vector< std::string >::value_type arg3_str(arg3_pstr);
2540   arg3 = &arg3_str;
2541   jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
2542   try {
2543     std_vector_Sl_std_string_Sg__set(arg1,arg2,(std::string const &)*arg3);
2544   }
2545   catch(std::out_of_range &_e) {
2546     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2547     return ;
2548   }
2549   
2550 }
2551
2552
2553 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfString(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2554   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2555   
2556   (void)jenv;
2557   (void)jcls;
2558   arg1 = *(std::vector< std::string > **)&jarg1; 
2559   delete arg1;
2560 }
2561
2562
2563 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2564   jlong jresult = 0 ;
2565   std::vector< ScicosID > *result = 0 ;
2566   
2567   (void)jenv;
2568   (void)jcls;
2569   result = (std::vector< ScicosID > *)new std::vector< ScicosID >();
2570   *(std::vector< ScicosID > **)&jresult = result; 
2571   return jresult;
2572 }
2573
2574
2575 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2576   jlong jresult = 0 ;
2577   std::vector< long long >::size_type arg1 ;
2578   std::vector< ScicosID > *result = 0 ;
2579   
2580   (void)jenv;
2581   (void)jcls;
2582   arg1 = (std::vector< long long >::size_type)jarg1; 
2583   result = (std::vector< ScicosID > *)new std::vector< ScicosID >(arg1);
2584   *(std::vector< ScicosID > **)&jresult = result; 
2585   return jresult;
2586 }
2587
2588
2589 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2590   jlong jresult = 0 ;
2591   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2592   std::vector< long long >::size_type result;
2593   
2594   (void)jenv;
2595   (void)jcls;
2596   (void)jarg1_;
2597   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2598   result = ((std::vector< ScicosID > const *)arg1)->size();
2599   jresult = (jlong)result; 
2600   return jresult;
2601 }
2602
2603
2604 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2605   jlong jresult = 0 ;
2606   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2607   std::vector< long long >::size_type result;
2608   
2609   (void)jenv;
2610   (void)jcls;
2611   (void)jarg1_;
2612   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2613   result = ((std::vector< ScicosID > const *)arg1)->capacity();
2614   jresult = (jlong)result; 
2615   return jresult;
2616 }
2617
2618
2619 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2620   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2621   std::vector< long long >::size_type arg2 ;
2622   
2623   (void)jenv;
2624   (void)jcls;
2625   (void)jarg1_;
2626   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2627   arg2 = (std::vector< long long >::size_type)jarg2; 
2628   (arg1)->reserve(arg2);
2629 }
2630
2631
2632 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2633   jboolean jresult = 0 ;
2634   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2635   bool result;
2636   
2637   (void)jenv;
2638   (void)jcls;
2639   (void)jarg1_;
2640   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2641   result = (bool)((std::vector< ScicosID > const *)arg1)->empty();
2642   jresult = (jboolean)result; 
2643   return jresult;
2644 }
2645
2646
2647 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2648   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2649   
2650   (void)jenv;
2651   (void)jcls;
2652   (void)jarg1_;
2653   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2654   (arg1)->clear();
2655 }
2656
2657
2658 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2659   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2660   std::vector< long long >::value_type *arg2 = 0 ;
2661   std::vector< long long >::value_type temp2 ;
2662   
2663   (void)jenv;
2664   (void)jcls;
2665   (void)jarg1_;
2666   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2667   temp2 = (std::vector< long long >::value_type)jarg2; 
2668   arg2 = &temp2; 
2669   (arg1)->push_back((std::vector< long long >::value_type const &)*arg2);
2670 }
2671
2672
2673 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2674   jlong jresult = 0 ;
2675   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2676   int arg2 ;
2677   std::vector< long long >::value_type *result = 0 ;
2678   
2679   (void)jenv;
2680   (void)jcls;
2681   (void)jarg1_;
2682   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2683   arg2 = (int)jarg2; 
2684   try {
2685     result = (std::vector< long long >::value_type *) &std_vector_Sl_ScicosID_Sg__get(arg1,arg2);
2686   }
2687   catch(std::out_of_range &_e) {
2688     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2689     return 0;
2690   }
2691   
2692   jresult = (jlong)*result; 
2693   return jresult;
2694 }
2695
2696
2697 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
2698   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2699   int arg2 ;
2700   std::vector< long long >::value_type *arg3 = 0 ;
2701   std::vector< long long >::value_type temp3 ;
2702   
2703   (void)jenv;
2704   (void)jcls;
2705   (void)jarg1_;
2706   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2707   arg2 = (int)jarg2; 
2708   temp3 = (std::vector< long long >::value_type)jarg3; 
2709   arg3 = &temp3; 
2710   try {
2711     std_vector_Sl_ScicosID_Sg__set(arg1,arg2,(long long const &)*arg3);
2712   }
2713   catch(std::out_of_range &_e) {
2714     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2715     return ;
2716   }
2717   
2718 }
2719
2720
2721 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfScicosID(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2722   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2723   
2724   (void)jenv;
2725   (void)jcls;
2726   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2727   delete arg1;
2728 }
2729
2730
2731 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_register_1view(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
2732   std::string *arg1 = 0 ;
2733   org_scilab_modules_scicos::View *arg2 = (org_scilab_modules_scicos::View *) 0 ;
2734   
2735   (void)jenv;
2736   (void)jcls;
2737   (void)jarg2_;
2738   if(!jarg1) {
2739     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2740     return ;
2741   }
2742   const char *arg1_pstr = (const char *)jenv->GetStringUTFChars(jarg1, 0); 
2743   if (!arg1_pstr) return ;
2744   std::string arg1_str(arg1_pstr);
2745   arg1 = &arg1_str;
2746   jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
2747   arg2 = *(org_scilab_modules_scicos::View **)&jarg2; 
2748   register_view((std::string const &)*arg1,arg2);
2749 }
2750
2751
2752 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_unregister_1view(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2753   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
2754   
2755   (void)jenv;
2756   (void)jcls;
2757   (void)jarg1_;
2758   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
2759   unregister_view(arg1);
2760 }
2761
2762
2763 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) {
2764   int i;
2765   
2766   static struct {
2767     const char *method;
2768     const char *signature;
2769   } methods[5] = {
2770     {
2771       "SwigDirector_View_objectCreated", "(Lorg/scilab/modules/xcos/View;JI)V" 
2772     },
2773     {
2774       "SwigDirector_View_objectReferenced", "(Lorg/scilab/modules/xcos/View;JI)V" 
2775     },
2776     {
2777       "SwigDirector_View_objectUnreferenced", "(Lorg/scilab/modules/xcos/View;JI)V" 
2778     },
2779     {
2780       "SwigDirector_View_objectDeleted", "(Lorg/scilab/modules/xcos/View;JI)V" 
2781     },
2782     {
2783       "SwigDirector_View_propertyUpdated", "(Lorg/scilab/modules/xcos/View;JIII)V" 
2784     }
2785   };
2786   Swig::jclass_JavaControllerJNI = (jclass) jenv->NewGlobalRef(jcls);
2787   if (!Swig::jclass_JavaControllerJNI) return;
2788   for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {
2789     Swig::director_method_ids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);
2790     if (!Swig::director_method_ids[i]) return;
2791   }
2792 }
2793
2794
2795 #ifdef __cplusplus
2796 }
2797 #endif
2798