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