Xcos: fix the build after a00f9a31
[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 <iterator>
663 #include <algorithm>
664 #include <vector>
665 #include <string>
666
667 #include "utilities.hxx"
668 #include "View.hxx"
669 #include "Controller.hxx"
670
671
672 #include <stdexcept>
673
674
675 #include <string>
676
677 SWIGINTERN bool std_vector_Sl_int_Sg__contains(std::vector< int > *self,int const &o){
678                return std::find(self->begin(), self->end(), o) != self->end();
679             }
680 SWIGINTERN int std_vector_Sl_int_Sg__indexOf(std::vector< int > *self,int const &o){
681                auto it = std::find(self->begin(), self->end(), o);
682                if (it != self->end())
683                    return std::distance(self->begin(), it);
684                else
685                    return -1;
686             }
687 SWIGINTERN std::vector< int >::const_reference std_vector_Sl_int_Sg__get(std::vector< int > *self,int i){
688                 int size = int(self->size());
689                 if (i>=0 && i<size)
690                     return (*self)[i];
691                 else
692                     throw std::out_of_range("vector index out of range");
693             }
694 SWIGINTERN void std_vector_Sl_int_Sg__set(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
695                 int size = int(self->size());
696                 if (i>=0 && i<size)
697                     (*self)[i] = val;
698                 else
699                     throw std::out_of_range("vector index out of range");
700             }
701 SWIGINTERN void std_vector_Sl_int_Sg__add__SWIG_1(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
702                 int size = int(self->size());
703                 if (i>=0 && i<=size)
704                     self->insert(self->begin() + i, val);
705                 else
706                     throw std::out_of_range("vector index out of range");
707             }
708 SWIGINTERN bool std_vector_Sl_int_Sg__remove(std::vector< int > *self,std::vector< int >::value_type const &val){
709                 auto it = std::find(self->begin(), self->end(), val);
710                 if (it == self->end())
711                     return false;
712                 else
713                     self->erase(it);
714                 return true;
715             }
716 SWIGINTERN void *std_vector_Sl_int_Sg__asByteBuffer(std::vector< int > *self,int i,int capacity){
717                 (void) capacity;
718                 void* buffer = nullptr;
719                 int size = int(self->size()) ;
720                 if (i>=0 && i<size) {
721                     buffer = self->data() + i;
722                 } else if (i==0 && size == 0) {
723                     buffer = self->data();
724                 } else {
725                     throw std::out_of_range("vector index out of range");
726                 }
727                 return buffer;
728             }
729 SWIGINTERN bool std_vector_Sl_bool_Sg__get(std::vector< bool > *self,int i){
730                 int size = int(self->size());
731                 if (i>=0 && i<size)
732                     return (*self)[i];
733                 else
734                     throw std::out_of_range("vector index out of range");
735             }
736 SWIGINTERN void std_vector_Sl_bool_Sg__set(std::vector< bool > *self,int i,std::vector< bool >::value_type const &val){
737                 int size = int(self->size());
738                 if (i>=0 && i<size)
739                     (*self)[i] = val;
740                 else
741                     throw std::out_of_range("vector index out of range");
742             }
743 SWIGINTERN void std_vector_Sl_bool_Sg__add__SWIG_1(std::vector< bool > *self,int i,std::vector< bool >::value_type const &val){
744                 int size = int(self->size());
745                 if (i>=0 && i<=size)
746                     self->insert(self->begin() + i, val);
747                 else
748                     throw std::out_of_range("vector index out of range");
749             }
750 SWIGINTERN bool std_vector_Sl_bool_Sg__remove(std::vector< bool > *self,std::vector< bool >::value_type const &val){
751                 auto it = std::find(self->begin(), self->end(), val);
752                 if (it == self->end())
753                     return false;
754                 else
755                     self->erase(it);
756                 return true;
757             }
758 SWIGINTERN bool std_vector_Sl_double_Sg__contains(std::vector< double > *self,double const &o){
759                return std::find(self->begin(), self->end(), o) != self->end();
760             }
761 SWIGINTERN int std_vector_Sl_double_Sg__indexOf(std::vector< double > *self,double const &o){
762                auto it = std::find(self->begin(), self->end(), o);
763                if (it != self->end())
764                    return std::distance(self->begin(), it);
765                else
766                    return -1;
767             }
768 SWIGINTERN std::vector< double >::const_reference std_vector_Sl_double_Sg__get(std::vector< double > *self,int i){
769                 int size = int(self->size());
770                 if (i>=0 && i<size)
771                     return (*self)[i];
772                 else
773                     throw std::out_of_range("vector index out of range");
774             }
775 SWIGINTERN void std_vector_Sl_double_Sg__set(std::vector< double > *self,int i,std::vector< double >::value_type const &val){
776                 int size = int(self->size());
777                 if (i>=0 && i<size)
778                     (*self)[i] = val;
779                 else
780                     throw std::out_of_range("vector index out of range");
781             }
782 SWIGINTERN void std_vector_Sl_double_Sg__add__SWIG_1(std::vector< double > *self,int i,std::vector< double >::value_type const &val){
783                 int size = int(self->size());
784                 if (i>=0 && i<=size)
785                     self->insert(self->begin() + i, val);
786                 else
787                     throw std::out_of_range("vector index out of range");
788             }
789 SWIGINTERN bool std_vector_Sl_double_Sg__remove(std::vector< double > *self,std::vector< double >::value_type const &val){
790                 auto it = std::find(self->begin(), self->end(), val);
791                 if (it == self->end())
792                     return false;
793                 else
794                     self->erase(it);
795                 return true;
796             }
797 SWIGINTERN void *std_vector_Sl_double_Sg__asByteBuffer(std::vector< double > *self,int i,int capacity){
798                 (void) capacity;
799                 void* buffer = nullptr;
800                 int size = int(self->size()) ;
801                 if (i>=0 && i<size) {
802                     buffer = self->data() + i;
803                 } else if (i==0 && size == 0) {
804                     buffer = self->data();
805                 } else {
806                     throw std::out_of_range("vector index out of range");
807                 }
808                 return buffer;
809             }
810 SWIGINTERN bool std_vector_Sl_std_string_Sg__contains(std::vector< std::string > *self,std::string const &o){
811                return std::find(self->begin(), self->end(), o) != self->end();
812             }
813 SWIGINTERN int std_vector_Sl_std_string_Sg__indexOf(std::vector< std::string > *self,std::string const &o){
814                auto it = std::find(self->begin(), self->end(), o);
815                if (it != self->end())
816                    return std::distance(self->begin(), it);
817                else
818                    return -1;
819             }
820 SWIGINTERN std::vector< std::string >::const_reference std_vector_Sl_std_string_Sg__get(std::vector< std::string > *self,int i){
821                 int size = int(self->size());
822                 if (i>=0 && i<size)
823                     return (*self)[i];
824                 else
825                     throw std::out_of_range("vector index out of range");
826             }
827 SWIGINTERN void std_vector_Sl_std_string_Sg__set(std::vector< std::string > *self,int i,std::vector< std::string >::value_type const &val){
828                 int size = int(self->size());
829                 if (i>=0 && i<size)
830                     (*self)[i] = val;
831                 else
832                     throw std::out_of_range("vector index out of range");
833             }
834 SWIGINTERN void std_vector_Sl_std_string_Sg__add__SWIG_1(std::vector< std::string > *self,int i,std::vector< std::string >::value_type const &val){
835                 int size = int(self->size());
836                 if (i>=0 && i<=size)
837                     self->insert(self->begin() + i, val);
838                 else
839                     throw std::out_of_range("vector index out of range");
840             }
841 SWIGINTERN bool std_vector_Sl_std_string_Sg__remove(std::vector< std::string > *self,std::vector< std::string >::value_type const &val){
842                 auto it = std::find(self->begin(), self->end(), val);
843                 if (it == self->end())
844                     return false;
845                 else
846                     self->erase(it);
847                 return true;
848             }
849 SWIGINTERN void *std_vector_Sl_std_string_Sg__asByteBuffer(std::vector< std::string > *self,int i,int capacity){
850                 (void) capacity;
851                 void* buffer = nullptr;
852                 int size = int(self->size()) ;
853                 if (i>=0 && i<size) {
854                     buffer = self->data() + i;
855                 } else if (i==0 && size == 0) {
856                     buffer = self->data();
857                 } else {
858                     throw std::out_of_range("vector index out of range");
859                 }
860                 return buffer;
861             }
862 SWIGINTERN bool std_vector_Sl_ScicosID_Sg__contains(std::vector< ScicosID > *self,long long const &o){
863                return std::find(self->begin(), self->end(), o) != self->end();
864             }
865 SWIGINTERN int std_vector_Sl_ScicosID_Sg__indexOf(std::vector< ScicosID > *self,long long const &o){
866                auto it = std::find(self->begin(), self->end(), o);
867                if (it != self->end())
868                    return std::distance(self->begin(), it);
869                else
870                    return -1;
871             }
872 SWIGINTERN std::vector< long long >::const_reference std_vector_Sl_ScicosID_Sg__get(std::vector< ScicosID > *self,int i){
873                 int size = int(self->size());
874                 if (i>=0 && i<size)
875                     return (*self)[i];
876                 else
877                     throw std::out_of_range("vector index out of range");
878             }
879 SWIGINTERN void std_vector_Sl_ScicosID_Sg__set(std::vector< ScicosID > *self,int i,std::vector< long long >::value_type const &val){
880                 int size = int(self->size());
881                 if (i>=0 && i<size)
882                     (*self)[i] = val;
883                 else
884                     throw std::out_of_range("vector index out of range");
885             }
886 SWIGINTERN void std_vector_Sl_ScicosID_Sg__add__SWIG_1(std::vector< ScicosID > *self,int i,std::vector< long long >::value_type const &val){
887                 int size = int(self->size());
888                 if (i>=0 && i<=size)
889                     self->insert(self->begin() + i, val);
890                 else
891                     throw std::out_of_range("vector index out of range");
892             }
893 SWIGINTERN bool std_vector_Sl_ScicosID_Sg__remove(std::vector< ScicosID > *self,std::vector< long long >::value_type const &val){
894                 auto it = std::find(self->begin(), self->end(), val);
895                 if (it == self->end())
896                     return false;
897                 else
898                     self->erase(it);
899                 return true;
900             }
901 SWIGINTERN void *std_vector_Sl_ScicosID_Sg__asByteBuffer(std::vector< ScicosID > *self,int i,int capacity){
902                 (void) capacity;
903                 void* buffer = nullptr;
904                 int size = int(self->size()) ;
905                 if (i>=0 && i<size) {
906                     buffer = self->data() + i;
907                 } else if (i==0 && size == 0) {
908                     buffer = self->data();
909                 } else {
910                     throw std::out_of_range("vector index out of range");
911                 }
912                 return buffer;
913             }
914
915 static void register_view(const std::string& name, org_scilab_modules_scicos::View* view) {
916   org_scilab_modules_scicos::Controller::register_view(name, view);
917 };
918 static void unregister_view(org_scilab_modules_scicos::View* view) {
919   org_scilab_modules_scicos::Controller::unregister_view(view);
920 };
921
922
923
924 /* ---------------------------------------------------
925  * C++ director class methods
926  * --------------------------------------------------- */
927
928 #include "JavaController_wrap.h"
929
930 SwigDirector_View::SwigDirector_View(JNIEnv *jenv) : org_scilab_modules_scicos::View(), Swig::Director(jenv) {
931 }
932
933 SwigDirector_View::~SwigDirector_View() {
934   swig_disconnect_director_self("swigDirectorDisconnect");
935 }
936
937
938 void SwigDirector_View::objectCreated(ScicosID const &uid, kind_t kind) {
939   JNIEnvWrapper swigjnienv(this) ;
940   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
941   jobject swigjobj = (jobject) NULL ;
942   jlong juid = 0 ;
943   jint jkind  ;
944   
945   if (!swig_override[0]) {
946     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectCreated.");
947     return;
948   }
949   swigjobj = swig_get_self(jenv);
950   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
951     juid = (jlong)uid;
952     jkind = (jint) kind;
953     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[0], swigjobj, juid, jkind);
954     jthrowable swigerror = jenv->ExceptionOccurred();
955     if (swigerror) {
956       jenv->ExceptionClear();
957       throw Swig::DirectorException(jenv, swigerror);
958     }
959     
960   } else {
961     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectCreated ");
962   }
963   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
964 }
965
966 void SwigDirector_View::objectReferenced(ScicosID const &uid, kind_t kind, unsigned int refCount) {
967   JNIEnvWrapper swigjnienv(this) ;
968   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
969   jobject swigjobj = (jobject) NULL ;
970   jlong juid = 0 ;
971   jint jkind  ;
972   jlong jrefCount  ;
973   
974   if (!swig_override[1]) {
975     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectReferenced.");
976     return;
977   }
978   swigjobj = swig_get_self(jenv);
979   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
980     juid = (jlong)uid;
981     jkind = (jint) kind;
982     jrefCount = (jlong) refCount;
983     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[1], swigjobj, juid, jkind, jrefCount);
984     jthrowable swigerror = jenv->ExceptionOccurred();
985     if (swigerror) {
986       jenv->ExceptionClear();
987       throw Swig::DirectorException(jenv, swigerror);
988     }
989     
990   } else {
991     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectReferenced ");
992   }
993   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
994 }
995
996 void SwigDirector_View::objectUnreferenced(ScicosID const &uid, kind_t kind, unsigned int refCount) {
997   JNIEnvWrapper swigjnienv(this) ;
998   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
999   jobject swigjobj = (jobject) NULL ;
1000   jlong juid = 0 ;
1001   jint jkind  ;
1002   jlong jrefCount  ;
1003   
1004   if (!swig_override[2]) {
1005     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectUnreferenced.");
1006     return;
1007   }
1008   swigjobj = swig_get_self(jenv);
1009   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1010     juid = (jlong)uid;
1011     jkind = (jint) kind;
1012     jrefCount = (jlong) refCount;
1013     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[2], swigjobj, juid, jkind, jrefCount);
1014     jthrowable swigerror = jenv->ExceptionOccurred();
1015     if (swigerror) {
1016       jenv->ExceptionClear();
1017       throw Swig::DirectorException(jenv, swigerror);
1018     }
1019     
1020   } else {
1021     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectUnreferenced ");
1022   }
1023   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1024 }
1025
1026 void SwigDirector_View::objectDeleted(ScicosID const &uid, kind_t kind) {
1027   JNIEnvWrapper swigjnienv(this) ;
1028   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1029   jobject swigjobj = (jobject) NULL ;
1030   jlong juid = 0 ;
1031   jint jkind  ;
1032   
1033   if (!swig_override[3]) {
1034     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectDeleted.");
1035     return;
1036   }
1037   swigjobj = swig_get_self(jenv);
1038   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1039     juid = (jlong)uid;
1040     jkind = (jint) kind;
1041     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[3], swigjobj, juid, jkind);
1042     jthrowable swigerror = jenv->ExceptionOccurred();
1043     if (swigerror) {
1044       jenv->ExceptionClear();
1045       throw Swig::DirectorException(jenv, swigerror);
1046     }
1047     
1048   } else {
1049     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectDeleted ");
1050   }
1051   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1052 }
1053
1054 void SwigDirector_View::propertyUpdated(ScicosID const &uid, kind_t kind, object_properties_t property, update_status_t status) {
1055   JNIEnvWrapper swigjnienv(this) ;
1056   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1057   jobject swigjobj = (jobject) NULL ;
1058   jlong juid = 0 ;
1059   jint jkind  ;
1060   jint jproperty  ;
1061   jint jstatus  ;
1062   
1063   if (!swig_override[4]) {
1064     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::propertyUpdated.");
1065     return;
1066   }
1067   swigjobj = swig_get_self(jenv);
1068   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1069     juid = (jlong)uid;
1070     jkind = (jint) kind;
1071     jproperty = (jint) property;
1072     jstatus = (jint) status;
1073     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[4], swigjobj, juid, jkind, jproperty, jstatus);
1074     jthrowable swigerror = jenv->ExceptionOccurred();
1075     if (swigerror) {
1076       jenv->ExceptionClear();
1077       throw Swig::DirectorException(jenv, swigerror);
1078     }
1079     
1080   } else {
1081     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::propertyUpdated ");
1082   }
1083   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1084 }
1085
1086 void SwigDirector_View::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
1087   static struct {
1088     const char *mname;
1089     const char *mdesc;
1090     jmethodID base_methid;
1091   } methods[] = {
1092     {
1093       "objectCreated", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
1094     },
1095     {
1096       "objectReferenced", "(JLorg/scilab/modules/xcos/Kind;J)V", NULL 
1097     },
1098     {
1099       "objectUnreferenced", "(JLorg/scilab/modules/xcos/Kind;J)V", NULL 
1100     },
1101     {
1102       "objectDeleted", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
1103     },
1104     {
1105       "propertyUpdated", "(JLorg/scilab/modules/xcos/Kind;Lorg/scilab/modules/xcos/ObjectProperties;Lorg/scilab/modules/xcos/UpdateStatus;)V", NULL 
1106     }
1107   };
1108   
1109   static jclass baseclass = 0 ;
1110   
1111   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
1112     if (!baseclass) {
1113       baseclass = jenv->FindClass("org/scilab/modules/xcos/View");
1114       if (!baseclass) return;
1115       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
1116     }
1117     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
1118     for (int i = 0; i < 5; ++i) {
1119       if (!methods[i].base_methid) {
1120         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
1121         if (!methods[i].base_methid) return;
1122       }
1123       swig_override[i] = false;
1124       if (derived) {
1125         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
1126         swig_override[i] = (methid != methods[i].base_methid);
1127         jenv->ExceptionClear();
1128       }
1129     }
1130   }
1131 }
1132
1133
1134
1135 #ifdef __cplusplus
1136 extern "C" {
1137 #endif
1138
1139 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1View(JNIEnv *jenv, jclass jcls) {
1140   jlong jresult = 0 ;
1141   org_scilab_modules_scicos::View *result = 0 ;
1142   
1143   (void)jenv;
1144   (void)jcls;
1145   result = (org_scilab_modules_scicos::View *)new SwigDirector_View(jenv);
1146   *(org_scilab_modules_scicos::View **)&jresult = result; 
1147   return jresult;
1148 }
1149
1150
1151 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1View(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1152   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1153   
1154   (void)jenv;
1155   (void)jcls;
1156   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1157   delete arg1;
1158 }
1159
1160
1161 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectCreated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1162   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1163   ScicosID *arg2 = 0 ;
1164   kind_t arg3 ;
1165   ScicosID temp2 ;
1166   
1167   (void)jenv;
1168   (void)jcls;
1169   (void)jarg1_;
1170   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1171   temp2 = (ScicosID)jarg2; 
1172   arg2 = &temp2; 
1173   arg3 = (kind_t)jarg3; 
1174   (arg1)->objectCreated((ScicosID const &)*arg2,arg3);
1175 }
1176
1177
1178 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectReferenced(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jlong jarg4) {
1179   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1180   ScicosID *arg2 = 0 ;
1181   kind_t arg3 ;
1182   unsigned int arg4 ;
1183   ScicosID temp2 ;
1184   
1185   (void)jenv;
1186   (void)jcls;
1187   (void)jarg1_;
1188   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1189   temp2 = (ScicosID)jarg2; 
1190   arg2 = &temp2; 
1191   arg3 = (kind_t)jarg3; 
1192   arg4 = (unsigned int)jarg4; 
1193   (arg1)->objectReferenced((ScicosID const &)*arg2,arg3,arg4);
1194 }
1195
1196
1197 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectUnreferenced(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jlong jarg4) {
1198   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1199   ScicosID *arg2 = 0 ;
1200   kind_t arg3 ;
1201   unsigned int arg4 ;
1202   ScicosID temp2 ;
1203   
1204   (void)jenv;
1205   (void)jcls;
1206   (void)jarg1_;
1207   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1208   temp2 = (ScicosID)jarg2; 
1209   arg2 = &temp2; 
1210   arg3 = (kind_t)jarg3; 
1211   arg4 = (unsigned int)jarg4; 
1212   (arg1)->objectUnreferenced((ScicosID const &)*arg2,arg3,arg4);
1213 }
1214
1215
1216 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectDeleted(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1217   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1218   ScicosID *arg2 = 0 ;
1219   kind_t arg3 ;
1220   ScicosID temp2 ;
1221   
1222   (void)jenv;
1223   (void)jcls;
1224   (void)jarg1_;
1225   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1226   temp2 = (ScicosID)jarg2; 
1227   arg2 = &temp2; 
1228   arg3 = (kind_t)jarg3; 
1229   (arg1)->objectDeleted((ScicosID const &)*arg2,arg3);
1230 }
1231
1232
1233 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) {
1234   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1235   ScicosID *arg2 = 0 ;
1236   kind_t arg3 ;
1237   object_properties_t arg4 ;
1238   update_status_t arg5 ;
1239   ScicosID temp2 ;
1240   
1241   (void)jenv;
1242   (void)jcls;
1243   (void)jarg1_;
1244   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1245   temp2 = (ScicosID)jarg2; 
1246   arg2 = &temp2; 
1247   arg3 = (kind_t)jarg3; 
1248   arg4 = (object_properties_t)jarg4; 
1249   arg5 = (update_status_t)jarg5; 
1250   (arg1)->propertyUpdated((ScicosID const &)*arg2,arg3,arg4,arg5);
1251 }
1252
1253
1254 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) {
1255   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1256   (void)jcls;
1257   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1258   if (director) {
1259     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
1260   }
1261 }
1262
1263
1264 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
1265   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1266   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1267   (void)jcls;
1268   if (director) {
1269     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
1270   }
1271 }
1272
1273
1274 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1look_1for_1view(JNIEnv *jenv, jclass jcls, jstring jarg1) {
1275   jlong jresult = 0 ;
1276   std::string *arg1 = 0 ;
1277   org_scilab_modules_scicos::View *result = 0 ;
1278   
1279   (void)jenv;
1280   (void)jcls;
1281   Swig::JavaString javaString(jenv, jarg1);
1282   std::string arg1_str(javaString.c_str());
1283   arg1 = &arg1_str;
1284   result = (org_scilab_modules_scicos::View *)org_scilab_modules_scicos::Controller::look_for_view((std::string const &)*arg1);
1285   *(org_scilab_modules_scicos::View **)&jresult = result; 
1286   
1287   return jresult;
1288 }
1289
1290
1291 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1Controller(JNIEnv *jenv, jclass jcls) {
1292   jlong jresult = 0 ;
1293   org_scilab_modules_scicos::Controller *result = 0 ;
1294   
1295   (void)jenv;
1296   (void)jcls;
1297   result = (org_scilab_modules_scicos::Controller *)new org_scilab_modules_scicos::Controller();
1298   *(org_scilab_modules_scicos::Controller **)&jresult = result; 
1299   return jresult;
1300 }
1301
1302
1303 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1Controller(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1304   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1305   
1306   (void)jenv;
1307   (void)jcls;
1308   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1309   delete arg1;
1310 }
1311
1312
1313 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1createObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1314   jlong jresult = 0 ;
1315   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1316   kind_t arg2 ;
1317   ScicosID result;
1318   
1319   (void)jenv;
1320   (void)jcls;
1321   (void)jarg1_;
1322   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1323   arg2 = (kind_t)jarg2; 
1324   result = (ScicosID)(arg1)->createObject(arg2);
1325   jresult = (jlong)result; 
1326   return jresult;
1327 }
1328
1329
1330 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1referenceObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1331   jlong jresult = 0 ;
1332   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1333   ScicosID arg2 ;
1334   unsigned int result;
1335   
1336   (void)jenv;
1337   (void)jcls;
1338   (void)jarg1_;
1339   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1340   arg2 = (ScicosID)jarg2; 
1341   result = (unsigned int)((org_scilab_modules_scicos::Controller const *)arg1)->referenceObject(arg2);
1342   jresult = (jlong)result; 
1343   return jresult;
1344 }
1345
1346
1347 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1deleteObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1348   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1349   ScicosID arg2 ;
1350   
1351   (void)jenv;
1352   (void)jcls;
1353   (void)jarg1_;
1354   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1355   arg2 = (ScicosID)jarg2; 
1356   (arg1)->deleteObject(arg2);
1357 }
1358
1359
1360 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1cloneObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jboolean jarg3, jboolean jarg4) {
1361   jlong jresult = 0 ;
1362   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1363   ScicosID arg2 ;
1364   bool arg3 ;
1365   bool arg4 ;
1366   ScicosID result;
1367   
1368   (void)jenv;
1369   (void)jcls;
1370   (void)jarg1_;
1371   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1372   arg2 = (ScicosID)jarg2; 
1373   arg3 = jarg3 ? true : false; 
1374   arg4 = jarg4 ? true : false; 
1375   result = (ScicosID)(arg1)->cloneObject(arg2,arg3,arg4);
1376   jresult = (jlong)result; 
1377   return jresult;
1378 }
1379
1380
1381 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getKind(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1382   jint jresult = 0 ;
1383   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1384   ScicosID arg2 ;
1385   kind_t result;
1386   
1387   (void)jenv;
1388   (void)jcls;
1389   (void)jarg1_;
1390   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1391   arg2 = (ScicosID)jarg2; 
1392   result = (kind_t)((org_scilab_modules_scicos::Controller const *)arg1)->getKind(arg2);
1393   jresult = (jint)result; 
1394   return jresult;
1395 }
1396
1397
1398 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getAll(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1399   jlong jresult = 0 ;
1400   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1401   kind_t arg2 ;
1402   std::vector< ScicosID > result;
1403   
1404   (void)jenv;
1405   (void)jcls;
1406   (void)jarg1_;
1407   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1408   arg2 = (kind_t)jarg2; 
1409   result = ((org_scilab_modules_scicos::Controller const *)arg1)->getAll(arg2);
1410   *(std::vector< ScicosID > **)&jresult = new std::vector< ScicosID >((const std::vector< ScicosID > &)result); 
1411   return jresult;
1412 }
1413
1414
1415 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1sortAndFillKind(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
1416   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1417   std::vector< ScicosID > *arg2 = 0 ;
1418   std::vector< int > *arg3 = 0 ;
1419   
1420   (void)jenv;
1421   (void)jcls;
1422   (void)jarg1_;
1423   (void)jarg2_;
1424   (void)jarg3_;
1425   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1426   arg2 = *(std::vector< ScicosID > **)&jarg2;
1427   if (!arg2) {
1428     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ScicosID > & reference is null");
1429     return ;
1430   } 
1431   arg3 = *(std::vector< int > **)&jarg3;
1432   if (!arg3) {
1433     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > & reference is null");
1434     return ;
1435   } 
1436   (arg1)->sortAndFillKind(*arg2,*arg3);
1437 }
1438
1439
1440 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jdoubleArray jarg5) {
1441   jboolean jresult = 0 ;
1442   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1443   ScicosID arg2 ;
1444   kind_t arg3 ;
1445   object_properties_t arg4 ;
1446   double *arg5 = 0 ;
1447   double temp5 ;
1448   bool result;
1449   
1450   (void)jenv;
1451   (void)jcls;
1452   (void)jarg1_;
1453   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1454   arg2 = (ScicosID)jarg2; 
1455   arg3 = (kind_t)jarg3; 
1456   arg4 = (object_properties_t)jarg4; 
1457   {
1458     if (!jarg5) {
1459       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1460       return 0;
1461     }
1462     if (jenv->GetArrayLength(jarg5) == 0) {
1463       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1464       return 0;
1465     }
1466     temp5 = (double)0;
1467     arg5 = &temp5; 
1468   }
1469   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1470   jresult = (jboolean)result; 
1471   {
1472     jdouble jvalue = (jdouble)temp5;
1473     jenv->SetDoubleArrayRegion(jarg5, 0, 1, &jvalue);
1474   }
1475   
1476   return jresult;
1477 }
1478
1479
1480 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) {
1481   jboolean jresult = 0 ;
1482   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1483   ScicosID arg2 ;
1484   kind_t arg3 ;
1485   object_properties_t arg4 ;
1486   int *arg5 = 0 ;
1487   int temp5 ;
1488   bool result;
1489   
1490   (void)jenv;
1491   (void)jcls;
1492   (void)jarg1_;
1493   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1494   arg2 = (ScicosID)jarg2; 
1495   arg3 = (kind_t)jarg3; 
1496   arg4 = (object_properties_t)jarg4; 
1497   {
1498     if (!jarg5) {
1499       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1500       return 0;
1501     }
1502     if (jenv->GetArrayLength(jarg5) == 0) {
1503       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1504       return 0;
1505     }
1506     temp5 = (int)0;
1507     arg5 = &temp5; 
1508   }
1509   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1510   jresult = (jboolean)result; 
1511   {
1512     jint jvalue = (jint)temp5;
1513     jenv->SetIntArrayRegion(jarg5, 0, 1, &jvalue);
1514   }
1515   
1516   return jresult;
1517 }
1518
1519
1520 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) {
1521   jboolean jresult = 0 ;
1522   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1523   ScicosID arg2 ;
1524   kind_t arg3 ;
1525   object_properties_t arg4 ;
1526   bool *arg5 = 0 ;
1527   bool temp5 ;
1528   bool result;
1529   
1530   (void)jenv;
1531   (void)jcls;
1532   (void)jarg1_;
1533   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1534   arg2 = (ScicosID)jarg2; 
1535   arg3 = (kind_t)jarg3; 
1536   arg4 = (object_properties_t)jarg4; 
1537   {
1538     if (!jarg5) {
1539       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1540       return 0;
1541     }
1542     if (jenv->GetArrayLength(jarg5) == 0) {
1543       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1544       return 0;
1545     }
1546     temp5 = false;
1547     arg5 = &temp5; 
1548   }
1549   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1550   jresult = (jboolean)result; 
1551   {
1552     jboolean jvalue = (jboolean)temp5;
1553     jenv->SetBooleanArrayRegion(jarg5, 0, 1, &jvalue);
1554   }
1555   
1556   return jresult;
1557 }
1558
1559
1560 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jobjectArray jarg5) {
1561   jboolean jresult = 0 ;
1562   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1563   ScicosID arg2 ;
1564   kind_t arg3 ;
1565   object_properties_t arg4 ;
1566   std::string *arg5 = 0 ;
1567   std::string temp5 ;
1568   bool result;
1569   
1570   (void)jenv;
1571   (void)jcls;
1572   (void)jarg1_;
1573   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1574   arg2 = (ScicosID)jarg2; 
1575   arg3 = (kind_t)jarg3; 
1576   arg4 = (object_properties_t)jarg4; 
1577   {
1578     if (!jarg5) {
1579       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1580       return 0;
1581     }
1582     if (jenv->GetArrayLength(jarg5) == 0) {
1583       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1584       return 0;
1585     }
1586     arg5 = &temp5;
1587     *arg5 = "";
1588   }
1589   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1590   jresult = (jboolean)result; 
1591   {
1592     jstring jnewstring = NULL;
1593     if (arg5) {
1594       jnewstring = jenv->NewStringUTF(arg5->c_str());
1595     }
1596     jenv->SetObjectArrayElement(jarg5, 0, jnewstring);
1597   }
1598   return jresult;
1599 }
1600
1601
1602 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlongArray jarg5) {
1603   jboolean jresult = 0 ;
1604   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1605   ScicosID arg2 ;
1606   kind_t arg3 ;
1607   object_properties_t arg4 ;
1608   ScicosID *arg5 = 0 ;
1609   ScicosID temp5 ;
1610   bool result;
1611   
1612   (void)jenv;
1613   (void)jcls;
1614   (void)jarg1_;
1615   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1616   arg2 = (ScicosID)jarg2; 
1617   arg3 = (kind_t)jarg3; 
1618   arg4 = (object_properties_t)jarg4; 
1619   {
1620     if (!jarg5) {
1621       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1622       return 0;
1623     }
1624     if (jenv->GetArrayLength(jarg5) == 0) {
1625       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1626       return 0;
1627     }
1628     temp5 = (ScicosID)0;
1629     arg5 = &temp5; 
1630   }
1631   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1632   jresult = (jboolean)result; 
1633   {
1634     jlong jvalue = (jlong)temp5;
1635     jenv->SetLongArrayRegion(jarg5, 0, 1, &jvalue);
1636   }
1637   
1638   return jresult;
1639 }
1640
1641
1642 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1643   jboolean jresult = 0 ;
1644   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1645   ScicosID arg2 ;
1646   kind_t arg3 ;
1647   object_properties_t arg4 ;
1648   std::vector< double > *arg5 = 0 ;
1649   bool result;
1650   
1651   (void)jenv;
1652   (void)jcls;
1653   (void)jarg1_;
1654   (void)jarg5_;
1655   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1656   arg2 = (ScicosID)jarg2; 
1657   arg3 = (kind_t)jarg3; 
1658   arg4 = (object_properties_t)jarg4; 
1659   arg5 = *(std::vector< double > **)&jarg5;
1660   if (!arg5) {
1661     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< double > & reference is null");
1662     return 0;
1663   } 
1664   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1665   jresult = (jboolean)result; 
1666   return jresult;
1667 }
1668
1669
1670 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_) {
1671   jboolean jresult = 0 ;
1672   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1673   ScicosID arg2 ;
1674   kind_t arg3 ;
1675   object_properties_t arg4 ;
1676   std::vector< int > *arg5 = 0 ;
1677   bool result;
1678   
1679   (void)jenv;
1680   (void)jcls;
1681   (void)jarg1_;
1682   (void)jarg5_;
1683   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1684   arg2 = (ScicosID)jarg2; 
1685   arg3 = (kind_t)jarg3; 
1686   arg4 = (object_properties_t)jarg4; 
1687   arg5 = *(std::vector< int > **)&jarg5;
1688   if (!arg5) {
1689     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > & reference is null");
1690     return 0;
1691   } 
1692   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1693   jresult = (jboolean)result; 
1694   return jresult;
1695 }
1696
1697
1698 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_) {
1699   jboolean jresult = 0 ;
1700   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1701   ScicosID arg2 ;
1702   kind_t arg3 ;
1703   object_properties_t arg4 ;
1704   std::vector< bool > *arg5 = 0 ;
1705   bool result;
1706   
1707   (void)jenv;
1708   (void)jcls;
1709   (void)jarg1_;
1710   (void)jarg5_;
1711   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1712   arg2 = (ScicosID)jarg2; 
1713   arg3 = (kind_t)jarg3; 
1714   arg4 = (object_properties_t)jarg4; 
1715   arg5 = *(std::vector< bool > **)&jarg5;
1716   if (!arg5) {
1717     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< bool > & reference is null");
1718     return 0;
1719   } 
1720   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1721   jresult = (jboolean)result; 
1722   return jresult;
1723 }
1724
1725
1726 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_) {
1727   jboolean jresult = 0 ;
1728   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1729   ScicosID arg2 ;
1730   kind_t arg3 ;
1731   object_properties_t arg4 ;
1732   std::vector< std::string > *arg5 = 0 ;
1733   bool result;
1734   
1735   (void)jenv;
1736   (void)jcls;
1737   (void)jarg1_;
1738   (void)jarg5_;
1739   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1740   arg2 = (ScicosID)jarg2; 
1741   arg3 = (kind_t)jarg3; 
1742   arg4 = (object_properties_t)jarg4; 
1743   arg5 = *(std::vector< std::string > **)&jarg5;
1744   if (!arg5) {
1745     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > & reference is null");
1746     return 0;
1747   } 
1748   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1749   jresult = (jboolean)result; 
1750   return jresult;
1751 }
1752
1753
1754 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_) {
1755   jboolean jresult = 0 ;
1756   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1757   ScicosID arg2 ;
1758   kind_t arg3 ;
1759   object_properties_t arg4 ;
1760   std::vector< ScicosID > *arg5 = 0 ;
1761   bool result;
1762   
1763   (void)jenv;
1764   (void)jcls;
1765   (void)jarg1_;
1766   (void)jarg5_;
1767   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1768   arg2 = (ScicosID)jarg2; 
1769   arg3 = (kind_t)jarg3; 
1770   arg4 = (object_properties_t)jarg4; 
1771   arg5 = *(std::vector< ScicosID > **)&jarg5;
1772   if (!arg5) {
1773     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ScicosID > & reference is null");
1774     return 0;
1775   } 
1776   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1777   jresult = (jboolean)result; 
1778   return jresult;
1779 }
1780
1781
1782 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jdouble jarg5) {
1783   jint jresult = 0 ;
1784   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1785   ScicosID arg2 ;
1786   kind_t arg3 ;
1787   object_properties_t arg4 ;
1788   double arg5 ;
1789   update_status_t result;
1790   
1791   (void)jenv;
1792   (void)jcls;
1793   (void)jarg1_;
1794   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1795   arg2 = (ScicosID)jarg2; 
1796   arg3 = (kind_t)jarg3; 
1797   arg4 = (object_properties_t)jarg4; 
1798   arg5 = (double)jarg5; 
1799   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,arg5);
1800   jresult = (jint)result; 
1801   return jresult;
1802 }
1803
1804
1805 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) {
1806   jint jresult = 0 ;
1807   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1808   ScicosID arg2 ;
1809   kind_t arg3 ;
1810   object_properties_t arg4 ;
1811   int arg5 ;
1812   update_status_t result;
1813   
1814   (void)jenv;
1815   (void)jcls;
1816   (void)jarg1_;
1817   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1818   arg2 = (ScicosID)jarg2; 
1819   arg3 = (kind_t)jarg3; 
1820   arg4 = (object_properties_t)jarg4; 
1821   arg5 = (int)jarg5; 
1822   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,arg5);
1823   jresult = (jint)result; 
1824   return jresult;
1825 }
1826
1827
1828 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) {
1829   jint jresult = 0 ;
1830   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1831   ScicosID arg2 ;
1832   kind_t arg3 ;
1833   object_properties_t arg4 ;
1834   bool arg5 ;
1835   update_status_t result;
1836   
1837   (void)jenv;
1838   (void)jcls;
1839   (void)jarg1_;
1840   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1841   arg2 = (ScicosID)jarg2; 
1842   arg3 = (kind_t)jarg3; 
1843   arg4 = (object_properties_t)jarg4; 
1844   arg5 = jarg5 ? true : false; 
1845   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,arg5);
1846   jresult = (jint)result; 
1847   return jresult;
1848 }
1849
1850
1851 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, jlong jarg5) {
1852   jint jresult = 0 ;
1853   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1854   ScicosID arg2 ;
1855   kind_t arg3 ;
1856   object_properties_t arg4 ;
1857   ScicosID arg5 ;
1858   update_status_t result;
1859   
1860   (void)jenv;
1861   (void)jcls;
1862   (void)jarg1_;
1863   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1864   arg2 = (ScicosID)jarg2; 
1865   arg3 = (kind_t)jarg3; 
1866   arg4 = (object_properties_t)jarg4; 
1867   arg5 = (ScicosID)jarg5; 
1868   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,arg5);
1869   jresult = (jint)result; 
1870   return jresult;
1871 }
1872
1873
1874 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) {
1875   jint jresult = 0 ;
1876   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1877   ScicosID arg2 ;
1878   kind_t arg3 ;
1879   object_properties_t arg4 ;
1880   std::string *arg5 = 0 ;
1881   update_status_t result;
1882   
1883   (void)jenv;
1884   (void)jcls;
1885   (void)jarg1_;
1886   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1887   arg2 = (ScicosID)jarg2; 
1888   arg3 = (kind_t)jarg3; 
1889   arg4 = (object_properties_t)jarg4; 
1890   Swig::JavaString javaString(jenv, jarg5);
1891   std::string arg5_str(javaString.c_str());
1892   arg5 = &arg5_str;
1893   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::string const &)*arg5);
1894   jresult = (jint)result; 
1895   
1896   return jresult;
1897 }
1898
1899
1900 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1901   jint jresult = 0 ;
1902   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1903   ScicosID arg2 ;
1904   kind_t arg3 ;
1905   object_properties_t arg4 ;
1906   std::vector< double > *arg5 = 0 ;
1907   update_status_t result;
1908   
1909   (void)jenv;
1910   (void)jcls;
1911   (void)jarg1_;
1912   (void)jarg5_;
1913   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1914   arg2 = (ScicosID)jarg2; 
1915   arg3 = (kind_t)jarg3; 
1916   arg4 = (object_properties_t)jarg4; 
1917   arg5 = *(std::vector< double > **)&jarg5;
1918   if (!arg5) {
1919     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< double > const & reference is null");
1920     return 0;
1921   } 
1922   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::vector< double > const &)*arg5);
1923   jresult = (jint)result; 
1924   return jresult;
1925 }
1926
1927
1928 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_) {
1929   jint jresult = 0 ;
1930   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1931   ScicosID arg2 ;
1932   kind_t arg3 ;
1933   object_properties_t arg4 ;
1934   std::vector< int > *arg5 = 0 ;
1935   update_status_t result;
1936   
1937   (void)jenv;
1938   (void)jcls;
1939   (void)jarg1_;
1940   (void)jarg5_;
1941   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1942   arg2 = (ScicosID)jarg2; 
1943   arg3 = (kind_t)jarg3; 
1944   arg4 = (object_properties_t)jarg4; 
1945   arg5 = *(std::vector< int > **)&jarg5;
1946   if (!arg5) {
1947     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > const & reference is null");
1948     return 0;
1949   } 
1950   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::vector< int > const &)*arg5);
1951   jresult = (jint)result; 
1952   return jresult;
1953 }
1954
1955
1956 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_) {
1957   jint jresult = 0 ;
1958   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1959   ScicosID arg2 ;
1960   kind_t arg3 ;
1961   object_properties_t arg4 ;
1962   std::vector< bool > *arg5 = 0 ;
1963   update_status_t result;
1964   
1965   (void)jenv;
1966   (void)jcls;
1967   (void)jarg1_;
1968   (void)jarg5_;
1969   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1970   arg2 = (ScicosID)jarg2; 
1971   arg3 = (kind_t)jarg3; 
1972   arg4 = (object_properties_t)jarg4; 
1973   arg5 = *(std::vector< bool > **)&jarg5;
1974   if (!arg5) {
1975     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< bool > const & reference is null");
1976     return 0;
1977   } 
1978   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::vector< bool > const &)*arg5);
1979   jresult = (jint)result; 
1980   return jresult;
1981 }
1982
1983
1984 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_) {
1985   jint jresult = 0 ;
1986   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1987   ScicosID arg2 ;
1988   kind_t arg3 ;
1989   object_properties_t arg4 ;
1990   std::vector< std::string > *arg5 = 0 ;
1991   update_status_t result;
1992   
1993   (void)jenv;
1994   (void)jcls;
1995   (void)jarg1_;
1996   (void)jarg5_;
1997   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1998   arg2 = (ScicosID)jarg2; 
1999   arg3 = (kind_t)jarg3; 
2000   arg4 = (object_properties_t)jarg4; 
2001   arg5 = *(std::vector< std::string > **)&jarg5;
2002   if (!arg5) {
2003     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & reference is null");
2004     return 0;
2005   } 
2006   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::vector< std::string > const &)*arg5);
2007   jresult = (jint)result; 
2008   return jresult;
2009 }
2010
2011
2012 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_) {
2013   jint jresult = 0 ;
2014   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
2015   ScicosID arg2 ;
2016   kind_t arg3 ;
2017   object_properties_t arg4 ;
2018   std::vector< ScicosID > *arg5 = 0 ;
2019   update_status_t result;
2020   
2021   (void)jenv;
2022   (void)jcls;
2023   (void)jarg1_;
2024   (void)jarg5_;
2025   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
2026   arg2 = (ScicosID)jarg2; 
2027   arg3 = (kind_t)jarg3; 
2028   arg4 = (object_properties_t)jarg4; 
2029   arg5 = *(std::vector< ScicosID > **)&jarg5;
2030   if (!arg5) {
2031     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ScicosID > const & reference is null");
2032     return 0;
2033   } 
2034   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::vector< ScicosID > const &)*arg5);
2035   jresult = (jint)result; 
2036   return jresult;
2037 }
2038
2039
2040 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2041   jlong jresult = 0 ;
2042   std::vector< int > *result = 0 ;
2043   
2044   (void)jenv;
2045   (void)jcls;
2046   result = (std::vector< int > *)new std::vector< int >();
2047   *(std::vector< int > **)&jresult = result; 
2048   return jresult;
2049 }
2050
2051
2052 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2053   jlong jresult = 0 ;
2054   std::vector< int >::size_type arg1 ;
2055   std::vector< int > *result = 0 ;
2056   
2057   (void)jenv;
2058   (void)jcls;
2059   arg1 = (std::vector< int >::size_type)jarg1; 
2060   result = (std::vector< int > *)new std::vector< int >(arg1);
2061   *(std::vector< int > **)&jresult = result; 
2062   return jresult;
2063 }
2064
2065
2066 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2067   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2068   std::vector< int >::size_type arg2 ;
2069   
2070   (void)jenv;
2071   (void)jcls;
2072   (void)jarg1_;
2073   arg1 = *(std::vector< int > **)&jarg1; 
2074   arg2 = (std::vector< int >::size_type)jarg2; 
2075   (arg1)->reserve(arg2);
2076 }
2077
2078
2079 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2080   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2081   std::vector< int >::size_type arg2 ;
2082   
2083   (void)jenv;
2084   (void)jcls;
2085   (void)jarg1_;
2086   arg1 = *(std::vector< int > **)&jarg1; 
2087   arg2 = (std::vector< int >::size_type)jarg2; 
2088   (arg1)->resize(arg2);
2089 }
2090
2091
2092 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2093   jint jresult = 0 ;
2094   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2095   int result;
2096   
2097   (void)jenv;
2098   (void)jcls;
2099   (void)jarg1_;
2100   arg1 = *(std::vector< int > **)&jarg1; 
2101   result = (int)((std::vector< int > const *)arg1)->size();
2102   jresult = (jint)result; 
2103   return jresult;
2104 }
2105
2106
2107 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2108   jboolean jresult = 0 ;
2109   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2110   bool result;
2111   
2112   (void)jenv;
2113   (void)jcls;
2114   (void)jarg1_;
2115   arg1 = *(std::vector< int > **)&jarg1; 
2116   result = (bool)((std::vector< int > const *)arg1)->empty();
2117   jresult = (jboolean)result; 
2118   return jresult;
2119 }
2120
2121
2122 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2123   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2124   
2125   (void)jenv;
2126   (void)jcls;
2127   (void)jarg1_;
2128   arg1 = *(std::vector< int > **)&jarg1; 
2129   (arg1)->clear();
2130 }
2131
2132
2133 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2134   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2135   std::vector< int >::value_type *arg2 = 0 ;
2136   std::vector< int >::value_type temp2 ;
2137   
2138   (void)jenv;
2139   (void)jcls;
2140   (void)jarg1_;
2141   arg1 = *(std::vector< int > **)&jarg1; 
2142   temp2 = (std::vector< int >::value_type)jarg2; 
2143   arg2 = &temp2; 
2144   (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
2145 }
2146
2147
2148 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2149   jboolean jresult = 0 ;
2150   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2151   int *arg2 = 0 ;
2152   int temp2 ;
2153   bool result;
2154   
2155   (void)jenv;
2156   (void)jcls;
2157   (void)jarg1_;
2158   arg1 = *(std::vector< int > **)&jarg1; 
2159   temp2 = (int)jarg2; 
2160   arg2 = &temp2; 
2161   result = (bool)std_vector_Sl_int_Sg__contains(arg1,(int const &)*arg2);
2162   jresult = (jboolean)result; 
2163   return jresult;
2164 }
2165
2166
2167 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2168   jint jresult = 0 ;
2169   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2170   int *arg2 = 0 ;
2171   int temp2 ;
2172   int result;
2173   
2174   (void)jenv;
2175   (void)jcls;
2176   (void)jarg1_;
2177   arg1 = *(std::vector< int > **)&jarg1; 
2178   temp2 = (int)jarg2; 
2179   arg2 = &temp2; 
2180   result = (int)std_vector_Sl_int_Sg__indexOf(arg1,(int const &)*arg2);
2181   jresult = (jint)result; 
2182   return jresult;
2183 }
2184
2185
2186 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2187   jint jresult = 0 ;
2188   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2189   int arg2 ;
2190   std::vector< int >::value_type *result = 0 ;
2191   
2192   (void)jenv;
2193   (void)jcls;
2194   (void)jarg1_;
2195   arg1 = *(std::vector< int > **)&jarg1; 
2196   arg2 = (int)jarg2; 
2197   try {
2198     result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__get(arg1,arg2);
2199   }
2200   catch(std::out_of_range &_e) {
2201     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2202     return 0;
2203   }
2204   
2205   jresult = (jint)*result; 
2206   return jresult;
2207 }
2208
2209
2210 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2211   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2212   int arg2 ;
2213   std::vector< int >::value_type *arg3 = 0 ;
2214   std::vector< int >::value_type temp3 ;
2215   
2216   (void)jenv;
2217   (void)jcls;
2218   (void)jarg1_;
2219   arg1 = *(std::vector< int > **)&jarg1; 
2220   arg2 = (int)jarg2; 
2221   temp3 = (std::vector< int >::value_type)jarg3; 
2222   arg3 = &temp3; 
2223   try {
2224     std_vector_Sl_int_Sg__set(arg1,arg2,(int const &)*arg3);
2225   }
2226   catch(std::out_of_range &_e) {
2227     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2228     return ;
2229   }
2230   
2231 }
2232
2233
2234 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1add_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2235   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2236   int arg2 ;
2237   std::vector< int >::value_type *arg3 = 0 ;
2238   std::vector< int >::value_type temp3 ;
2239   
2240   (void)jenv;
2241   (void)jcls;
2242   (void)jarg1_;
2243   arg1 = *(std::vector< int > **)&jarg1; 
2244   arg2 = (int)jarg2; 
2245   temp3 = (std::vector< int >::value_type)jarg3; 
2246   arg3 = &temp3; 
2247   try {
2248     std_vector_Sl_int_Sg__add__SWIG_1(arg1,arg2,(int const &)*arg3);
2249   }
2250   catch(std::out_of_range &_e) {
2251     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2252     return ;
2253   }
2254   
2255 }
2256
2257
2258 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2259   jboolean jresult = 0 ;
2260   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2261   std::vector< int >::value_type *arg2 = 0 ;
2262   std::vector< int >::value_type temp2 ;
2263   bool result;
2264   
2265   (void)jenv;
2266   (void)jcls;
2267   (void)jarg1_;
2268   arg1 = *(std::vector< int > **)&jarg1; 
2269   temp2 = (std::vector< int >::value_type)jarg2; 
2270   arg2 = &temp2; 
2271   result = (bool)std_vector_Sl_int_Sg__remove(arg1,(int const &)*arg2);
2272   jresult = (jboolean)result; 
2273   return jresult;
2274 }
2275
2276
2277 SWIGEXPORT jobject JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1asByteBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2278   jobject jresult = 0 ;
2279   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2280   int arg2 ;
2281   int arg3 ;
2282   void *result = 0 ;
2283   
2284   (void)jenv;
2285   (void)jcls;
2286   (void)jarg1_;
2287   arg1 = *(std::vector< int > **)&jarg1; 
2288   arg2 = (int)jarg2; 
2289   arg3 = (int)jarg3; 
2290   result = (void *)std_vector_Sl_int_Sg__asByteBuffer(arg1,arg2,arg3);
2291   {
2292     if (arg3 <= 0) {
2293       arg3 = arg1->size() - arg2;
2294     } else if (arg1->size() < arg3) {
2295       throw std::out_of_range("vector index out of range");
2296     }
2297     jresult = jenv->NewDirectByteBuffer(result, arg3 * sizeof(decltype(arg1->back())));
2298   }
2299   return jresult;
2300 }
2301
2302
2303 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfInt(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2304   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2305   
2306   (void)jenv;
2307   (void)jcls;
2308   arg1 = *(std::vector< int > **)&jarg1; 
2309   delete arg1;
2310 }
2311
2312
2313 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2314   jlong jresult = 0 ;
2315   std::vector< bool > *result = 0 ;
2316   
2317   (void)jenv;
2318   (void)jcls;
2319   result = (std::vector< bool > *)new std::vector< bool >();
2320   *(std::vector< bool > **)&jresult = result; 
2321   return jresult;
2322 }
2323
2324
2325 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2326   jlong jresult = 0 ;
2327   std::vector< bool >::size_type arg1 ;
2328   std::vector< bool > *result = 0 ;
2329   
2330   (void)jenv;
2331   (void)jcls;
2332   arg1 = (std::vector< bool >::size_type)jarg1; 
2333   result = (std::vector< bool > *)new std::vector< bool >(arg1);
2334   *(std::vector< bool > **)&jresult = result; 
2335   return jresult;
2336 }
2337
2338
2339 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2340   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2341   std::vector< bool >::size_type arg2 ;
2342   
2343   (void)jenv;
2344   (void)jcls;
2345   (void)jarg1_;
2346   arg1 = *(std::vector< bool > **)&jarg1; 
2347   arg2 = (std::vector< bool >::size_type)jarg2; 
2348   (arg1)->reserve(arg2);
2349 }
2350
2351
2352 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2353   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2354   std::vector< bool >::size_type arg2 ;
2355   
2356   (void)jenv;
2357   (void)jcls;
2358   (void)jarg1_;
2359   arg1 = *(std::vector< bool > **)&jarg1; 
2360   arg2 = (std::vector< bool >::size_type)jarg2; 
2361   (arg1)->resize(arg2);
2362 }
2363
2364
2365 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2366   jint jresult = 0 ;
2367   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2368   int result;
2369   
2370   (void)jenv;
2371   (void)jcls;
2372   (void)jarg1_;
2373   arg1 = *(std::vector< bool > **)&jarg1; 
2374   result = (int)((std::vector< bool > const *)arg1)->size();
2375   jresult = (jint)result; 
2376   return jresult;
2377 }
2378
2379
2380 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2381   jboolean jresult = 0 ;
2382   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2383   bool result;
2384   
2385   (void)jenv;
2386   (void)jcls;
2387   (void)jarg1_;
2388   arg1 = *(std::vector< bool > **)&jarg1; 
2389   result = (bool)((std::vector< bool > const *)arg1)->empty();
2390   jresult = (jboolean)result; 
2391   return jresult;
2392 }
2393
2394
2395 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2396   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2397   
2398   (void)jenv;
2399   (void)jcls;
2400   (void)jarg1_;
2401   arg1 = *(std::vector< bool > **)&jarg1; 
2402   (arg1)->clear();
2403 }
2404
2405
2406 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
2407   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2408   std::vector< bool >::value_type *arg2 = 0 ;
2409   std::vector< bool >::value_type temp2 ;
2410   
2411   (void)jenv;
2412   (void)jcls;
2413   (void)jarg1_;
2414   arg1 = *(std::vector< bool > **)&jarg1; 
2415   temp2 = jarg2 ? true : false; 
2416   arg2 = &temp2; 
2417   (arg1)->push_back((std::vector< bool >::value_type const &)*arg2);
2418 }
2419
2420
2421 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2422   jboolean jresult = 0 ;
2423   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2424   int arg2 ;
2425   bool result;
2426   
2427   (void)jenv;
2428   (void)jcls;
2429   (void)jarg1_;
2430   arg1 = *(std::vector< bool > **)&jarg1; 
2431   arg2 = (int)jarg2; 
2432   try {
2433     result = (bool)std_vector_Sl_bool_Sg__get(arg1,arg2);
2434   }
2435   catch(std::out_of_range &_e) {
2436     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2437     return 0;
2438   }
2439   
2440   jresult = (jboolean)result; 
2441   return jresult;
2442 }
2443
2444
2445 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
2446   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2447   int arg2 ;
2448   std::vector< bool >::value_type *arg3 = 0 ;
2449   std::vector< bool >::value_type temp3 ;
2450   
2451   (void)jenv;
2452   (void)jcls;
2453   (void)jarg1_;
2454   arg1 = *(std::vector< bool > **)&jarg1; 
2455   arg2 = (int)jarg2; 
2456   temp3 = jarg3 ? true : false; 
2457   arg3 = &temp3; 
2458   try {
2459     std_vector_Sl_bool_Sg__set(arg1,arg2,(bool const &)*arg3);
2460   }
2461   catch(std::out_of_range &_e) {
2462     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2463     return ;
2464   }
2465   
2466 }
2467
2468
2469 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1add_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
2470   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2471   int arg2 ;
2472   std::vector< bool >::value_type *arg3 = 0 ;
2473   std::vector< bool >::value_type temp3 ;
2474   
2475   (void)jenv;
2476   (void)jcls;
2477   (void)jarg1_;
2478   arg1 = *(std::vector< bool > **)&jarg1; 
2479   arg2 = (int)jarg2; 
2480   temp3 = jarg3 ? true : false; 
2481   arg3 = &temp3; 
2482   try {
2483     std_vector_Sl_bool_Sg__add__SWIG_1(arg1,arg2,(bool const &)*arg3);
2484   }
2485   catch(std::out_of_range &_e) {
2486     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2487     return ;
2488   }
2489   
2490 }
2491
2492
2493 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
2494   jboolean jresult = 0 ;
2495   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2496   std::vector< bool >::value_type *arg2 = 0 ;
2497   std::vector< bool >::value_type temp2 ;
2498   bool result;
2499   
2500   (void)jenv;
2501   (void)jcls;
2502   (void)jarg1_;
2503   arg1 = *(std::vector< bool > **)&jarg1; 
2504   temp2 = jarg2 ? true : false; 
2505   arg2 = &temp2; 
2506   result = (bool)std_vector_Sl_bool_Sg__remove(arg1,(bool const &)*arg2);
2507   jresult = (jboolean)result; 
2508   return jresult;
2509 }
2510
2511
2512 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfBool(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2513   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2514   
2515   (void)jenv;
2516   (void)jcls;
2517   arg1 = *(std::vector< bool > **)&jarg1; 
2518   delete arg1;
2519 }
2520
2521
2522 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2523   jlong jresult = 0 ;
2524   std::vector< double > *result = 0 ;
2525   
2526   (void)jenv;
2527   (void)jcls;
2528   result = (std::vector< double > *)new std::vector< double >();
2529   *(std::vector< double > **)&jresult = result; 
2530   return jresult;
2531 }
2532
2533
2534 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2535   jlong jresult = 0 ;
2536   std::vector< double >::size_type arg1 ;
2537   std::vector< double > *result = 0 ;
2538   
2539   (void)jenv;
2540   (void)jcls;
2541   arg1 = (std::vector< double >::size_type)jarg1; 
2542   result = (std::vector< double > *)new std::vector< double >(arg1);
2543   *(std::vector< double > **)&jresult = result; 
2544   return jresult;
2545 }
2546
2547
2548 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2549   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2550   std::vector< double >::size_type arg2 ;
2551   
2552   (void)jenv;
2553   (void)jcls;
2554   (void)jarg1_;
2555   arg1 = *(std::vector< double > **)&jarg1; 
2556   arg2 = (std::vector< double >::size_type)jarg2; 
2557   (arg1)->reserve(arg2);
2558 }
2559
2560
2561 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2562   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2563   std::vector< double >::size_type arg2 ;
2564   
2565   (void)jenv;
2566   (void)jcls;
2567   (void)jarg1_;
2568   arg1 = *(std::vector< double > **)&jarg1; 
2569   arg2 = (std::vector< double >::size_type)jarg2; 
2570   (arg1)->resize(arg2);
2571 }
2572
2573
2574 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2575   jint jresult = 0 ;
2576   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2577   int result;
2578   
2579   (void)jenv;
2580   (void)jcls;
2581   (void)jarg1_;
2582   arg1 = *(std::vector< double > **)&jarg1; 
2583   result = (int)((std::vector< double > const *)arg1)->size();
2584   jresult = (jint)result; 
2585   return jresult;
2586 }
2587
2588
2589 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2590   jboolean jresult = 0 ;
2591   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2592   bool result;
2593   
2594   (void)jenv;
2595   (void)jcls;
2596   (void)jarg1_;
2597   arg1 = *(std::vector< double > **)&jarg1; 
2598   result = (bool)((std::vector< double > const *)arg1)->empty();
2599   jresult = (jboolean)result; 
2600   return jresult;
2601 }
2602
2603
2604 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2605   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2606   
2607   (void)jenv;
2608   (void)jcls;
2609   (void)jarg1_;
2610   arg1 = *(std::vector< double > **)&jarg1; 
2611   (arg1)->clear();
2612 }
2613
2614
2615 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2616   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2617   std::vector< double >::value_type *arg2 = 0 ;
2618   std::vector< double >::value_type temp2 ;
2619   
2620   (void)jenv;
2621   (void)jcls;
2622   (void)jarg1_;
2623   arg1 = *(std::vector< double > **)&jarg1; 
2624   temp2 = (std::vector< double >::value_type)jarg2; 
2625   arg2 = &temp2; 
2626   (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
2627 }
2628
2629
2630 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2631   jboolean jresult = 0 ;
2632   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2633   double *arg2 = 0 ;
2634   double temp2 ;
2635   bool result;
2636   
2637   (void)jenv;
2638   (void)jcls;
2639   (void)jarg1_;
2640   arg1 = *(std::vector< double > **)&jarg1; 
2641   temp2 = (double)jarg2; 
2642   arg2 = &temp2; 
2643   result = (bool)std_vector_Sl_double_Sg__contains(arg1,(double const &)*arg2);
2644   jresult = (jboolean)result; 
2645   return jresult;
2646 }
2647
2648
2649 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2650   jint jresult = 0 ;
2651   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2652   double *arg2 = 0 ;
2653   double temp2 ;
2654   int result;
2655   
2656   (void)jenv;
2657   (void)jcls;
2658   (void)jarg1_;
2659   arg1 = *(std::vector< double > **)&jarg1; 
2660   temp2 = (double)jarg2; 
2661   arg2 = &temp2; 
2662   result = (int)std_vector_Sl_double_Sg__indexOf(arg1,(double const &)*arg2);
2663   jresult = (jint)result; 
2664   return jresult;
2665 }
2666
2667
2668 SWIGEXPORT jdouble JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2669   jdouble jresult = 0 ;
2670   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2671   int arg2 ;
2672   std::vector< double >::value_type *result = 0 ;
2673   
2674   (void)jenv;
2675   (void)jcls;
2676   (void)jarg1_;
2677   arg1 = *(std::vector< double > **)&jarg1; 
2678   arg2 = (int)jarg2; 
2679   try {
2680     result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__get(arg1,arg2);
2681   }
2682   catch(std::out_of_range &_e) {
2683     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2684     return 0;
2685   }
2686   
2687   jresult = (jdouble)*result; 
2688   return jresult;
2689 }
2690
2691
2692 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) {
2693   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2694   int arg2 ;
2695   std::vector< double >::value_type *arg3 = 0 ;
2696   std::vector< double >::value_type temp3 ;
2697   
2698   (void)jenv;
2699   (void)jcls;
2700   (void)jarg1_;
2701   arg1 = *(std::vector< double > **)&jarg1; 
2702   arg2 = (int)jarg2; 
2703   temp3 = (std::vector< double >::value_type)jarg3; 
2704   arg3 = &temp3; 
2705   try {
2706     std_vector_Sl_double_Sg__set(arg1,arg2,(double const &)*arg3);
2707   }
2708   catch(std::out_of_range &_e) {
2709     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2710     return ;
2711   }
2712   
2713 }
2714
2715
2716 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1add_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) {
2717   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2718   int arg2 ;
2719   std::vector< double >::value_type *arg3 = 0 ;
2720   std::vector< double >::value_type temp3 ;
2721   
2722   (void)jenv;
2723   (void)jcls;
2724   (void)jarg1_;
2725   arg1 = *(std::vector< double > **)&jarg1; 
2726   arg2 = (int)jarg2; 
2727   temp3 = (std::vector< double >::value_type)jarg3; 
2728   arg3 = &temp3; 
2729   try {
2730     std_vector_Sl_double_Sg__add__SWIG_1(arg1,arg2,(double const &)*arg3);
2731   }
2732   catch(std::out_of_range &_e) {
2733     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2734     return ;
2735   }
2736   
2737 }
2738
2739
2740 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2741   jboolean jresult = 0 ;
2742   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2743   std::vector< double >::value_type *arg2 = 0 ;
2744   std::vector< double >::value_type temp2 ;
2745   bool result;
2746   
2747   (void)jenv;
2748   (void)jcls;
2749   (void)jarg1_;
2750   arg1 = *(std::vector< double > **)&jarg1; 
2751   temp2 = (std::vector< double >::value_type)jarg2; 
2752   arg2 = &temp2; 
2753   result = (bool)std_vector_Sl_double_Sg__remove(arg1,(double const &)*arg2);
2754   jresult = (jboolean)result; 
2755   return jresult;
2756 }
2757
2758
2759 SWIGEXPORT jobject JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1asByteBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2760   jobject jresult = 0 ;
2761   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2762   int arg2 ;
2763   int arg3 ;
2764   void *result = 0 ;
2765   
2766   (void)jenv;
2767   (void)jcls;
2768   (void)jarg1_;
2769   arg1 = *(std::vector< double > **)&jarg1; 
2770   arg2 = (int)jarg2; 
2771   arg3 = (int)jarg3; 
2772   result = (void *)std_vector_Sl_double_Sg__asByteBuffer(arg1,arg2,arg3);
2773   {
2774     if (arg3 <= 0) {
2775       arg3 = arg1->size() - arg2;
2776     } else if (arg1->size() < arg3) {
2777       throw std::out_of_range("vector index out of range");
2778     }
2779     jresult = jenv->NewDirectByteBuffer(result, arg3 * sizeof(decltype(arg1->back())));
2780   }
2781   return jresult;
2782 }
2783
2784
2785 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfDouble(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2786   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2787   
2788   (void)jenv;
2789   (void)jcls;
2790   arg1 = *(std::vector< double > **)&jarg1; 
2791   delete arg1;
2792 }
2793
2794
2795 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2796   jlong jresult = 0 ;
2797   std::vector< std::string > *result = 0 ;
2798   
2799   (void)jenv;
2800   (void)jcls;
2801   result = (std::vector< std::string > *)new std::vector< std::string >();
2802   *(std::vector< std::string > **)&jresult = result; 
2803   return jresult;
2804 }
2805
2806
2807 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2808   jlong jresult = 0 ;
2809   std::vector< std::string >::size_type arg1 ;
2810   std::vector< std::string > *result = 0 ;
2811   
2812   (void)jenv;
2813   (void)jcls;
2814   arg1 = (std::vector< std::string >::size_type)jarg1; 
2815   result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
2816   *(std::vector< std::string > **)&jresult = result; 
2817   return jresult;
2818 }
2819
2820
2821 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2822   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2823   std::vector< std::string >::size_type arg2 ;
2824   
2825   (void)jenv;
2826   (void)jcls;
2827   (void)jarg1_;
2828   arg1 = *(std::vector< std::string > **)&jarg1; 
2829   arg2 = (std::vector< std::string >::size_type)jarg2; 
2830   (arg1)->reserve(arg2);
2831 }
2832
2833
2834 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2835   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2836   std::vector< std::string >::size_type arg2 ;
2837   
2838   (void)jenv;
2839   (void)jcls;
2840   (void)jarg1_;
2841   arg1 = *(std::vector< std::string > **)&jarg1; 
2842   arg2 = (std::vector< std::string >::size_type)jarg2; 
2843   (arg1)->resize(arg2);
2844 }
2845
2846
2847 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2848   jint jresult = 0 ;
2849   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2850   int result;
2851   
2852   (void)jenv;
2853   (void)jcls;
2854   (void)jarg1_;
2855   arg1 = *(std::vector< std::string > **)&jarg1; 
2856   result = (int)((std::vector< std::string > const *)arg1)->size();
2857   jresult = (jint)result; 
2858   return jresult;
2859 }
2860
2861
2862 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2863   jboolean jresult = 0 ;
2864   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2865   bool result;
2866   
2867   (void)jenv;
2868   (void)jcls;
2869   (void)jarg1_;
2870   arg1 = *(std::vector< std::string > **)&jarg1; 
2871   result = (bool)((std::vector< std::string > const *)arg1)->empty();
2872   jresult = (jboolean)result; 
2873   return jresult;
2874 }
2875
2876
2877 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2878   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2879   
2880   (void)jenv;
2881   (void)jcls;
2882   (void)jarg1_;
2883   arg1 = *(std::vector< std::string > **)&jarg1; 
2884   (arg1)->clear();
2885 }
2886
2887
2888 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2889   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2890   std::vector< std::string >::value_type *arg2 = 0 ;
2891   
2892   (void)jenv;
2893   (void)jcls;
2894   (void)jarg1_;
2895   arg1 = *(std::vector< std::string > **)&jarg1; 
2896   Swig::JavaString javaString(jenv, jarg2);
2897   std::string arg2_str(javaString.c_str());
2898   arg2 = &arg2_str;
2899   (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
2900   
2901 }
2902
2903
2904 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2905   jboolean jresult = 0 ;
2906   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2907   std::string *arg2 = 0 ;
2908   bool result;
2909   
2910   (void)jenv;
2911   (void)jcls;
2912   (void)jarg1_;
2913   arg1 = *(std::vector< std::string > **)&jarg1; 
2914   Swig::JavaString javaString(jenv, jarg2);
2915   std::string arg2_str(javaString.c_str());
2916   arg2 = &arg2_str;
2917   result = (bool)std_vector_Sl_std_string_Sg__contains(arg1,(std::string const &)*arg2);
2918   jresult = (jboolean)result; 
2919   
2920   return jresult;
2921 }
2922
2923
2924 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2925   jint jresult = 0 ;
2926   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2927   std::string *arg2 = 0 ;
2928   int result;
2929   
2930   (void)jenv;
2931   (void)jcls;
2932   (void)jarg1_;
2933   arg1 = *(std::vector< std::string > **)&jarg1; 
2934   Swig::JavaString javaString(jenv, jarg2);
2935   std::string arg2_str(javaString.c_str());
2936   arg2 = &arg2_str;
2937   result = (int)std_vector_Sl_std_string_Sg__indexOf(arg1,(std::string const &)*arg2);
2938   jresult = (jint)result; 
2939   
2940   return jresult;
2941 }
2942
2943
2944 SWIGEXPORT jstring JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2945   jstring jresult = 0 ;
2946   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2947   int arg2 ;
2948   std::vector< std::string >::value_type *result = 0 ;
2949   
2950   (void)jenv;
2951   (void)jcls;
2952   (void)jarg1_;
2953   arg1 = *(std::vector< std::string > **)&jarg1; 
2954   arg2 = (int)jarg2; 
2955   try {
2956     result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__get(arg1,arg2);
2957   }
2958   catch(std::out_of_range &_e) {
2959     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2960     return 0;
2961   }
2962   
2963   jresult = jenv->NewStringUTF(result->c_str()); 
2964   return jresult;
2965 }
2966
2967
2968 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
2969   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2970   int arg2 ;
2971   std::vector< std::string >::value_type *arg3 = 0 ;
2972   
2973   (void)jenv;
2974   (void)jcls;
2975   (void)jarg1_;
2976   arg1 = *(std::vector< std::string > **)&jarg1; 
2977   arg2 = (int)jarg2; 
2978   Swig::JavaString javaString(jenv, jarg3);
2979   std::string arg3_str(javaString.c_str());
2980   arg3 = &arg3_str;
2981   try {
2982     std_vector_Sl_std_string_Sg__set(arg1,arg2,(std::string const &)*arg3);
2983   }
2984   catch(std::out_of_range &_e) {
2985     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2986     return ;
2987   }
2988   
2989   
2990 }
2991
2992
2993 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1add_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
2994   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2995   int arg2 ;
2996   std::vector< std::string >::value_type *arg3 = 0 ;
2997   
2998   (void)jenv;
2999   (void)jcls;
3000   (void)jarg1_;
3001   arg1 = *(std::vector< std::string > **)&jarg1; 
3002   arg2 = (int)jarg2; 
3003   Swig::JavaString javaString(jenv, jarg3);
3004   std::string arg3_str(javaString.c_str());
3005   arg3 = &arg3_str;
3006   try {
3007     std_vector_Sl_std_string_Sg__add__SWIG_1(arg1,arg2,(std::string const &)*arg3);
3008   }
3009   catch(std::out_of_range &_e) {
3010     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3011     return ;
3012   }
3013   
3014   
3015 }
3016
3017
3018 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
3019   jboolean jresult = 0 ;
3020   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
3021   std::vector< std::string >::value_type *arg2 = 0 ;
3022   bool result;
3023   
3024   (void)jenv;
3025   (void)jcls;
3026   (void)jarg1_;
3027   arg1 = *(std::vector< std::string > **)&jarg1; 
3028   Swig::JavaString javaString(jenv, jarg2);
3029   std::string arg2_str(javaString.c_str());
3030   arg2 = &arg2_str;
3031   result = (bool)std_vector_Sl_std_string_Sg__remove(arg1,(std::string const &)*arg2);
3032   jresult = (jboolean)result; 
3033   
3034   return jresult;
3035 }
3036
3037
3038 SWIGEXPORT jobject JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1asByteBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
3039   jobject jresult = 0 ;
3040   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
3041   int arg2 ;
3042   int arg3 ;
3043   void *result = 0 ;
3044   
3045   (void)jenv;
3046   (void)jcls;
3047   (void)jarg1_;
3048   arg1 = *(std::vector< std::string > **)&jarg1; 
3049   arg2 = (int)jarg2; 
3050   arg3 = (int)jarg3; 
3051   result = (void *)std_vector_Sl_std_string_Sg__asByteBuffer(arg1,arg2,arg3);
3052   {
3053     if (arg3 <= 0) {
3054       arg3 = arg1->size() - arg2;
3055     } else if (arg1->size() < arg3) {
3056       throw std::out_of_range("vector index out of range");
3057     }
3058     jresult = jenv->NewDirectByteBuffer(result, arg3 * sizeof(decltype(arg1->back())));
3059   }
3060   return jresult;
3061 }
3062
3063
3064 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfString(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3065   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
3066   
3067   (void)jenv;
3068   (void)jcls;
3069   arg1 = *(std::vector< std::string > **)&jarg1; 
3070   delete arg1;
3071 }
3072
3073
3074 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
3075   jlong jresult = 0 ;
3076   std::vector< ScicosID > *result = 0 ;
3077   
3078   (void)jenv;
3079   (void)jcls;
3080   result = (std::vector< ScicosID > *)new std::vector< ScicosID >();
3081   *(std::vector< ScicosID > **)&jresult = result; 
3082   return jresult;
3083 }
3084
3085
3086 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3087   jlong jresult = 0 ;
3088   std::vector< long long >::size_type arg1 ;
3089   std::vector< ScicosID > *result = 0 ;
3090   
3091   (void)jenv;
3092   (void)jcls;
3093   arg1 = (std::vector< long long >::size_type)jarg1; 
3094   result = (std::vector< ScicosID > *)new std::vector< ScicosID >(arg1);
3095   *(std::vector< ScicosID > **)&jresult = result; 
3096   return jresult;
3097 }
3098
3099
3100 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3101   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3102   std::vector< long long >::size_type arg2 ;
3103   
3104   (void)jenv;
3105   (void)jcls;
3106   (void)jarg1_;
3107   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3108   arg2 = (std::vector< long long >::size_type)jarg2; 
3109   (arg1)->reserve(arg2);
3110 }
3111
3112
3113 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3114   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3115   std::vector< long long >::size_type arg2 ;
3116   
3117   (void)jenv;
3118   (void)jcls;
3119   (void)jarg1_;
3120   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3121   arg2 = (std::vector< long long >::size_type)jarg2; 
3122   (arg1)->resize(arg2);
3123 }
3124
3125
3126 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3127   jint jresult = 0 ;
3128   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3129   int result;
3130   
3131   (void)jenv;
3132   (void)jcls;
3133   (void)jarg1_;
3134   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3135   result = (int)((std::vector< ScicosID > const *)arg1)->size();
3136   jresult = (jint)result; 
3137   return jresult;
3138 }
3139
3140
3141 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3142   jboolean jresult = 0 ;
3143   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3144   bool result;
3145   
3146   (void)jenv;
3147   (void)jcls;
3148   (void)jarg1_;
3149   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3150   result = (bool)((std::vector< ScicosID > const *)arg1)->empty();
3151   jresult = (jboolean)result; 
3152   return jresult;
3153 }
3154
3155
3156 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3157   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3158   
3159   (void)jenv;
3160   (void)jcls;
3161   (void)jarg1_;
3162   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3163   (arg1)->clear();
3164 }
3165
3166
3167 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3168   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3169   std::vector< long long >::value_type *arg2 = 0 ;
3170   std::vector< long long >::value_type temp2 ;
3171   
3172   (void)jenv;
3173   (void)jcls;
3174   (void)jarg1_;
3175   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3176   temp2 = (std::vector< long long >::value_type)jarg2; 
3177   arg2 = &temp2; 
3178   (arg1)->push_back((std::vector< long long >::value_type const &)*arg2);
3179 }
3180
3181
3182 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3183   jboolean jresult = 0 ;
3184   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3185   long long *arg2 = 0 ;
3186   long long temp2 ;
3187   bool result;
3188   
3189   (void)jenv;
3190   (void)jcls;
3191   (void)jarg1_;
3192   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3193   temp2 = (long long)jarg2; 
3194   arg2 = &temp2; 
3195   result = (bool)std_vector_Sl_ScicosID_Sg__contains(arg1,(long long const &)*arg2);
3196   jresult = (jboolean)result; 
3197   return jresult;
3198 }
3199
3200
3201 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3202   jint jresult = 0 ;
3203   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3204   long long *arg2 = 0 ;
3205   long long temp2 ;
3206   int result;
3207   
3208   (void)jenv;
3209   (void)jcls;
3210   (void)jarg1_;
3211   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3212   temp2 = (long long)jarg2; 
3213   arg2 = &temp2; 
3214   result = (int)std_vector_Sl_ScicosID_Sg__indexOf(arg1,(long long const &)*arg2);
3215   jresult = (jint)result; 
3216   return jresult;
3217 }
3218
3219
3220 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3221   jlong jresult = 0 ;
3222   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3223   int arg2 ;
3224   std::vector< long long >::value_type *result = 0 ;
3225   
3226   (void)jenv;
3227   (void)jcls;
3228   (void)jarg1_;
3229   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3230   arg2 = (int)jarg2; 
3231   try {
3232     result = (std::vector< long long >::value_type *) &std_vector_Sl_ScicosID_Sg__get(arg1,arg2);
3233   }
3234   catch(std::out_of_range &_e) {
3235     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3236     return 0;
3237   }
3238   
3239   jresult = (jlong)*result; 
3240   return jresult;
3241 }
3242
3243
3244 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
3245   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3246   int arg2 ;
3247   std::vector< long long >::value_type *arg3 = 0 ;
3248   std::vector< long long >::value_type temp3 ;
3249   
3250   (void)jenv;
3251   (void)jcls;
3252   (void)jarg1_;
3253   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3254   arg2 = (int)jarg2; 
3255   temp3 = (std::vector< long long >::value_type)jarg3; 
3256   arg3 = &temp3; 
3257   try {
3258     std_vector_Sl_ScicosID_Sg__set(arg1,arg2,(long long const &)*arg3);
3259   }
3260   catch(std::out_of_range &_e) {
3261     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3262     return ;
3263   }
3264   
3265 }
3266
3267
3268 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1add_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
3269   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3270   int arg2 ;
3271   std::vector< long long >::value_type *arg3 = 0 ;
3272   std::vector< long long >::value_type temp3 ;
3273   
3274   (void)jenv;
3275   (void)jcls;
3276   (void)jarg1_;
3277   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3278   arg2 = (int)jarg2; 
3279   temp3 = (std::vector< long long >::value_type)jarg3; 
3280   arg3 = &temp3; 
3281   try {
3282     std_vector_Sl_ScicosID_Sg__add__SWIG_1(arg1,arg2,(long long const &)*arg3);
3283   }
3284   catch(std::out_of_range &_e) {
3285     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3286     return ;
3287   }
3288   
3289 }
3290
3291
3292 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3293   jboolean jresult = 0 ;
3294   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3295   std::vector< long long >::value_type *arg2 = 0 ;
3296   std::vector< long long >::value_type temp2 ;
3297   bool result;
3298   
3299   (void)jenv;
3300   (void)jcls;
3301   (void)jarg1_;
3302   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3303   temp2 = (std::vector< long long >::value_type)jarg2; 
3304   arg2 = &temp2; 
3305   result = (bool)std_vector_Sl_ScicosID_Sg__remove(arg1,(long long const &)*arg2);
3306   jresult = (jboolean)result; 
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT jobject JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1asByteBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
3312   jobject jresult = 0 ;
3313   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3314   int arg2 ;
3315   int arg3 ;
3316   void *result = 0 ;
3317   
3318   (void)jenv;
3319   (void)jcls;
3320   (void)jarg1_;
3321   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3322   arg2 = (int)jarg2; 
3323   arg3 = (int)jarg3; 
3324   result = (void *)std_vector_Sl_ScicosID_Sg__asByteBuffer(arg1,arg2,arg3);
3325   {
3326     if (arg3 <= 0) {
3327       arg3 = arg1->size() - arg2;
3328     } else if (arg1->size() < arg3) {
3329       throw std::out_of_range("vector index out of range");
3330     }
3331     jresult = jenv->NewDirectByteBuffer(result, arg3 * sizeof(decltype(arg1->back())));
3332   }
3333   return jresult;
3334 }
3335
3336
3337 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfScicosID(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3338   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3339   
3340   (void)jenv;
3341   (void)jcls;
3342   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3343   delete arg1;
3344 }
3345
3346
3347 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_register_1view(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
3348   std::string *arg1 = 0 ;
3349   org_scilab_modules_scicos::View *arg2 = (org_scilab_modules_scicos::View *) 0 ;
3350   
3351   (void)jenv;
3352   (void)jcls;
3353   (void)jarg2_;
3354   Swig::JavaString javaString(jenv, jarg1);
3355   std::string arg1_str(javaString.c_str());
3356   arg1 = &arg1_str;
3357   arg2 = *(org_scilab_modules_scicos::View **)&jarg2; 
3358   register_view((std::string const &)*arg1,arg2);
3359   
3360 }
3361
3362
3363 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_unregister_1view(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3364   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
3365   
3366   (void)jenv;
3367   (void)jcls;
3368   (void)jarg1_;
3369   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
3370   unregister_view(arg1);
3371 }
3372
3373
3374 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) {
3375   int i;
3376   
3377   static struct {
3378     const char *method;
3379     const char *signature;
3380   } methods[5] = {
3381     {
3382       "SwigDirector_View_objectCreated", "(Lorg/scilab/modules/xcos/View;JI)V" 
3383     },
3384     {
3385       "SwigDirector_View_objectReferenced", "(Lorg/scilab/modules/xcos/View;JIJ)V" 
3386     },
3387     {
3388       "SwigDirector_View_objectUnreferenced", "(Lorg/scilab/modules/xcos/View;JIJ)V" 
3389     },
3390     {
3391       "SwigDirector_View_objectDeleted", "(Lorg/scilab/modules/xcos/View;JI)V" 
3392     },
3393     {
3394       "SwigDirector_View_propertyUpdated", "(Lorg/scilab/modules/xcos/View;JIII)V" 
3395     }
3396   };
3397   Swig::jclass_JavaControllerJNI = (jclass) jenv->NewGlobalRef(jcls);
3398   if (!Swig::jclass_JavaControllerJNI) return;
3399   for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {
3400     Swig::director_method_ids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);
3401     if (!Swig::director_method_ids[i]) return;
3402   }
3403 }
3404
3405
3406 #ifdef __cplusplus
3407 }
3408 #endif
3409