c170912148754a32d22a78639c0c5a24fc2c0d58
[scilab.git] / scilab / modules / xcos / src / jni / JavaController_wrap.cxx
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 3.0.7
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10
11 #define SWIGJAVA
12 #define SWIG_DIRECTORS
13
14
15 #ifdef __cplusplus
16 /* SwigValueWrapper is described in swig.swg */
17 template<typename T> class SwigValueWrapper {
18   struct SwigMovePointer {
19     T *ptr;
20     SwigMovePointer(T *p) : ptr(p) { }
21     ~SwigMovePointer() { delete ptr; }
22     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
23   } pointer;
24   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
26 public:
27   SwigValueWrapper() : pointer(0) { }
28   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
29   operator T&() const { return *pointer.ptr; }
30   T *operator&() { return pointer.ptr; }
31 };
32
33 template <typename T> T SwigValueInit() {
34   return T();
35 }
36 #endif
37
38 /* -----------------------------------------------------------------------------
39  *  This section contains generic SWIG labels for method/variable
40  *  declarations/attributes, and other compiler dependent labels.
41  * ----------------------------------------------------------------------------- */
42
43 /* template workaround for compilers that cannot correctly implement the C++ standard */
44 #ifndef SWIGTEMPLATEDISAMBIGUATOR
45 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
46 #  define SWIGTEMPLATEDISAMBIGUATOR template
47 # elif defined(__HP_aCC)
48 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
49 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
50 #  define SWIGTEMPLATEDISAMBIGUATOR template
51 # else
52 #  define SWIGTEMPLATEDISAMBIGUATOR
53 # endif
54 #endif
55
56 /* inline attribute */
57 #ifndef SWIGINLINE
58 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
59 #   define SWIGINLINE inline
60 # else
61 #   define SWIGINLINE
62 # endif
63 #endif
64
65 /* attribute recognised by some compilers to avoid 'unused' warnings */
66 #ifndef SWIGUNUSED
67 # if defined(__GNUC__)
68 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
69 #     define SWIGUNUSED __attribute__ ((__unused__))
70 #   else
71 #     define SWIGUNUSED
72 #   endif
73 # elif defined(__ICC)
74 #   define SWIGUNUSED __attribute__ ((__unused__))
75 # else
76 #   define SWIGUNUSED
77 # endif
78 #endif
79
80 #ifndef SWIG_MSC_UNSUPPRESS_4505
81 # if defined(_MSC_VER)
82 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
83 # endif
84 #endif
85
86 #ifndef SWIGUNUSEDPARM
87 # ifdef __cplusplus
88 #   define SWIGUNUSEDPARM(p)
89 # else
90 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
91 # endif
92 #endif
93
94 /* internal SWIG method */
95 #ifndef SWIGINTERN
96 # define SWIGINTERN static SWIGUNUSED
97 #endif
98
99 /* internal inline SWIG method */
100 #ifndef SWIGINTERNINLINE
101 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
102 #endif
103
104 /* exporting methods */
105 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
106 #  ifndef GCC_HASCLASSVISIBILITY
107 #    define GCC_HASCLASSVISIBILITY
108 #  endif
109 #endif
110
111 #ifndef SWIGEXPORT
112 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
113 #   if defined(STATIC_LINKED)
114 #     define SWIGEXPORT
115 #   else
116 #     define SWIGEXPORT __declspec(dllexport)
117 #   endif
118 # else
119 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
120 #     define SWIGEXPORT __attribute__ ((visibility("default")))
121 #   else
122 #     define SWIGEXPORT
123 #   endif
124 # endif
125 #endif
126
127 /* calling conventions for Windows */
128 #ifndef SWIGSTDCALL
129 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
130 #   define SWIGSTDCALL __stdcall
131 # else
132 #   define SWIGSTDCALL
133 # endif
134 #endif
135
136 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
137 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
138 # define _CRT_SECURE_NO_DEPRECATE
139 #endif
140
141 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
142 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
143 # define _SCL_SECURE_NO_DEPRECATE
144 #endif
145
146 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
147 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
148 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
149 #endif
150
151 /* Intel's compiler complains if a variable which was never initialised is
152  * cast to void, which is a common idiom which we use to indicate that we
153  * are aware a variable isn't used.  So we just silence that warning.
154  * See: https://github.com/swig/swig/issues/192 for more discussion.
155  */
156 #ifdef __INTEL_COMPILER
157 # pragma warning disable 592
158 #endif
159
160
161 /* Fix for jlong on some versions of gcc on Windows */
162 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
163   typedef long long __int64;
164 #endif
165
166 /* Fix for jlong on 64-bit x86 Solaris */
167 #if defined(__x86_64)
168 # ifdef _LP64
169 #   undef _LP64
170 # endif
171 #endif
172
173 #include <jni.h>
174 #include <stdlib.h>
175 #include <string.h>
176
177
178 /* Support for throwing Java exceptions */
179 typedef enum {
180   SWIG_JavaOutOfMemoryError = 1, 
181   SWIG_JavaIOException, 
182   SWIG_JavaRuntimeException, 
183   SWIG_JavaIndexOutOfBoundsException,
184   SWIG_JavaArithmeticException,
185   SWIG_JavaIllegalArgumentException,
186   SWIG_JavaNullPointerException,
187   SWIG_JavaDirectorPureVirtual,
188   SWIG_JavaUnknownError
189 } SWIG_JavaExceptionCodes;
190
191 typedef struct {
192   SWIG_JavaExceptionCodes code;
193   const char *java_exception;
194 } SWIG_JavaExceptions_t;
195
196
197 static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
198   jclass excep;
199   static const SWIG_JavaExceptions_t java_exceptions[] = {
200     { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
201     { SWIG_JavaIOException, "java/io/IOException" },
202     { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
203     { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
204     { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
205     { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
206     { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
207     { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
208     { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
209     { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
210   };
211   const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
212
213   while (except_ptr->code != code && except_ptr->code)
214     except_ptr++;
215
216   jenv->ExceptionClear();
217   excep = jenv->FindClass(except_ptr->java_exception);
218   if (excep)
219     jenv->ThrowNew(excep, msg);
220 }
221
222
223 /* Contract support */
224
225 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else
226
227 /* -----------------------------------------------------------------------------
228  * director_common.swg
229  *
230  * This file contains support for director classes which is common between
231  * languages.
232  * ----------------------------------------------------------------------------- */
233
234 /*
235   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
236   'Swig' namespace. This could be useful for multi-modules projects.
237 */
238 #ifdef SWIG_DIRECTOR_STATIC
239 /* Force anonymous (static) namespace */
240 #define Swig
241 #endif
242 /* -----------------------------------------------------------------------------
243  * director.swg
244  *
245  * This file contains support for director classes so that Java proxy
246  * methods can be called from C++.
247  * ----------------------------------------------------------------------------- */
248
249 #if defined(DEBUG_DIRECTOR_OWNED) || defined(DEBUG_DIRECTOR_EXCEPTION)
250 #include <iostream>
251 #endif
252
253 #include <exception>
254
255 namespace Swig {
256
257   /* Java object wrapper */
258   class JObjectWrapper {
259   public:
260     JObjectWrapper() : jthis_(NULL), weak_global_(true) {
261     }
262
263     ~JObjectWrapper() {
264       jthis_ = NULL;
265       weak_global_ = true;
266     }
267
268     bool set(JNIEnv *jenv, jobject jobj, bool mem_own, bool weak_global) {
269       if (!jthis_) {
270         weak_global_ = weak_global || !mem_own; // hold as weak global if explicitly requested or not owned
271         if (jobj)
272           jthis_ = weak_global_ ? jenv->NewWeakGlobalRef(jobj) : jenv->NewGlobalRef(jobj);
273 #if defined(DEBUG_DIRECTOR_OWNED)
274         std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> " << jthis_ << std::endl;
275 #endif
276         return true;
277       } else {
278 #if defined(DEBUG_DIRECTOR_OWNED)
279         std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> already set" << std::endl;
280 #endif
281         return false;
282       }
283     }
284
285     jobject get(JNIEnv *jenv) const {
286 #if defined(DEBUG_DIRECTOR_OWNED)
287       std::cout << "JObjectWrapper::get(";
288       if (jthis_)
289         std::cout << jthis_;
290       else
291         std::cout << "null";
292       std::cout << ") -> return new local ref" << std::endl;
293 #endif
294       return (jthis_ ? jenv->NewLocalRef(jthis_) : jthis_);
295     }
296
297     void release(JNIEnv *jenv) {
298 #if defined(DEBUG_DIRECTOR_OWNED)
299       std::cout << "JObjectWrapper::release(" << jthis_ << "): " << (weak_global_ ? "weak global ref" : "global ref") << std::endl;
300 #endif
301       if (jthis_) {
302         if (weak_global_) {
303           if (jenv->IsSameObject(jthis_, NULL) == JNI_FALSE)
304             jenv->DeleteWeakGlobalRef((jweak)jthis_);
305         } else
306           jenv->DeleteGlobalRef(jthis_);
307       }
308
309       jthis_ = NULL;
310       weak_global_ = true;
311     }
312
313     /* Only call peek if you know what you are doing wrt to weak/global references */
314     jobject peek() {
315       return jthis_;
316     }
317
318     /* Java proxy releases ownership of C++ object, C++ object is now
319        responsible for destruction (creates NewGlobalRef to pin Java proxy) */
320     void java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
321       if (take_or_release) {  /* Java takes ownership of C++ object's lifetime. */
322         if (!weak_global_) {
323           jenv->DeleteGlobalRef(jthis_);
324           jthis_ = jenv->NewWeakGlobalRef(jself);
325           weak_global_ = true;
326         }
327       } else {
328         /* Java releases ownership of C++ object's lifetime */
329         if (weak_global_) {
330           jenv->DeleteWeakGlobalRef((jweak)jthis_);
331           jthis_ = jenv->NewGlobalRef(jself);
332           weak_global_ = false;
333         }
334       }
335     }
336
337   private:
338     /* pointer to Java object */
339     jobject jthis_;
340     /* Local or global reference flag */
341     bool weak_global_;
342   };
343
344   /* Local JNI reference deleter */
345   class LocalRefGuard {
346     JNIEnv *jenv_;
347     jobject jobj_;
348
349     // non-copyable
350     LocalRefGuard(const LocalRefGuard &);
351     LocalRefGuard &operator=(const LocalRefGuard &);
352   public:
353     LocalRefGuard(JNIEnv *jenv, jobject jobj): jenv_(jenv), jobj_(jobj) {}
354     ~LocalRefGuard() {
355       if (jobj_)
356         jenv_->DeleteLocalRef(jobj_);
357     }
358   };
359
360   /* director base class */
361   class Director {
362     /* pointer to Java virtual machine */
363     JavaVM *swig_jvm_;
364
365   protected:
366 #if defined (_MSC_VER) && (_MSC_VER<1300)
367     class JNIEnvWrapper;
368     friend class JNIEnvWrapper;
369 #endif
370     /* Utility class for managing the JNI environment */
371     class JNIEnvWrapper {
372       const Director *director_;
373       JNIEnv *jenv_;
374       int env_status;
375     public:
376       JNIEnvWrapper(const Director *director) : director_(director), jenv_(0), env_status(0) {
377 #if defined(__ANDROID__)
378         JNIEnv **jenv = &jenv_;
379 #else
380         void **jenv = (void **)&jenv_;
381 #endif
382         env_status = director_->swig_jvm_->GetEnv((void **)&jenv_, JNI_VERSION_1_2);
383 #if defined(SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON)
384         // Attach a daemon thread to the JVM. Useful when the JVM should not wait for
385         // the thread to exit upon shutdown. Only for jdk-1.4 and later.
386         director_->swig_jvm_->AttachCurrentThreadAsDaemon(jenv, NULL);
387 #else
388         director_->swig_jvm_->AttachCurrentThread(jenv, NULL);
389 #endif
390       }
391       ~JNIEnvWrapper() {
392 #if !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD)
393         // Some JVMs, eg jdk-1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call.
394         // However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak.
395         if (env_status == JNI_EDETACHED)
396           director_->swig_jvm_->DetachCurrentThread();
397 #endif
398       }
399       JNIEnv *getJNIEnv() const {
400         return jenv_;
401       }
402     };
403
404     /* Java object wrapper */
405     JObjectWrapper swig_self_;
406
407     /* Disconnect director from Java object */
408     void swig_disconnect_director_self(const char *disconn_method) {
409       JNIEnvWrapper jnienv(this) ;
410       JNIEnv *jenv = jnienv.getJNIEnv() ;
411       jobject jobj = swig_self_.get(jenv);
412       LocalRefGuard ref_deleter(jenv, jobj);
413 #if defined(DEBUG_DIRECTOR_OWNED)
414       std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl;
415 #endif
416       if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) {
417         jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(jobj), disconn_method, "()V");
418         if (disconn_meth) {
419 #if defined(DEBUG_DIRECTOR_OWNED)
420           std::cout << "Swig::Director::disconnect_director_self upcall to " << disconn_method << std::endl;
421 #endif
422           jenv->CallVoidMethod(jobj, disconn_meth);
423         }
424       }
425     }
426
427   public:
428     Director(JNIEnv *jenv) : swig_jvm_((JavaVM *) NULL), swig_self_() {
429       /* Acquire the Java VM pointer */
430       jenv->GetJavaVM(&swig_jvm_);
431     }
432
433     virtual ~Director() {
434       JNIEnvWrapper jnienv(this) ;
435       JNIEnv *jenv = jnienv.getJNIEnv() ;
436       swig_self_.release(jenv);
437     }
438
439     bool swig_set_self(JNIEnv *jenv, jobject jself, bool mem_own, bool weak_global) {
440       return swig_self_.set(jenv, jself, mem_own, weak_global);
441     }
442
443     jobject swig_get_self(JNIEnv *jenv) const {
444       return swig_self_.get(jenv);
445     }
446
447     // Change C++ object's ownership, relative to Java
448     void swig_java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
449       swig_self_.java_change_ownership(jenv, jself, take_or_release);
450     }
451   };
452
453   // Zero initialized bool array
454   template<size_t N> class BoolArray {
455     bool array_[N];
456   public:
457     BoolArray() {
458       memset(array_, 0, sizeof(array_));
459     }
460     bool& operator[](size_t n) {
461       return array_[n];
462     }
463     bool operator[](size_t n) const {
464       return array_[n];
465     }
466   };
467
468   // Utility classes and functions for exception handling.
469
470   // Simple holder for a Java string during exception handling, providing access to a c-style string
471   class JavaString {
472   public:
473     JavaString(JNIEnv *jenv, jstring jstr) : jenv_(jenv), jstr_(jstr), cstr_(0) {
474       if (jenv_ && jstr_)
475         cstr_ = (const char *) jenv_->GetStringUTFChars(jstr_, NULL);
476     }
477
478     ~JavaString() {
479       if (jenv_ && jstr_ && cstr_)
480         jenv_->ReleaseStringUTFChars(jstr_, cstr_);
481     }
482
483     const char *c_str(const char *null_string = "null JavaString") const {
484       return cstr_ ? cstr_ : null_string;
485     }
486
487   private:
488     // non-copyable
489     JavaString(const JavaString &);
490     JavaString &operator=(const JavaString &);
491
492     JNIEnv *jenv_;
493     jstring jstr_;
494     const char *cstr_;
495   };
496
497   // Helper class to extract the exception message from a Java throwable
498   class JavaExceptionMessage {
499   public:
500     JavaExceptionMessage(JNIEnv *jenv, jthrowable throwable) : message_(jenv, exceptionMessageFromThrowable(jenv, throwable)) {
501     }
502
503     const char *message() const {
504       return message_.c_str("Could not get exception message in JavaExceptionMessage");
505     }
506
507   private:
508     // non-copyable
509     JavaExceptionMessage(const JavaExceptionMessage &);
510     JavaExceptionMessage &operator=(const JavaExceptionMessage &);
511
512     // Get exception message by calling Java method Throwable.getMessage()
513     static jstring exceptionMessageFromThrowable(JNIEnv *jenv, jthrowable throwable) {
514       jstring jmsg = NULL;
515       if (jenv && throwable) {
516         jenv->ExceptionClear(); // Cannot invoke methods with any pending exceptions
517         jclass throwclz = jenv->GetObjectClass(throwable);
518         if (throwclz) {
519           // All Throwable classes have a getMessage() method, so call it to extract the exception message
520           jmethodID getMessageMethodID = jenv->GetMethodID(throwclz, "getMessage", "()Ljava/lang/String;");
521           if (getMessageMethodID)
522             jmsg = (jstring)jenv->CallObjectMethod(throwable, getMessageMethodID);
523         }
524         if (jmsg == NULL && jenv->ExceptionCheck())
525           jenv->ExceptionClear();
526       }
527       return jmsg;
528     }
529
530     JavaString message_;
531   };
532
533   // C++ Exception class for handling Java exceptions thrown during a director method Java upcall
534   class DirectorException : public std::exception {
535   public:
536
537     // Construct exception from a Java throwable
538     DirectorException(JNIEnv *jenv, jthrowable throwable) : classname_(0), msg_(0) {
539
540       // Call Java method Object.getClass().getName() to obtain the throwable's class name (delimited by '/')
541       if (throwable) {
542         jclass throwclz = jenv->GetObjectClass(throwable);
543         if (throwclz) {
544           jclass clzclz = jenv->GetObjectClass(throwclz);
545           if (clzclz) {
546             jmethodID getNameMethodID = jenv->GetMethodID(clzclz, "getName", "()Ljava/lang/String;");
547             if (getNameMethodID) {
548               jstring jstr_classname = (jstring)(jenv->CallObjectMethod(throwclz, getNameMethodID));
549               // Copy strings, since there is no guarantee that jenv will be active when handled
550               if (jstr_classname) {
551                 JavaString jsclassname(jenv, jstr_classname);
552                 const char *classname = jsclassname.c_str(0);
553                 if (classname)
554                   classname_ = copypath(classname);
555               }
556             }
557           }
558         }
559       }
560
561       JavaExceptionMessage exceptionmsg(jenv, throwable);
562       msg_ = copystr(exceptionmsg.message());
563     }
564
565     // More general constructor for handling as a java.lang.RuntimeException
566     DirectorException(const char *msg) : classname_(0), msg_(copystr(msg ? msg : "Unspecified DirectorException message")) {
567     }
568
569     ~DirectorException() throw() {
570       delete[] classname_;
571       delete[] msg_;
572     }
573
574     const char *what() const throw() {
575       return msg_;
576     }
577
578     // Reconstruct and raise/throw the Java Exception that caused the DirectorException
579     // Note that any error in the JNI exception handling results in a Java RuntimeException
580     void raiseJavaException(JNIEnv *jenv) const {
581       if (jenv) {
582         jenv->ExceptionClear();
583
584         jmethodID ctorMethodID = 0;
585         jclass throwableclass = 0;
586         if (classname_) {
587           throwableclass = jenv->FindClass(classname_);
588           if (throwableclass)
589             ctorMethodID = jenv->GetMethodID(throwableclass, "<init>", "(Ljava/lang/String;)V");
590         }
591
592         if (ctorMethodID) {
593           jenv->ThrowNew(throwableclass, what());
594         } else {
595           SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, what());
596         }
597       }
598     }
599
600   private:
601     static char *copypath(const char *srcmsg) {
602       char *target = copystr(srcmsg);
603       for (char *c=target; *c; ++c) {
604         if ('.' == *c)
605           *c = '/';
606       }
607       return target;
608     }
609
610     static char *copystr(const char *srcmsg) {
611       char *target = 0;
612       if (srcmsg) {
613         size_t msglen = strlen(srcmsg) + 1;
614         target = new char[msglen];
615         strncpy(target, srcmsg, msglen);
616       }
617       return target;
618     }
619
620     const char *classname_;
621     const char *msg_;
622   };
623
624   // Helper method to determine if a Java throwable matches a particular Java class type
625   SWIGINTERN bool ExceptionMatches(JNIEnv *jenv, jthrowable throwable, const char *classname) {
626     bool matches = false;
627
628     if (throwable && jenv && classname) {
629       // Exceptions need to be cleared for correct behavior.
630       // The caller of ExceptionMatches should restore pending exceptions if desired -
631       // the caller already has the throwable.
632       jenv->ExceptionClear();
633
634       jclass clz = jenv->FindClass(classname);
635       if (clz) {
636         jclass classclz = jenv->GetObjectClass(clz);
637         jmethodID isInstanceMethodID = jenv->GetMethodID(classclz, "isInstance", "(Ljava/lang/Object;)Z");
638         if (isInstanceMethodID) {
639           matches = jenv->CallBooleanMethod(clz, isInstanceMethodID, throwable) != 0;
640         }
641       }
642
643 #if defined(DEBUG_DIRECTOR_EXCEPTION)
644       if (jenv->ExceptionCheck()) {
645         // Typically occurs when an invalid classname argument is passed resulting in a ClassNotFoundException
646         JavaExceptionMessage exc(jenv, jenv->ExceptionOccurred());
647         std::cout << "Error: ExceptionMatches: class '" << classname << "' : " << exc.message() << std::endl;
648       }
649 #endif
650     }
651     return matches;
652   }
653 }
654
655 namespace Swig {
656   namespace {
657     jclass jclass_JavaControllerJNI = NULL;
658     jmethodID director_method_ids[5];
659   }
660 }
661
662 #include <iterator>
663 #include <algorithm>
664 #include <vector>
665 #include <string>
666
667 #include "utilities.hxx"
668 #include "View.hxx"
669 #include "Controller.hxx"
670
671
672 #include <stdexcept>
673
674
675 #include <string>
676
677 SWIGINTERN bool std_vector_Sl_int_Sg__contains(std::vector< int > *self,int const &o){
678                return std::find(self->begin(), self->end(), o) != self->end();
679             }
680 SWIGINTERN int std_vector_Sl_int_Sg__indexOf(std::vector< int > *self,int const &o){
681                auto it = std::find(self->begin(), self->end(), o);
682                if (it != self->end())
683                    return std::distance(self->begin(), it);
684                else
685                    return -1;
686             }
687 SWIGINTERN std::vector< int >::const_reference std_vector_Sl_int_Sg__get(std::vector< int > *self,int i){
688                 int size = int(self->size());
689                 if (i>=0 && i<size)
690                     return (*self)[i];
691                 else
692                     throw std::out_of_range("vector index out of range");
693             }
694 SWIGINTERN void std_vector_Sl_int_Sg__set(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
695                 int size = int(self->size());
696                 if (i>=0 && i<size)
697                     (*self)[i] = val;
698                 else
699                     throw std::out_of_range("vector index out of range");
700             }
701 SWIGINTERN void std_vector_Sl_int_Sg__add__SWIG_1(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
702                 int size = int(self->size());
703                 if (i>=0 && i<=size)
704                     self->insert(self->begin() + i, val);
705                 else
706                     throw std::out_of_range("vector index out of range");
707             }
708 SWIGINTERN bool std_vector_Sl_int_Sg__remove(std::vector< int > *self,std::vector< int >::value_type const &val){
709                 auto it = std::find(self->begin(), self->end(), val);
710                 if (it == self->end())
711                     return false;
712                 else
713                     self->erase(it);
714                 return true;
715             }
716 SWIGINTERN void *std_vector_Sl_int_Sg__asByteBuffer(std::vector< int > *self,int i,int capacity){
717                 (void) capacity;
718                 void* buffer = nullptr;
719                 int size = int(self->size()) ;
720                 if (i>=0 && i<size) {
721                     buffer = self->data() + i;
722                 } else if (i==0 && size == 0) {
723                     buffer = self->data();
724                 } else {
725                     throw std::out_of_range("vector index out of range");
726                 }
727                 return buffer;
728             }
729 SWIGINTERN bool std_vector_Sl_bool_Sg__get(std::vector< bool > *self,int i){
730                 int size = int(self->size());
731                 if (i>=0 && i<size)
732                     return (*self)[i];
733                 else
734                     throw std::out_of_range("vector index out of range");
735             }
736 SWIGINTERN void std_vector_Sl_bool_Sg__set(std::vector< bool > *self,int i,std::vector< bool >::value_type const &val){
737                 int size = int(self->size());
738                 if (i>=0 && i<size)
739                     (*self)[i] = val;
740                 else
741                     throw std::out_of_range("vector index out of range");
742             }
743 SWIGINTERN void std_vector_Sl_bool_Sg__add__SWIG_1(std::vector< bool > *self,int i,std::vector< bool >::value_type const &val){
744                 int size = int(self->size());
745                 if (i>=0 && i<=size)
746                     self->insert(self->begin() + i, val);
747                 else
748                     throw std::out_of_range("vector index out of range");
749             }
750 SWIGINTERN bool std_vector_Sl_bool_Sg__remove(std::vector< bool > *self,std::vector< bool >::value_type const &val){
751                 auto it = std::find(self->begin(), self->end(), val);
752                 if (it == self->end())
753                     return false;
754                 else
755                     self->erase(it);
756                 return true;
757             }
758 SWIGINTERN bool std_vector_Sl_double_Sg__contains(std::vector< double > *self,double const &o){
759                return std::find(self->begin(), self->end(), o) != self->end();
760             }
761 SWIGINTERN int std_vector_Sl_double_Sg__indexOf(std::vector< double > *self,double const &o){
762                auto it = std::find(self->begin(), self->end(), o);
763                if (it != self->end())
764                    return std::distance(self->begin(), it);
765                else
766                    return -1;
767             }
768 SWIGINTERN std::vector< double >::const_reference std_vector_Sl_double_Sg__get(std::vector< double > *self,int i){
769                 int size = int(self->size());
770                 if (i>=0 && i<size)
771                     return (*self)[i];
772                 else
773                     throw std::out_of_range("vector index out of range");
774             }
775 SWIGINTERN void std_vector_Sl_double_Sg__set(std::vector< double > *self,int i,std::vector< double >::value_type const &val){
776                 int size = int(self->size());
777                 if (i>=0 && i<size)
778                     (*self)[i] = val;
779                 else
780                     throw std::out_of_range("vector index out of range");
781             }
782 SWIGINTERN void std_vector_Sl_double_Sg__add__SWIG_1(std::vector< double > *self,int i,std::vector< double >::value_type const &val){
783                 int size = int(self->size());
784                 if (i>=0 && i<=size)
785                     self->insert(self->begin() + i, val);
786                 else
787                     throw std::out_of_range("vector index out of range");
788             }
789 SWIGINTERN bool std_vector_Sl_double_Sg__remove(std::vector< double > *self,std::vector< double >::value_type const &val){
790                 auto it = std::find(self->begin(), self->end(), val);
791                 if (it == self->end())
792                     return false;
793                 else
794                     self->erase(it);
795                 return true;
796             }
797 SWIGINTERN void *std_vector_Sl_double_Sg__asByteBuffer(std::vector< double > *self,int i,int capacity){
798                 (void) capacity;
799                 void* buffer = nullptr;
800                 int size = int(self->size()) ;
801                 if (i>=0 && i<size) {
802                     buffer = self->data() + i;
803                 } else if (i==0 && size == 0) {
804                     buffer = self->data();
805                 } else {
806                     throw std::out_of_range("vector index out of range");
807                 }
808                 return buffer;
809             }
810 SWIGINTERN bool std_vector_Sl_std_string_Sg__contains(std::vector< std::string > *self,std::string const &o){
811                return std::find(self->begin(), self->end(), o) != self->end();
812             }
813 SWIGINTERN int std_vector_Sl_std_string_Sg__indexOf(std::vector< std::string > *self,std::string const &o){
814                auto it = std::find(self->begin(), self->end(), o);
815                if (it != self->end())
816                    return std::distance(self->begin(), it);
817                else
818                    return -1;
819             }
820 SWIGINTERN std::vector< std::string >::const_reference std_vector_Sl_std_string_Sg__get(std::vector< std::string > *self,int i){
821                 int size = int(self->size());
822                 if (i>=0 && i<size)
823                     return (*self)[i];
824                 else
825                     throw std::out_of_range("vector index out of range");
826             }
827 SWIGINTERN void std_vector_Sl_std_string_Sg__set(std::vector< std::string > *self,int i,std::vector< std::string >::value_type const &val){
828                 int size = int(self->size());
829                 if (i>=0 && i<size)
830                     (*self)[i] = val;
831                 else
832                     throw std::out_of_range("vector index out of range");
833             }
834 SWIGINTERN void std_vector_Sl_std_string_Sg__add__SWIG_1(std::vector< std::string > *self,int i,std::vector< std::string >::value_type const &val){
835                 int size = int(self->size());
836                 if (i>=0 && i<=size)
837                     self->insert(self->begin() + i, val);
838                 else
839                     throw std::out_of_range("vector index out of range");
840             }
841 SWIGINTERN bool std_vector_Sl_std_string_Sg__remove(std::vector< std::string > *self,std::vector< std::string >::value_type const &val){
842                 auto it = std::find(self->begin(), self->end(), val);
843                 if (it == self->end())
844                     return false;
845                 else
846                     self->erase(it);
847                 return true;
848             }
849 SWIGINTERN void *std_vector_Sl_std_string_Sg__asByteBuffer(std::vector< std::string > *self,int i,int capacity){
850                 (void) capacity;
851                 void* buffer = nullptr;
852                 int size = int(self->size()) ;
853                 if (i>=0 && i<size) {
854                     buffer = self->data() + i;
855                 } else if (i==0 && size == 0) {
856                     buffer = self->data();
857                 } else {
858                     throw std::out_of_range("vector index out of range");
859                 }
860                 return buffer;
861             }
862 SWIGINTERN bool std_vector_Sl_ScicosID_Sg__contains(std::vector< ScicosID > *self,long long const &o){
863                return std::find(self->begin(), self->end(), o) != self->end();
864             }
865 SWIGINTERN int std_vector_Sl_ScicosID_Sg__indexOf(std::vector< ScicosID > *self,long long const &o){
866                auto it = std::find(self->begin(), self->end(), o);
867                if (it != self->end())
868                    return std::distance(self->begin(), it);
869                else
870                    return -1;
871             }
872 SWIGINTERN std::vector< long long >::const_reference std_vector_Sl_ScicosID_Sg__get(std::vector< ScicosID > *self,int i){
873                 int size = int(self->size());
874                 if (i>=0 && i<size)
875                     return (*self)[i];
876                 else
877                     throw std::out_of_range("vector index out of range");
878             }
879 SWIGINTERN void std_vector_Sl_ScicosID_Sg__set(std::vector< ScicosID > *self,int i,std::vector< long long >::value_type const &val){
880                 int size = int(self->size());
881                 if (i>=0 && i<size)
882                     (*self)[i] = val;
883                 else
884                     throw std::out_of_range("vector index out of range");
885             }
886 SWIGINTERN void std_vector_Sl_ScicosID_Sg__add__SWIG_1(std::vector< ScicosID > *self,int i,std::vector< long long >::value_type const &val){
887                 int size = int(self->size());
888                 if (i>=0 && i<=size)
889                     self->insert(self->begin() + i, val);
890                 else
891                     throw std::out_of_range("vector index out of range");
892             }
893 SWIGINTERN bool std_vector_Sl_ScicosID_Sg__remove(std::vector< ScicosID > *self,std::vector< long long >::value_type const &val){
894                 auto it = std::find(self->begin(), self->end(), val);
895                 if (it == self->end())
896                     return false;
897                 else
898                     self->erase(it);
899                 return true;
900             }
901 SWIGINTERN void *std_vector_Sl_ScicosID_Sg__asByteBuffer(std::vector< ScicosID > *self,int i,int capacity){
902                 (void) capacity;
903                 void* buffer = nullptr;
904                 int size = int(self->size()) ;
905                 if (i>=0 && i<size) {
906                     buffer = self->data() + i;
907                 } else if (i==0 && size == 0) {
908                     buffer = self->data();
909                 } else {
910                     throw std::out_of_range("vector index out of range");
911                 }
912                 return buffer;
913             }
914
915 static void register_view(const std::string& name, org_scilab_modules_scicos::View* view) {
916   org_scilab_modules_scicos::Controller::register_view(name, view);
917 };
918 static void unregister_view(org_scilab_modules_scicos::View* view) {
919   org_scilab_modules_scicos::Controller::unregister_view(view);
920 };
921
922
923
924 /* ---------------------------------------------------
925  * C++ director class methods
926  * --------------------------------------------------- */
927
928 #include "JavaController_wrap.h"
929
930 SwigDirector_View::SwigDirector_View(JNIEnv *jenv) : org_scilab_modules_scicos::View(), Swig::Director(jenv) {
931 }
932
933 SwigDirector_View::~SwigDirector_View() {
934   swig_disconnect_director_self("swigDirectorDisconnect");
935 }
936
937
938 void SwigDirector_View::objectCreated(ScicosID const &uid, kind_t kind) {
939   JNIEnvWrapper swigjnienv(this) ;
940   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
941   jobject swigjobj = (jobject) NULL ;
942   jlong juid = 0 ;
943   jint jkind  ;
944   
945   if (!swig_override[0]) {
946     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectCreated.");
947     return;
948   }
949   swigjobj = swig_get_self(jenv);
950   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
951     juid = (jlong)uid;
952     jkind = (jint) kind;
953     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[0], swigjobj, juid, jkind);
954     jthrowable swigerror = jenv->ExceptionOccurred();
955     if (swigerror) {
956       jenv->ExceptionClear();
957       throw Swig::DirectorException(jenv, swigerror);
958     }
959     
960   } else {
961     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectCreated ");
962   }
963   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
964 }
965
966 void SwigDirector_View::objectReferenced(ScicosID const &uid, kind_t kind, unsigned int refCount) {
967   JNIEnvWrapper swigjnienv(this) ;
968   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
969   jobject swigjobj = (jobject) NULL ;
970   jlong juid = 0 ;
971   jint jkind  ;
972   jlong jrefCount  ;
973   
974   if (!swig_override[1]) {
975     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectReferenced.");
976     return;
977   }
978   swigjobj = swig_get_self(jenv);
979   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
980     juid = (jlong)uid;
981     jkind = (jint) kind;
982     jrefCount = (jlong) refCount;
983     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[1], swigjobj, juid, jkind, jrefCount);
984     jthrowable swigerror = jenv->ExceptionOccurred();
985     if (swigerror) {
986       jenv->ExceptionClear();
987       throw Swig::DirectorException(jenv, swigerror);
988     }
989     
990   } else {
991     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectReferenced ");
992   }
993   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
994 }
995
996 void SwigDirector_View::objectUnreferenced(ScicosID const &uid, kind_t kind, unsigned int refCount) {
997   JNIEnvWrapper swigjnienv(this) ;
998   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
999   jobject swigjobj = (jobject) NULL ;
1000   jlong juid = 0 ;
1001   jint jkind  ;
1002   jlong jrefCount  ;
1003   
1004   if (!swig_override[2]) {
1005     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectUnreferenced.");
1006     return;
1007   }
1008   swigjobj = swig_get_self(jenv);
1009   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1010     juid = (jlong)uid;
1011     jkind = (jint) kind;
1012     jrefCount = (jlong) refCount;
1013     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[2], swigjobj, juid, jkind, jrefCount);
1014     jthrowable swigerror = jenv->ExceptionOccurred();
1015     if (swigerror) {
1016       jenv->ExceptionClear();
1017       throw Swig::DirectorException(jenv, swigerror);
1018     }
1019     
1020   } else {
1021     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectUnreferenced ");
1022   }
1023   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1024 }
1025
1026 void SwigDirector_View::objectDeleted(ScicosID const &uid, kind_t kind) {
1027   JNIEnvWrapper swigjnienv(this) ;
1028   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1029   jobject swigjobj = (jobject) NULL ;
1030   jlong juid = 0 ;
1031   jint jkind  ;
1032   
1033   if (!swig_override[3]) {
1034     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectDeleted.");
1035     return;
1036   }
1037   swigjobj = swig_get_self(jenv);
1038   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1039     juid = (jlong)uid;
1040     jkind = (jint) kind;
1041     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[3], swigjobj, juid, jkind);
1042     jthrowable swigerror = jenv->ExceptionOccurred();
1043     if (swigerror) {
1044       jenv->ExceptionClear();
1045       throw Swig::DirectorException(jenv, swigerror);
1046     }
1047     
1048   } else {
1049     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectDeleted ");
1050   }
1051   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1052 }
1053
1054 void SwigDirector_View::propertyUpdated(ScicosID const &uid, kind_t kind, object_properties_t property, update_status_t status) {
1055   JNIEnvWrapper swigjnienv(this) ;
1056   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1057   jobject swigjobj = (jobject) NULL ;
1058   jlong juid = 0 ;
1059   jint jkind  ;
1060   jint jproperty  ;
1061   jint jstatus  ;
1062   
1063   if (!swig_override[4]) {
1064     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::propertyUpdated.");
1065     return;
1066   }
1067   swigjobj = swig_get_self(jenv);
1068   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1069     juid = (jlong)uid;
1070     jkind = (jint) kind;
1071     jproperty = (jint) property;
1072     jstatus = (jint) status;
1073     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_method_ids[4], swigjobj, juid, jkind, jproperty, jstatus);
1074     jthrowable swigerror = jenv->ExceptionOccurred();
1075     if (swigerror) {
1076       jenv->ExceptionClear();
1077       throw Swig::DirectorException(jenv, swigerror);
1078     }
1079     
1080   } else {
1081     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::propertyUpdated ");
1082   }
1083   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1084 }
1085
1086 void SwigDirector_View::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
1087   static struct {
1088     const char *mname;
1089     const char *mdesc;
1090     jmethodID base_methid;
1091   } methods[] = {
1092     {
1093       "objectCreated", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
1094     },
1095     {
1096       "objectReferenced", "(JLorg/scilab/modules/xcos/Kind;J)V", NULL 
1097     },
1098     {
1099       "objectUnreferenced", "(JLorg/scilab/modules/xcos/Kind;J)V", NULL 
1100     },
1101     {
1102       "objectDeleted", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
1103     },
1104     {
1105       "propertyUpdated", "(JLorg/scilab/modules/xcos/Kind;Lorg/scilab/modules/xcos/ObjectProperties;Lorg/scilab/modules/xcos/UpdateStatus;)V", NULL 
1106     }
1107   };
1108   
1109   static jclass baseclass = 0 ;
1110   
1111   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
1112     if (!baseclass) {
1113       baseclass = jenv->FindClass("org/scilab/modules/xcos/View");
1114       if (!baseclass) return;
1115       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
1116     }
1117     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
1118     for (int i = 0; i < 5; ++i) {
1119       if (!methods[i].base_methid) {
1120         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
1121         if (!methods[i].base_methid) return;
1122       }
1123       swig_override[i] = false;
1124       if (derived) {
1125         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
1126         swig_override[i] = (methid != methods[i].base_methid);
1127         jenv->ExceptionClear();
1128       }
1129     }
1130   }
1131 }
1132
1133
1134
1135 #ifdef __cplusplus
1136 extern "C" {
1137 #endif
1138
1139 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1View(JNIEnv *jenv, jclass jcls) {
1140   jlong jresult = 0 ;
1141   org_scilab_modules_scicos::View *result = 0 ;
1142   
1143   (void)jenv;
1144   (void)jcls;
1145   result = (org_scilab_modules_scicos::View *)new SwigDirector_View(jenv);
1146   *(org_scilab_modules_scicos::View **)&jresult = result; 
1147   return jresult;
1148 }
1149
1150
1151 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1View(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1152   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1153   
1154   (void)jenv;
1155   (void)jcls;
1156   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1157   delete arg1;
1158 }
1159
1160
1161 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectCreated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1162   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1163   ScicosID *arg2 = 0 ;
1164   kind_t arg3 ;
1165   ScicosID temp2 ;
1166   
1167   (void)jenv;
1168   (void)jcls;
1169   (void)jarg1_;
1170   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1171   temp2 = (ScicosID)jarg2; 
1172   arg2 = &temp2; 
1173   arg3 = (kind_t)jarg3; 
1174   (arg1)->objectCreated((ScicosID const &)*arg2,arg3);
1175 }
1176
1177
1178 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectReferenced(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jlong jarg4) {
1179   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1180   ScicosID *arg2 = 0 ;
1181   kind_t arg3 ;
1182   unsigned int arg4 ;
1183   ScicosID temp2 ;
1184   
1185   (void)jenv;
1186   (void)jcls;
1187   (void)jarg1_;
1188   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1189   temp2 = (ScicosID)jarg2; 
1190   arg2 = &temp2; 
1191   arg3 = (kind_t)jarg3; 
1192   arg4 = (unsigned int)jarg4; 
1193   (arg1)->objectReferenced((ScicosID const &)*arg2,arg3,arg4);
1194 }
1195
1196
1197 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectUnreferenced(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jlong jarg4) {
1198   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1199   ScicosID *arg2 = 0 ;
1200   kind_t arg3 ;
1201   unsigned int arg4 ;
1202   ScicosID temp2 ;
1203   
1204   (void)jenv;
1205   (void)jcls;
1206   (void)jarg1_;
1207   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1208   temp2 = (ScicosID)jarg2; 
1209   arg2 = &temp2; 
1210   arg3 = (kind_t)jarg3; 
1211   arg4 = (unsigned int)jarg4; 
1212   (arg1)->objectUnreferenced((ScicosID const &)*arg2,arg3,arg4);
1213 }
1214
1215
1216 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectDeleted(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
1217   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1218   ScicosID *arg2 = 0 ;
1219   kind_t arg3 ;
1220   ScicosID temp2 ;
1221   
1222   (void)jenv;
1223   (void)jcls;
1224   (void)jarg1_;
1225   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1226   temp2 = (ScicosID)jarg2; 
1227   arg2 = &temp2; 
1228   arg3 = (kind_t)jarg3; 
1229   (arg1)->objectDeleted((ScicosID const &)*arg2,arg3);
1230 }
1231
1232
1233 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1propertyUpdated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jint jarg5) {
1234   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
1235   ScicosID *arg2 = 0 ;
1236   kind_t arg3 ;
1237   object_properties_t arg4 ;
1238   update_status_t arg5 ;
1239   ScicosID temp2 ;
1240   
1241   (void)jenv;
1242   (void)jcls;
1243   (void)jarg1_;
1244   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
1245   temp2 = (ScicosID)jarg2; 
1246   arg2 = &temp2; 
1247   arg3 = (kind_t)jarg3; 
1248   arg4 = (object_properties_t)jarg4; 
1249   arg5 = (update_status_t)jarg5; 
1250   (arg1)->propertyUpdated((ScicosID const &)*arg2,arg3,arg4,arg5);
1251 }
1252
1253
1254 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
1255   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1256   (void)jcls;
1257   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1258   if (director) {
1259     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
1260   }
1261 }
1262
1263
1264 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
1265   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
1266   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
1267   (void)jcls;
1268   if (director) {
1269     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
1270   }
1271 }
1272
1273
1274 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1look_1for_1view(JNIEnv *jenv, jclass jcls, jstring jarg1) {
1275   jlong jresult = 0 ;
1276   std::string *arg1 = 0 ;
1277   org_scilab_modules_scicos::View *result = 0 ;
1278   
1279   (void)jenv;
1280   (void)jcls;
1281   Swig::JavaString javaString(jenv, jarg1);
1282   *arg1 = std::string(javaString.c_str());
1283   result = (org_scilab_modules_scicos::View *)org_scilab_modules_scicos::Controller::look_for_view((std::string const &)*arg1);
1284   *(org_scilab_modules_scicos::View **)&jresult = result; 
1285   
1286   return jresult;
1287 }
1288
1289
1290 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1Controller(JNIEnv *jenv, jclass jcls) {
1291   jlong jresult = 0 ;
1292   org_scilab_modules_scicos::Controller *result = 0 ;
1293   
1294   (void)jenv;
1295   (void)jcls;
1296   result = (org_scilab_modules_scicos::Controller *)new org_scilab_modules_scicos::Controller();
1297   *(org_scilab_modules_scicos::Controller **)&jresult = result; 
1298   return jresult;
1299 }
1300
1301
1302 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1Controller(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1303   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1304   
1305   (void)jenv;
1306   (void)jcls;
1307   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1308   delete arg1;
1309 }
1310
1311
1312 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1createObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1313   jlong jresult = 0 ;
1314   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1315   kind_t arg2 ;
1316   ScicosID result;
1317   
1318   (void)jenv;
1319   (void)jcls;
1320   (void)jarg1_;
1321   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1322   arg2 = (kind_t)jarg2; 
1323   result = (ScicosID)(arg1)->createObject(arg2);
1324   jresult = (jlong)result; 
1325   return jresult;
1326 }
1327
1328
1329 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1referenceObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1330   jlong jresult = 0 ;
1331   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1332   ScicosID arg2 ;
1333   unsigned int result;
1334   
1335   (void)jenv;
1336   (void)jcls;
1337   (void)jarg1_;
1338   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1339   arg2 = (ScicosID)jarg2; 
1340   result = (unsigned int)((org_scilab_modules_scicos::Controller const *)arg1)->referenceObject(arg2);
1341   jresult = (jlong)result; 
1342   return jresult;
1343 }
1344
1345
1346 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1deleteObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1347   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1348   ScicosID arg2 ;
1349   
1350   (void)jenv;
1351   (void)jcls;
1352   (void)jarg1_;
1353   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1354   arg2 = (ScicosID)jarg2; 
1355   (arg1)->deleteObject(arg2);
1356 }
1357
1358
1359 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) {
1360   jlong jresult = 0 ;
1361   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1362   ScicosID arg2 ;
1363   bool arg3 ;
1364   bool arg4 ;
1365   ScicosID result;
1366   
1367   (void)jenv;
1368   (void)jcls;
1369   (void)jarg1_;
1370   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1371   arg2 = (ScicosID)jarg2; 
1372   arg3 = jarg3 ? true : false; 
1373   arg4 = jarg4 ? true : false; 
1374   result = (ScicosID)(arg1)->cloneObject(arg2,arg3,arg4);
1375   jresult = (jlong)result; 
1376   return jresult;
1377 }
1378
1379
1380 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getKind(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1381   jint jresult = 0 ;
1382   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1383   ScicosID arg2 ;
1384   kind_t result;
1385   
1386   (void)jenv;
1387   (void)jcls;
1388   (void)jarg1_;
1389   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1390   arg2 = (ScicosID)jarg2; 
1391   result = (kind_t)((org_scilab_modules_scicos::Controller const *)arg1)->getKind(arg2);
1392   jresult = (jint)result; 
1393   return jresult;
1394 }
1395
1396
1397 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getAll(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1398   jlong jresult = 0 ;
1399   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1400   kind_t arg2 ;
1401   std::vector< ScicosID > result;
1402   
1403   (void)jenv;
1404   (void)jcls;
1405   (void)jarg1_;
1406   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1407   arg2 = (kind_t)jarg2; 
1408   result = ((org_scilab_modules_scicos::Controller const *)arg1)->getAll(arg2);
1409   *(std::vector< ScicosID > **)&jresult = new std::vector< ScicosID >((const std::vector< ScicosID > &)result); 
1410   return jresult;
1411 }
1412
1413
1414 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_) {
1415   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1416   std::vector< ScicosID > *arg2 = 0 ;
1417   std::vector< int > *arg3 = 0 ;
1418   
1419   (void)jenv;
1420   (void)jcls;
1421   (void)jarg1_;
1422   (void)jarg2_;
1423   (void)jarg3_;
1424   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1425   arg2 = *(std::vector< ScicosID > **)&jarg2;
1426   if (!arg2) {
1427     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ScicosID > & reference is null");
1428     return ;
1429   } 
1430   arg3 = *(std::vector< int > **)&jarg3;
1431   if (!arg3) {
1432     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > & reference is null");
1433     return ;
1434   } 
1435   (arg1)->sortAndFillKind(*arg2,*arg3);
1436 }
1437
1438
1439 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) {
1440   jboolean jresult = 0 ;
1441   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1442   ScicosID arg2 ;
1443   kind_t arg3 ;
1444   object_properties_t arg4 ;
1445   double *arg5 = 0 ;
1446   double temp5 ;
1447   bool result;
1448   
1449   (void)jenv;
1450   (void)jcls;
1451   (void)jarg1_;
1452   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1453   arg2 = (ScicosID)jarg2; 
1454   arg3 = (kind_t)jarg3; 
1455   arg4 = (object_properties_t)jarg4; 
1456   {
1457     if (!jarg5) {
1458       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1459       return 0;
1460     }
1461     if (jenv->GetArrayLength(jarg5) == 0) {
1462       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1463       return 0;
1464     }
1465     temp5 = (double)0;
1466     arg5 = &temp5; 
1467   }
1468   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1469   jresult = (jboolean)result; 
1470   {
1471     jdouble jvalue = (jdouble)temp5;
1472     jenv->SetDoubleArrayRegion(jarg5, 0, 1, &jvalue);
1473   }
1474   
1475   return jresult;
1476 }
1477
1478
1479 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) {
1480   jboolean jresult = 0 ;
1481   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1482   ScicosID arg2 ;
1483   kind_t arg3 ;
1484   object_properties_t arg4 ;
1485   int *arg5 = 0 ;
1486   int temp5 ;
1487   bool result;
1488   
1489   (void)jenv;
1490   (void)jcls;
1491   (void)jarg1_;
1492   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1493   arg2 = (ScicosID)jarg2; 
1494   arg3 = (kind_t)jarg3; 
1495   arg4 = (object_properties_t)jarg4; 
1496   {
1497     if (!jarg5) {
1498       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1499       return 0;
1500     }
1501     if (jenv->GetArrayLength(jarg5) == 0) {
1502       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1503       return 0;
1504     }
1505     temp5 = (int)0;
1506     arg5 = &temp5; 
1507   }
1508   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1509   jresult = (jboolean)result; 
1510   {
1511     jint jvalue = (jint)temp5;
1512     jenv->SetIntArrayRegion(jarg5, 0, 1, &jvalue);
1513   }
1514   
1515   return jresult;
1516 }
1517
1518
1519 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) {
1520   jboolean jresult = 0 ;
1521   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1522   ScicosID arg2 ;
1523   kind_t arg3 ;
1524   object_properties_t arg4 ;
1525   bool *arg5 = 0 ;
1526   bool temp5 ;
1527   bool result;
1528   
1529   (void)jenv;
1530   (void)jcls;
1531   (void)jarg1_;
1532   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1533   arg2 = (ScicosID)jarg2; 
1534   arg3 = (kind_t)jarg3; 
1535   arg4 = (object_properties_t)jarg4; 
1536   {
1537     if (!jarg5) {
1538       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1539       return 0;
1540     }
1541     if (jenv->GetArrayLength(jarg5) == 0) {
1542       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1543       return 0;
1544     }
1545     temp5 = false;
1546     arg5 = &temp5; 
1547   }
1548   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1549   jresult = (jboolean)result; 
1550   {
1551     jboolean jvalue = (jboolean)temp5;
1552     jenv->SetBooleanArrayRegion(jarg5, 0, 1, &jvalue);
1553   }
1554   
1555   return jresult;
1556 }
1557
1558
1559 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) {
1560   jboolean jresult = 0 ;
1561   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1562   ScicosID arg2 ;
1563   kind_t arg3 ;
1564   object_properties_t arg4 ;
1565   std::string *arg5 = 0 ;
1566   std::string temp5 ;
1567   bool result;
1568   
1569   (void)jenv;
1570   (void)jcls;
1571   (void)jarg1_;
1572   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1573   arg2 = (ScicosID)jarg2; 
1574   arg3 = (kind_t)jarg3; 
1575   arg4 = (object_properties_t)jarg4; 
1576   {
1577     if (!jarg5) {
1578       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1579       return 0;
1580     }
1581     if (jenv->GetArrayLength(jarg5) == 0) {
1582       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1583       return 0;
1584     }
1585     arg5 = &temp5;
1586     *arg5 = "";
1587   }
1588   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1589   jresult = (jboolean)result; 
1590   {
1591     jstring jnewstring = NULL;
1592     if (arg5) {
1593       jnewstring = jenv->NewStringUTF(arg5->c_str());
1594     }
1595     jenv->SetObjectArrayElement(jarg5, 0, jnewstring);
1596   }
1597   return jresult;
1598 }
1599
1600
1601 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) {
1602   jboolean jresult = 0 ;
1603   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1604   ScicosID arg2 ;
1605   kind_t arg3 ;
1606   object_properties_t arg4 ;
1607   ScicosID *arg5 = 0 ;
1608   ScicosID temp5 ;
1609   bool result;
1610   
1611   (void)jenv;
1612   (void)jcls;
1613   (void)jarg1_;
1614   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1615   arg2 = (ScicosID)jarg2; 
1616   arg3 = (kind_t)jarg3; 
1617   arg4 = (object_properties_t)jarg4; 
1618   {
1619     if (!jarg5) {
1620       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1621       return 0;
1622     }
1623     if (jenv->GetArrayLength(jarg5) == 0) {
1624       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1625       return 0;
1626     }
1627     temp5 = (ScicosID)0;
1628     arg5 = &temp5; 
1629   }
1630   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1631   jresult = (jboolean)result; 
1632   {
1633     jlong jvalue = (jlong)temp5;
1634     jenv->SetLongArrayRegion(jarg5, 0, 1, &jvalue);
1635   }
1636   
1637   return jresult;
1638 }
1639
1640
1641 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_) {
1642   jboolean jresult = 0 ;
1643   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1644   ScicosID arg2 ;
1645   kind_t arg3 ;
1646   object_properties_t arg4 ;
1647   std::vector< double > *arg5 = 0 ;
1648   bool result;
1649   
1650   (void)jenv;
1651   (void)jcls;
1652   (void)jarg1_;
1653   (void)jarg5_;
1654   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1655   arg2 = (ScicosID)jarg2; 
1656   arg3 = (kind_t)jarg3; 
1657   arg4 = (object_properties_t)jarg4; 
1658   arg5 = *(std::vector< double > **)&jarg5;
1659   if (!arg5) {
1660     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< double > & reference is null");
1661     return 0;
1662   } 
1663   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1664   jresult = (jboolean)result; 
1665   return jresult;
1666 }
1667
1668
1669 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_) {
1670   jboolean jresult = 0 ;
1671   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1672   ScicosID arg2 ;
1673   kind_t arg3 ;
1674   object_properties_t arg4 ;
1675   std::vector< int > *arg5 = 0 ;
1676   bool result;
1677   
1678   (void)jenv;
1679   (void)jcls;
1680   (void)jarg1_;
1681   (void)jarg5_;
1682   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1683   arg2 = (ScicosID)jarg2; 
1684   arg3 = (kind_t)jarg3; 
1685   arg4 = (object_properties_t)jarg4; 
1686   arg5 = *(std::vector< int > **)&jarg5;
1687   if (!arg5) {
1688     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > & reference is null");
1689     return 0;
1690   } 
1691   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1692   jresult = (jboolean)result; 
1693   return jresult;
1694 }
1695
1696
1697 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_) {
1698   jboolean jresult = 0 ;
1699   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1700   ScicosID arg2 ;
1701   kind_t arg3 ;
1702   object_properties_t arg4 ;
1703   std::vector< bool > *arg5 = 0 ;
1704   bool result;
1705   
1706   (void)jenv;
1707   (void)jcls;
1708   (void)jarg1_;
1709   (void)jarg5_;
1710   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1711   arg2 = (ScicosID)jarg2; 
1712   arg3 = (kind_t)jarg3; 
1713   arg4 = (object_properties_t)jarg4; 
1714   arg5 = *(std::vector< bool > **)&jarg5;
1715   if (!arg5) {
1716     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< bool > & reference is null");
1717     return 0;
1718   } 
1719   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1720   jresult = (jboolean)result; 
1721   return jresult;
1722 }
1723
1724
1725 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_) {
1726   jboolean jresult = 0 ;
1727   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1728   ScicosID arg2 ;
1729   kind_t arg3 ;
1730   object_properties_t arg4 ;
1731   std::vector< std::string > *arg5 = 0 ;
1732   bool result;
1733   
1734   (void)jenv;
1735   (void)jcls;
1736   (void)jarg1_;
1737   (void)jarg5_;
1738   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1739   arg2 = (ScicosID)jarg2; 
1740   arg3 = (kind_t)jarg3; 
1741   arg4 = (object_properties_t)jarg4; 
1742   arg5 = *(std::vector< std::string > **)&jarg5;
1743   if (!arg5) {
1744     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > & reference is null");
1745     return 0;
1746   } 
1747   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1748   jresult = (jboolean)result; 
1749   return jresult;
1750 }
1751
1752
1753 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_) {
1754   jboolean jresult = 0 ;
1755   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1756   ScicosID arg2 ;
1757   kind_t arg3 ;
1758   object_properties_t arg4 ;
1759   std::vector< ScicosID > *arg5 = 0 ;
1760   bool result;
1761   
1762   (void)jenv;
1763   (void)jcls;
1764   (void)jarg1_;
1765   (void)jarg5_;
1766   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1767   arg2 = (ScicosID)jarg2; 
1768   arg3 = (kind_t)jarg3; 
1769   arg4 = (object_properties_t)jarg4; 
1770   arg5 = *(std::vector< ScicosID > **)&jarg5;
1771   if (!arg5) {
1772     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ScicosID > & reference is null");
1773     return 0;
1774   } 
1775   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->getObjectProperty(arg2,arg3,arg4,*arg5);
1776   jresult = (jboolean)result; 
1777   return jresult;
1778 }
1779
1780
1781 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) {
1782   jint jresult = 0 ;
1783   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1784   ScicosID arg2 ;
1785   kind_t arg3 ;
1786   object_properties_t arg4 ;
1787   double arg5 ;
1788   update_status_t result;
1789   
1790   (void)jenv;
1791   (void)jcls;
1792   (void)jarg1_;
1793   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1794   arg2 = (ScicosID)jarg2; 
1795   arg3 = (kind_t)jarg3; 
1796   arg4 = (object_properties_t)jarg4; 
1797   arg5 = (double)jarg5; 
1798   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,arg5);
1799   jresult = (jint)result; 
1800   return jresult;
1801 }
1802
1803
1804 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) {
1805   jint jresult = 0 ;
1806   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1807   ScicosID arg2 ;
1808   kind_t arg3 ;
1809   object_properties_t arg4 ;
1810   int arg5 ;
1811   update_status_t result;
1812   
1813   (void)jenv;
1814   (void)jcls;
1815   (void)jarg1_;
1816   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1817   arg2 = (ScicosID)jarg2; 
1818   arg3 = (kind_t)jarg3; 
1819   arg4 = (object_properties_t)jarg4; 
1820   arg5 = (int)jarg5; 
1821   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,arg5);
1822   jresult = (jint)result; 
1823   return jresult;
1824 }
1825
1826
1827 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) {
1828   jint jresult = 0 ;
1829   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1830   ScicosID arg2 ;
1831   kind_t arg3 ;
1832   object_properties_t arg4 ;
1833   bool arg5 ;
1834   update_status_t result;
1835   
1836   (void)jenv;
1837   (void)jcls;
1838   (void)jarg1_;
1839   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1840   arg2 = (ScicosID)jarg2; 
1841   arg3 = (kind_t)jarg3; 
1842   arg4 = (object_properties_t)jarg4; 
1843   arg5 = jarg5 ? true : false; 
1844   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,arg5);
1845   jresult = (jint)result; 
1846   return jresult;
1847 }
1848
1849
1850 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) {
1851   jint jresult = 0 ;
1852   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1853   ScicosID arg2 ;
1854   kind_t arg3 ;
1855   object_properties_t arg4 ;
1856   ScicosID arg5 ;
1857   update_status_t result;
1858   
1859   (void)jenv;
1860   (void)jcls;
1861   (void)jarg1_;
1862   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1863   arg2 = (ScicosID)jarg2; 
1864   arg3 = (kind_t)jarg3; 
1865   arg4 = (object_properties_t)jarg4; 
1866   arg5 = (ScicosID)jarg5; 
1867   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,arg5);
1868   jresult = (jint)result; 
1869   return jresult;
1870 }
1871
1872
1873 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) {
1874   jint jresult = 0 ;
1875   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1876   ScicosID arg2 ;
1877   kind_t arg3 ;
1878   object_properties_t arg4 ;
1879   std::string *arg5 = 0 ;
1880   update_status_t result;
1881   
1882   (void)jenv;
1883   (void)jcls;
1884   (void)jarg1_;
1885   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1886   arg2 = (ScicosID)jarg2; 
1887   arg3 = (kind_t)jarg3; 
1888   arg4 = (object_properties_t)jarg4; 
1889   Swig::JavaString javaString(jenv, jarg5);
1890   *arg5 = std::string(javaString.c_str());
1891   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::string const &)*arg5);
1892   jresult = (jint)result; 
1893   
1894   return jresult;
1895 }
1896
1897
1898 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_) {
1899   jint jresult = 0 ;
1900   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1901   ScicosID arg2 ;
1902   kind_t arg3 ;
1903   object_properties_t arg4 ;
1904   std::vector< double > *arg5 = 0 ;
1905   update_status_t result;
1906   
1907   (void)jenv;
1908   (void)jcls;
1909   (void)jarg1_;
1910   (void)jarg5_;
1911   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1912   arg2 = (ScicosID)jarg2; 
1913   arg3 = (kind_t)jarg3; 
1914   arg4 = (object_properties_t)jarg4; 
1915   arg5 = *(std::vector< double > **)&jarg5;
1916   if (!arg5) {
1917     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< double > const & reference is null");
1918     return 0;
1919   } 
1920   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::vector< double > const &)*arg5);
1921   jresult = (jint)result; 
1922   return jresult;
1923 }
1924
1925
1926 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_) {
1927   jint jresult = 0 ;
1928   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1929   ScicosID arg2 ;
1930   kind_t arg3 ;
1931   object_properties_t arg4 ;
1932   std::vector< int > *arg5 = 0 ;
1933   update_status_t result;
1934   
1935   (void)jenv;
1936   (void)jcls;
1937   (void)jarg1_;
1938   (void)jarg5_;
1939   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1940   arg2 = (ScicosID)jarg2; 
1941   arg3 = (kind_t)jarg3; 
1942   arg4 = (object_properties_t)jarg4; 
1943   arg5 = *(std::vector< int > **)&jarg5;
1944   if (!arg5) {
1945     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > const & reference is null");
1946     return 0;
1947   } 
1948   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::vector< int > const &)*arg5);
1949   jresult = (jint)result; 
1950   return jresult;
1951 }
1952
1953
1954 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_) {
1955   jint jresult = 0 ;
1956   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1957   ScicosID arg2 ;
1958   kind_t arg3 ;
1959   object_properties_t arg4 ;
1960   std::vector< bool > *arg5 = 0 ;
1961   update_status_t result;
1962   
1963   (void)jenv;
1964   (void)jcls;
1965   (void)jarg1_;
1966   (void)jarg5_;
1967   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1968   arg2 = (ScicosID)jarg2; 
1969   arg3 = (kind_t)jarg3; 
1970   arg4 = (object_properties_t)jarg4; 
1971   arg5 = *(std::vector< bool > **)&jarg5;
1972   if (!arg5) {
1973     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< bool > const & reference is null");
1974     return 0;
1975   } 
1976   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::vector< bool > const &)*arg5);
1977   jresult = (jint)result; 
1978   return jresult;
1979 }
1980
1981
1982 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_) {
1983   jint jresult = 0 ;
1984   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1985   ScicosID arg2 ;
1986   kind_t arg3 ;
1987   object_properties_t arg4 ;
1988   std::vector< std::string > *arg5 = 0 ;
1989   update_status_t result;
1990   
1991   (void)jenv;
1992   (void)jcls;
1993   (void)jarg1_;
1994   (void)jarg5_;
1995   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1996   arg2 = (ScicosID)jarg2; 
1997   arg3 = (kind_t)jarg3; 
1998   arg4 = (object_properties_t)jarg4; 
1999   arg5 = *(std::vector< std::string > **)&jarg5;
2000   if (!arg5) {
2001     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & reference is null");
2002     return 0;
2003   } 
2004   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::vector< std::string > const &)*arg5);
2005   jresult = (jint)result; 
2006   return jresult;
2007 }
2008
2009
2010 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_) {
2011   jint jresult = 0 ;
2012   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
2013   ScicosID arg2 ;
2014   kind_t arg3 ;
2015   object_properties_t arg4 ;
2016   std::vector< ScicosID > *arg5 = 0 ;
2017   update_status_t result;
2018   
2019   (void)jenv;
2020   (void)jcls;
2021   (void)jarg1_;
2022   (void)jarg5_;
2023   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
2024   arg2 = (ScicosID)jarg2; 
2025   arg3 = (kind_t)jarg3; 
2026   arg4 = (object_properties_t)jarg4; 
2027   arg5 = *(std::vector< ScicosID > **)&jarg5;
2028   if (!arg5) {
2029     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ScicosID > const & reference is null");
2030     return 0;
2031   } 
2032   result = (update_status_t)(arg1)->setObjectProperty(arg2,arg3,arg4,(std::vector< ScicosID > const &)*arg5);
2033   jresult = (jint)result; 
2034   return jresult;
2035 }
2036
2037
2038 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2039   jlong jresult = 0 ;
2040   std::vector< int > *result = 0 ;
2041   
2042   (void)jenv;
2043   (void)jcls;
2044   result = (std::vector< int > *)new std::vector< int >();
2045   *(std::vector< int > **)&jresult = result; 
2046   return jresult;
2047 }
2048
2049
2050 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2051   jlong jresult = 0 ;
2052   std::vector< int >::size_type arg1 ;
2053   std::vector< int > *result = 0 ;
2054   
2055   (void)jenv;
2056   (void)jcls;
2057   arg1 = (std::vector< int >::size_type)jarg1; 
2058   result = (std::vector< int > *)new std::vector< int >(arg1);
2059   *(std::vector< int > **)&jresult = result; 
2060   return jresult;
2061 }
2062
2063
2064 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2065   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2066   std::vector< int >::size_type arg2 ;
2067   
2068   (void)jenv;
2069   (void)jcls;
2070   (void)jarg1_;
2071   arg1 = *(std::vector< int > **)&jarg1; 
2072   arg2 = (std::vector< int >::size_type)jarg2; 
2073   (arg1)->reserve(arg2);
2074 }
2075
2076
2077 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2078   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2079   std::vector< int >::size_type arg2 ;
2080   
2081   (void)jenv;
2082   (void)jcls;
2083   (void)jarg1_;
2084   arg1 = *(std::vector< int > **)&jarg1; 
2085   arg2 = (std::vector< int >::size_type)jarg2; 
2086   (arg1)->resize(arg2);
2087 }
2088
2089
2090 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2091   jint jresult = 0 ;
2092   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2093   int result;
2094   
2095   (void)jenv;
2096   (void)jcls;
2097   (void)jarg1_;
2098   arg1 = *(std::vector< int > **)&jarg1; 
2099   result = (int)((std::vector< int > const *)arg1)->size();
2100   jresult = (jint)result; 
2101   return jresult;
2102 }
2103
2104
2105 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2106   jboolean jresult = 0 ;
2107   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2108   bool result;
2109   
2110   (void)jenv;
2111   (void)jcls;
2112   (void)jarg1_;
2113   arg1 = *(std::vector< int > **)&jarg1; 
2114   result = (bool)((std::vector< int > const *)arg1)->empty();
2115   jresult = (jboolean)result; 
2116   return jresult;
2117 }
2118
2119
2120 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2121   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2122   
2123   (void)jenv;
2124   (void)jcls;
2125   (void)jarg1_;
2126   arg1 = *(std::vector< int > **)&jarg1; 
2127   (arg1)->clear();
2128 }
2129
2130
2131 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2132   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2133   std::vector< int >::value_type *arg2 = 0 ;
2134   std::vector< int >::value_type temp2 ;
2135   
2136   (void)jenv;
2137   (void)jcls;
2138   (void)jarg1_;
2139   arg1 = *(std::vector< int > **)&jarg1; 
2140   temp2 = (std::vector< int >::value_type)jarg2; 
2141   arg2 = &temp2; 
2142   (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
2143 }
2144
2145
2146 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2147   jboolean jresult = 0 ;
2148   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2149   int *arg2 = 0 ;
2150   int temp2 ;
2151   bool result;
2152   
2153   (void)jenv;
2154   (void)jcls;
2155   (void)jarg1_;
2156   arg1 = *(std::vector< int > **)&jarg1; 
2157   temp2 = (int)jarg2; 
2158   arg2 = &temp2; 
2159   result = (bool)std_vector_Sl_int_Sg__contains(arg1,(int const &)*arg2);
2160   jresult = (jboolean)result; 
2161   return jresult;
2162 }
2163
2164
2165 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2166   jint jresult = 0 ;
2167   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2168   int *arg2 = 0 ;
2169   int temp2 ;
2170   int result;
2171   
2172   (void)jenv;
2173   (void)jcls;
2174   (void)jarg1_;
2175   arg1 = *(std::vector< int > **)&jarg1; 
2176   temp2 = (int)jarg2; 
2177   arg2 = &temp2; 
2178   result = (int)std_vector_Sl_int_Sg__indexOf(arg1,(int const &)*arg2);
2179   jresult = (jint)result; 
2180   return jresult;
2181 }
2182
2183
2184 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2185   jint jresult = 0 ;
2186   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2187   int arg2 ;
2188   std::vector< int >::value_type *result = 0 ;
2189   
2190   (void)jenv;
2191   (void)jcls;
2192   (void)jarg1_;
2193   arg1 = *(std::vector< int > **)&jarg1; 
2194   arg2 = (int)jarg2; 
2195   try {
2196     result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__get(arg1,arg2);
2197   }
2198   catch(std::out_of_range &_e) {
2199     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2200     return 0;
2201   }
2202   
2203   jresult = (jint)*result; 
2204   return jresult;
2205 }
2206
2207
2208 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2209   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2210   int arg2 ;
2211   std::vector< int >::value_type *arg3 = 0 ;
2212   std::vector< int >::value_type temp3 ;
2213   
2214   (void)jenv;
2215   (void)jcls;
2216   (void)jarg1_;
2217   arg1 = *(std::vector< int > **)&jarg1; 
2218   arg2 = (int)jarg2; 
2219   temp3 = (std::vector< int >::value_type)jarg3; 
2220   arg3 = &temp3; 
2221   try {
2222     std_vector_Sl_int_Sg__set(arg1,arg2,(int const &)*arg3);
2223   }
2224   catch(std::out_of_range &_e) {
2225     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2226     return ;
2227   }
2228   
2229 }
2230
2231
2232 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) {
2233   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2234   int arg2 ;
2235   std::vector< int >::value_type *arg3 = 0 ;
2236   std::vector< int >::value_type temp3 ;
2237   
2238   (void)jenv;
2239   (void)jcls;
2240   (void)jarg1_;
2241   arg1 = *(std::vector< int > **)&jarg1; 
2242   arg2 = (int)jarg2; 
2243   temp3 = (std::vector< int >::value_type)jarg3; 
2244   arg3 = &temp3; 
2245   try {
2246     std_vector_Sl_int_Sg__add__SWIG_1(arg1,arg2,(int const &)*arg3);
2247   }
2248   catch(std::out_of_range &_e) {
2249     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2250     return ;
2251   }
2252   
2253 }
2254
2255
2256 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2257   jboolean jresult = 0 ;
2258   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2259   std::vector< int >::value_type *arg2 = 0 ;
2260   std::vector< int >::value_type temp2 ;
2261   bool result;
2262   
2263   (void)jenv;
2264   (void)jcls;
2265   (void)jarg1_;
2266   arg1 = *(std::vector< int > **)&jarg1; 
2267   temp2 = (std::vector< int >::value_type)jarg2; 
2268   arg2 = &temp2; 
2269   result = (bool)std_vector_Sl_int_Sg__remove(arg1,(int const &)*arg2);
2270   jresult = (jboolean)result; 
2271   return jresult;
2272 }
2273
2274
2275 SWIGEXPORT jobject JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1asByteBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2276   jobject jresult = 0 ;
2277   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2278   int arg2 ;
2279   int arg3 ;
2280   void *result = 0 ;
2281   
2282   (void)jenv;
2283   (void)jcls;
2284   (void)jarg1_;
2285   arg1 = *(std::vector< int > **)&jarg1; 
2286   arg2 = (int)jarg2; 
2287   arg3 = (int)jarg3; 
2288   result = (void *)std_vector_Sl_int_Sg__asByteBuffer(arg1,arg2,arg3);
2289   {
2290     if (arg3 <= 0) {
2291       arg3 = arg1->size() - arg2;
2292     } else if (arg1->size() < arg3) {
2293       throw std::out_of_range("vector index out of range");
2294     }
2295     jresult = jenv->NewDirectByteBuffer(result, arg3 * sizeof(decltype(arg1->back())));
2296   }
2297   return jresult;
2298 }
2299
2300
2301 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfInt(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2302   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2303   
2304   (void)jenv;
2305   (void)jcls;
2306   arg1 = *(std::vector< int > **)&jarg1; 
2307   delete arg1;
2308 }
2309
2310
2311 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2312   jlong jresult = 0 ;
2313   std::vector< bool > *result = 0 ;
2314   
2315   (void)jenv;
2316   (void)jcls;
2317   result = (std::vector< bool > *)new std::vector< bool >();
2318   *(std::vector< bool > **)&jresult = result; 
2319   return jresult;
2320 }
2321
2322
2323 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2324   jlong jresult = 0 ;
2325   std::vector< bool >::size_type arg1 ;
2326   std::vector< bool > *result = 0 ;
2327   
2328   (void)jenv;
2329   (void)jcls;
2330   arg1 = (std::vector< bool >::size_type)jarg1; 
2331   result = (std::vector< bool > *)new std::vector< bool >(arg1);
2332   *(std::vector< bool > **)&jresult = result; 
2333   return jresult;
2334 }
2335
2336
2337 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2338   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2339   std::vector< bool >::size_type arg2 ;
2340   
2341   (void)jenv;
2342   (void)jcls;
2343   (void)jarg1_;
2344   arg1 = *(std::vector< bool > **)&jarg1; 
2345   arg2 = (std::vector< bool >::size_type)jarg2; 
2346   (arg1)->reserve(arg2);
2347 }
2348
2349
2350 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2351   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2352   std::vector< bool >::size_type arg2 ;
2353   
2354   (void)jenv;
2355   (void)jcls;
2356   (void)jarg1_;
2357   arg1 = *(std::vector< bool > **)&jarg1; 
2358   arg2 = (std::vector< bool >::size_type)jarg2; 
2359   (arg1)->resize(arg2);
2360 }
2361
2362
2363 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2364   jint jresult = 0 ;
2365   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2366   int result;
2367   
2368   (void)jenv;
2369   (void)jcls;
2370   (void)jarg1_;
2371   arg1 = *(std::vector< bool > **)&jarg1; 
2372   result = (int)((std::vector< bool > const *)arg1)->size();
2373   jresult = (jint)result; 
2374   return jresult;
2375 }
2376
2377
2378 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2379   jboolean jresult = 0 ;
2380   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2381   bool result;
2382   
2383   (void)jenv;
2384   (void)jcls;
2385   (void)jarg1_;
2386   arg1 = *(std::vector< bool > **)&jarg1; 
2387   result = (bool)((std::vector< bool > const *)arg1)->empty();
2388   jresult = (jboolean)result; 
2389   return jresult;
2390 }
2391
2392
2393 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2394   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2395   
2396   (void)jenv;
2397   (void)jcls;
2398   (void)jarg1_;
2399   arg1 = *(std::vector< bool > **)&jarg1; 
2400   (arg1)->clear();
2401 }
2402
2403
2404 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
2405   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2406   std::vector< bool >::value_type *arg2 = 0 ;
2407   std::vector< bool >::value_type temp2 ;
2408   
2409   (void)jenv;
2410   (void)jcls;
2411   (void)jarg1_;
2412   arg1 = *(std::vector< bool > **)&jarg1; 
2413   temp2 = jarg2 ? true : false; 
2414   arg2 = &temp2; 
2415   (arg1)->push_back((std::vector< bool >::value_type const &)*arg2);
2416 }
2417
2418
2419 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2420   jboolean jresult = 0 ;
2421   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2422   int arg2 ;
2423   bool result;
2424   
2425   (void)jenv;
2426   (void)jcls;
2427   (void)jarg1_;
2428   arg1 = *(std::vector< bool > **)&jarg1; 
2429   arg2 = (int)jarg2; 
2430   try {
2431     result = (bool)std_vector_Sl_bool_Sg__get(arg1,arg2);
2432   }
2433   catch(std::out_of_range &_e) {
2434     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2435     return 0;
2436   }
2437   
2438   jresult = (jboolean)result; 
2439   return jresult;
2440 }
2441
2442
2443 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
2444   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2445   int arg2 ;
2446   std::vector< bool >::value_type *arg3 = 0 ;
2447   std::vector< bool >::value_type temp3 ;
2448   
2449   (void)jenv;
2450   (void)jcls;
2451   (void)jarg1_;
2452   arg1 = *(std::vector< bool > **)&jarg1; 
2453   arg2 = (int)jarg2; 
2454   temp3 = jarg3 ? true : false; 
2455   arg3 = &temp3; 
2456   try {
2457     std_vector_Sl_bool_Sg__set(arg1,arg2,(bool const &)*arg3);
2458   }
2459   catch(std::out_of_range &_e) {
2460     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2461     return ;
2462   }
2463   
2464 }
2465
2466
2467 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) {
2468   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2469   int arg2 ;
2470   std::vector< bool >::value_type *arg3 = 0 ;
2471   std::vector< bool >::value_type temp3 ;
2472   
2473   (void)jenv;
2474   (void)jcls;
2475   (void)jarg1_;
2476   arg1 = *(std::vector< bool > **)&jarg1; 
2477   arg2 = (int)jarg2; 
2478   temp3 = jarg3 ? true : false; 
2479   arg3 = &temp3; 
2480   try {
2481     std_vector_Sl_bool_Sg__add__SWIG_1(arg1,arg2,(bool const &)*arg3);
2482   }
2483   catch(std::out_of_range &_e) {
2484     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2485     return ;
2486   }
2487   
2488 }
2489
2490
2491 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
2492   jboolean jresult = 0 ;
2493   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2494   std::vector< bool >::value_type *arg2 = 0 ;
2495   std::vector< bool >::value_type temp2 ;
2496   bool result;
2497   
2498   (void)jenv;
2499   (void)jcls;
2500   (void)jarg1_;
2501   arg1 = *(std::vector< bool > **)&jarg1; 
2502   temp2 = jarg2 ? true : false; 
2503   arg2 = &temp2; 
2504   result = (bool)std_vector_Sl_bool_Sg__remove(arg1,(bool const &)*arg2);
2505   jresult = (jboolean)result; 
2506   return jresult;
2507 }
2508
2509
2510 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfBool(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2511   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2512   
2513   (void)jenv;
2514   (void)jcls;
2515   arg1 = *(std::vector< bool > **)&jarg1; 
2516   delete arg1;
2517 }
2518
2519
2520 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2521   jlong jresult = 0 ;
2522   std::vector< double > *result = 0 ;
2523   
2524   (void)jenv;
2525   (void)jcls;
2526   result = (std::vector< double > *)new std::vector< double >();
2527   *(std::vector< double > **)&jresult = result; 
2528   return jresult;
2529 }
2530
2531
2532 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2533   jlong jresult = 0 ;
2534   std::vector< double >::size_type arg1 ;
2535   std::vector< double > *result = 0 ;
2536   
2537   (void)jenv;
2538   (void)jcls;
2539   arg1 = (std::vector< double >::size_type)jarg1; 
2540   result = (std::vector< double > *)new std::vector< double >(arg1);
2541   *(std::vector< double > **)&jresult = result; 
2542   return jresult;
2543 }
2544
2545
2546 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2547   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2548   std::vector< double >::size_type arg2 ;
2549   
2550   (void)jenv;
2551   (void)jcls;
2552   (void)jarg1_;
2553   arg1 = *(std::vector< double > **)&jarg1; 
2554   arg2 = (std::vector< double >::size_type)jarg2; 
2555   (arg1)->reserve(arg2);
2556 }
2557
2558
2559 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2560   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2561   std::vector< double >::size_type arg2 ;
2562   
2563   (void)jenv;
2564   (void)jcls;
2565   (void)jarg1_;
2566   arg1 = *(std::vector< double > **)&jarg1; 
2567   arg2 = (std::vector< double >::size_type)jarg2; 
2568   (arg1)->resize(arg2);
2569 }
2570
2571
2572 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2573   jint jresult = 0 ;
2574   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2575   int result;
2576   
2577   (void)jenv;
2578   (void)jcls;
2579   (void)jarg1_;
2580   arg1 = *(std::vector< double > **)&jarg1; 
2581   result = (int)((std::vector< double > const *)arg1)->size();
2582   jresult = (jint)result; 
2583   return jresult;
2584 }
2585
2586
2587 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2588   jboolean jresult = 0 ;
2589   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2590   bool result;
2591   
2592   (void)jenv;
2593   (void)jcls;
2594   (void)jarg1_;
2595   arg1 = *(std::vector< double > **)&jarg1; 
2596   result = (bool)((std::vector< double > const *)arg1)->empty();
2597   jresult = (jboolean)result; 
2598   return jresult;
2599 }
2600
2601
2602 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2603   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2604   
2605   (void)jenv;
2606   (void)jcls;
2607   (void)jarg1_;
2608   arg1 = *(std::vector< double > **)&jarg1; 
2609   (arg1)->clear();
2610 }
2611
2612
2613 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2614   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2615   std::vector< double >::value_type *arg2 = 0 ;
2616   std::vector< double >::value_type temp2 ;
2617   
2618   (void)jenv;
2619   (void)jcls;
2620   (void)jarg1_;
2621   arg1 = *(std::vector< double > **)&jarg1; 
2622   temp2 = (std::vector< double >::value_type)jarg2; 
2623   arg2 = &temp2; 
2624   (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
2625 }
2626
2627
2628 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2629   jboolean jresult = 0 ;
2630   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2631   double *arg2 = 0 ;
2632   double temp2 ;
2633   bool result;
2634   
2635   (void)jenv;
2636   (void)jcls;
2637   (void)jarg1_;
2638   arg1 = *(std::vector< double > **)&jarg1; 
2639   temp2 = (double)jarg2; 
2640   arg2 = &temp2; 
2641   result = (bool)std_vector_Sl_double_Sg__contains(arg1,(double const &)*arg2);
2642   jresult = (jboolean)result; 
2643   return jresult;
2644 }
2645
2646
2647 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2648   jint jresult = 0 ;
2649   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2650   double *arg2 = 0 ;
2651   double temp2 ;
2652   int result;
2653   
2654   (void)jenv;
2655   (void)jcls;
2656   (void)jarg1_;
2657   arg1 = *(std::vector< double > **)&jarg1; 
2658   temp2 = (double)jarg2; 
2659   arg2 = &temp2; 
2660   result = (int)std_vector_Sl_double_Sg__indexOf(arg1,(double const &)*arg2);
2661   jresult = (jint)result; 
2662   return jresult;
2663 }
2664
2665
2666 SWIGEXPORT jdouble JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2667   jdouble jresult = 0 ;
2668   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2669   int arg2 ;
2670   std::vector< double >::value_type *result = 0 ;
2671   
2672   (void)jenv;
2673   (void)jcls;
2674   (void)jarg1_;
2675   arg1 = *(std::vector< double > **)&jarg1; 
2676   arg2 = (int)jarg2; 
2677   try {
2678     result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__get(arg1,arg2);
2679   }
2680   catch(std::out_of_range &_e) {
2681     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2682     return 0;
2683   }
2684   
2685   jresult = (jdouble)*result; 
2686   return jresult;
2687 }
2688
2689
2690 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) {
2691   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2692   int arg2 ;
2693   std::vector< double >::value_type *arg3 = 0 ;
2694   std::vector< double >::value_type temp3 ;
2695   
2696   (void)jenv;
2697   (void)jcls;
2698   (void)jarg1_;
2699   arg1 = *(std::vector< double > **)&jarg1; 
2700   arg2 = (int)jarg2; 
2701   temp3 = (std::vector< double >::value_type)jarg3; 
2702   arg3 = &temp3; 
2703   try {
2704     std_vector_Sl_double_Sg__set(arg1,arg2,(double const &)*arg3);
2705   }
2706   catch(std::out_of_range &_e) {
2707     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2708     return ;
2709   }
2710   
2711 }
2712
2713
2714 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) {
2715   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2716   int arg2 ;
2717   std::vector< double >::value_type *arg3 = 0 ;
2718   std::vector< double >::value_type temp3 ;
2719   
2720   (void)jenv;
2721   (void)jcls;
2722   (void)jarg1_;
2723   arg1 = *(std::vector< double > **)&jarg1; 
2724   arg2 = (int)jarg2; 
2725   temp3 = (std::vector< double >::value_type)jarg3; 
2726   arg3 = &temp3; 
2727   try {
2728     std_vector_Sl_double_Sg__add__SWIG_1(arg1,arg2,(double const &)*arg3);
2729   }
2730   catch(std::out_of_range &_e) {
2731     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2732     return ;
2733   }
2734   
2735 }
2736
2737
2738 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2739   jboolean jresult = 0 ;
2740   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2741   std::vector< double >::value_type *arg2 = 0 ;
2742   std::vector< double >::value_type temp2 ;
2743   bool result;
2744   
2745   (void)jenv;
2746   (void)jcls;
2747   (void)jarg1_;
2748   arg1 = *(std::vector< double > **)&jarg1; 
2749   temp2 = (std::vector< double >::value_type)jarg2; 
2750   arg2 = &temp2; 
2751   result = (bool)std_vector_Sl_double_Sg__remove(arg1,(double const &)*arg2);
2752   jresult = (jboolean)result; 
2753   return jresult;
2754 }
2755
2756
2757 SWIGEXPORT jobject JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1asByteBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
2758   jobject jresult = 0 ;
2759   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2760   int arg2 ;
2761   int arg3 ;
2762   void *result = 0 ;
2763   
2764   (void)jenv;
2765   (void)jcls;
2766   (void)jarg1_;
2767   arg1 = *(std::vector< double > **)&jarg1; 
2768   arg2 = (int)jarg2; 
2769   arg3 = (int)jarg3; 
2770   result = (void *)std_vector_Sl_double_Sg__asByteBuffer(arg1,arg2,arg3);
2771   {
2772     if (arg3 <= 0) {
2773       arg3 = arg1->size() - arg2;
2774     } else if (arg1->size() < arg3) {
2775       throw std::out_of_range("vector index out of range");
2776     }
2777     jresult = jenv->NewDirectByteBuffer(result, arg3 * sizeof(decltype(arg1->back())));
2778   }
2779   return jresult;
2780 }
2781
2782
2783 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfDouble(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2784   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
2785   
2786   (void)jenv;
2787   (void)jcls;
2788   arg1 = *(std::vector< double > **)&jarg1; 
2789   delete arg1;
2790 }
2791
2792
2793 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2794   jlong jresult = 0 ;
2795   std::vector< std::string > *result = 0 ;
2796   
2797   (void)jenv;
2798   (void)jcls;
2799   result = (std::vector< std::string > *)new std::vector< std::string >();
2800   *(std::vector< std::string > **)&jresult = result; 
2801   return jresult;
2802 }
2803
2804
2805 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2806   jlong jresult = 0 ;
2807   std::vector< std::string >::size_type arg1 ;
2808   std::vector< std::string > *result = 0 ;
2809   
2810   (void)jenv;
2811   (void)jcls;
2812   arg1 = (std::vector< std::string >::size_type)jarg1; 
2813   result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
2814   *(std::vector< std::string > **)&jresult = result; 
2815   return jresult;
2816 }
2817
2818
2819 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2820   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2821   std::vector< std::string >::size_type arg2 ;
2822   
2823   (void)jenv;
2824   (void)jcls;
2825   (void)jarg1_;
2826   arg1 = *(std::vector< std::string > **)&jarg1; 
2827   arg2 = (std::vector< std::string >::size_type)jarg2; 
2828   (arg1)->reserve(arg2);
2829 }
2830
2831
2832 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2833   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2834   std::vector< std::string >::size_type arg2 ;
2835   
2836   (void)jenv;
2837   (void)jcls;
2838   (void)jarg1_;
2839   arg1 = *(std::vector< std::string > **)&jarg1; 
2840   arg2 = (std::vector< std::string >::size_type)jarg2; 
2841   (arg1)->resize(arg2);
2842 }
2843
2844
2845 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2846   jint jresult = 0 ;
2847   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2848   int result;
2849   
2850   (void)jenv;
2851   (void)jcls;
2852   (void)jarg1_;
2853   arg1 = *(std::vector< std::string > **)&jarg1; 
2854   result = (int)((std::vector< std::string > const *)arg1)->size();
2855   jresult = (jint)result; 
2856   return jresult;
2857 }
2858
2859
2860 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2861   jboolean jresult = 0 ;
2862   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2863   bool result;
2864   
2865   (void)jenv;
2866   (void)jcls;
2867   (void)jarg1_;
2868   arg1 = *(std::vector< std::string > **)&jarg1; 
2869   result = (bool)((std::vector< std::string > const *)arg1)->empty();
2870   jresult = (jboolean)result; 
2871   return jresult;
2872 }
2873
2874
2875 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2876   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2877   
2878   (void)jenv;
2879   (void)jcls;
2880   (void)jarg1_;
2881   arg1 = *(std::vector< std::string > **)&jarg1; 
2882   (arg1)->clear();
2883 }
2884
2885
2886 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2887   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2888   std::vector< std::string >::value_type *arg2 = 0 ;
2889   
2890   (void)jenv;
2891   (void)jcls;
2892   (void)jarg1_;
2893   arg1 = *(std::vector< std::string > **)&jarg1; 
2894   Swig::JavaString javaString(jenv, jarg2);
2895   *arg2 = std::string(javaString.c_str());
2896   (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
2897   
2898 }
2899
2900
2901 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2902   jboolean jresult = 0 ;
2903   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2904   std::string *arg2 = 0 ;
2905   bool result;
2906   
2907   (void)jenv;
2908   (void)jcls;
2909   (void)jarg1_;
2910   arg1 = *(std::vector< std::string > **)&jarg1; 
2911   Swig::JavaString javaString(jenv, jarg2);
2912   *arg2 = std::string(javaString.c_str());
2913   result = (bool)std_vector_Sl_std_string_Sg__contains(arg1,(std::string const &)*arg2);
2914   jresult = (jboolean)result; 
2915   
2916   return jresult;
2917 }
2918
2919
2920 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2921   jint jresult = 0 ;
2922   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2923   std::string *arg2 = 0 ;
2924   int result;
2925   
2926   (void)jenv;
2927   (void)jcls;
2928   (void)jarg1_;
2929   arg1 = *(std::vector< std::string > **)&jarg1; 
2930   Swig::JavaString javaString(jenv, jarg2);
2931   *arg2 = std::string(javaString.c_str());
2932   result = (int)std_vector_Sl_std_string_Sg__indexOf(arg1,(std::string const &)*arg2);
2933   jresult = (jint)result; 
2934   
2935   return jresult;
2936 }
2937
2938
2939 SWIGEXPORT jstring JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2940   jstring jresult = 0 ;
2941   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2942   int arg2 ;
2943   std::vector< std::string >::value_type *result = 0 ;
2944   
2945   (void)jenv;
2946   (void)jcls;
2947   (void)jarg1_;
2948   arg1 = *(std::vector< std::string > **)&jarg1; 
2949   arg2 = (int)jarg2; 
2950   try {
2951     result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__get(arg1,arg2);
2952   }
2953   catch(std::out_of_range &_e) {
2954     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2955     return 0;
2956   }
2957   
2958   jresult = jenv->NewStringUTF(result->c_str()); 
2959   return jresult;
2960 }
2961
2962
2963 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
2964   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2965   int arg2 ;
2966   std::vector< std::string >::value_type *arg3 = 0 ;
2967   
2968   (void)jenv;
2969   (void)jcls;
2970   (void)jarg1_;
2971   arg1 = *(std::vector< std::string > **)&jarg1; 
2972   arg2 = (int)jarg2; 
2973   Swig::JavaString javaString(jenv, jarg3);
2974   *arg3 = std::string(javaString.c_str());
2975   try {
2976     std_vector_Sl_std_string_Sg__set(arg1,arg2,(std::string const &)*arg3);
2977   }
2978   catch(std::out_of_range &_e) {
2979     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2980     return ;
2981   }
2982   
2983   
2984 }
2985
2986
2987 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) {
2988   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2989   int arg2 ;
2990   std::vector< std::string >::value_type *arg3 = 0 ;
2991   
2992   (void)jenv;
2993   (void)jcls;
2994   (void)jarg1_;
2995   arg1 = *(std::vector< std::string > **)&jarg1; 
2996   arg2 = (int)jarg2; 
2997   Swig::JavaString javaString(jenv, jarg3);
2998   *arg3 = std::string(javaString.c_str());
2999   try {
3000     std_vector_Sl_std_string_Sg__add__SWIG_1(arg1,arg2,(std::string const &)*arg3);
3001   }
3002   catch(std::out_of_range &_e) {
3003     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3004     return ;
3005   }
3006   
3007   
3008 }
3009
3010
3011 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
3012   jboolean jresult = 0 ;
3013   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
3014   std::vector< std::string >::value_type *arg2 = 0 ;
3015   bool result;
3016   
3017   (void)jenv;
3018   (void)jcls;
3019   (void)jarg1_;
3020   arg1 = *(std::vector< std::string > **)&jarg1; 
3021   Swig::JavaString javaString(jenv, jarg2);
3022   *arg2 = std::string(javaString.c_str());
3023   result = (bool)std_vector_Sl_std_string_Sg__remove(arg1,(std::string const &)*arg2);
3024   jresult = (jboolean)result; 
3025   
3026   return jresult;
3027 }
3028
3029
3030 SWIGEXPORT jobject JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1asByteBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
3031   jobject jresult = 0 ;
3032   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
3033   int arg2 ;
3034   int arg3 ;
3035   void *result = 0 ;
3036   
3037   (void)jenv;
3038   (void)jcls;
3039   (void)jarg1_;
3040   arg1 = *(std::vector< std::string > **)&jarg1; 
3041   arg2 = (int)jarg2; 
3042   arg3 = (int)jarg3; 
3043   result = (void *)std_vector_Sl_std_string_Sg__asByteBuffer(arg1,arg2,arg3);
3044   {
3045     if (arg3 <= 0) {
3046       arg3 = arg1->size() - arg2;
3047     } else if (arg1->size() < arg3) {
3048       throw std::out_of_range("vector index out of range");
3049     }
3050     jresult = jenv->NewDirectByteBuffer(result, arg3 * sizeof(decltype(arg1->back())));
3051   }
3052   return jresult;
3053 }
3054
3055
3056 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfString(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3057   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
3058   
3059   (void)jenv;
3060   (void)jcls;
3061   arg1 = *(std::vector< std::string > **)&jarg1; 
3062   delete arg1;
3063 }
3064
3065
3066 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
3067   jlong jresult = 0 ;
3068   std::vector< ScicosID > *result = 0 ;
3069   
3070   (void)jenv;
3071   (void)jcls;
3072   result = (std::vector< ScicosID > *)new std::vector< ScicosID >();
3073   *(std::vector< ScicosID > **)&jresult = result; 
3074   return jresult;
3075 }
3076
3077
3078 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3079   jlong jresult = 0 ;
3080   std::vector< long long >::size_type arg1 ;
3081   std::vector< ScicosID > *result = 0 ;
3082   
3083   (void)jenv;
3084   (void)jcls;
3085   arg1 = (std::vector< long long >::size_type)jarg1; 
3086   result = (std::vector< ScicosID > *)new std::vector< ScicosID >(arg1);
3087   *(std::vector< ScicosID > **)&jresult = result; 
3088   return jresult;
3089 }
3090
3091
3092 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1ensureCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3093   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3094   std::vector< long long >::size_type arg2 ;
3095   
3096   (void)jenv;
3097   (void)jcls;
3098   (void)jarg1_;
3099   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3100   arg2 = (std::vector< long long >::size_type)jarg2; 
3101   (arg1)->reserve(arg2);
3102 }
3103
3104
3105 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1resize(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)->resize(arg2);
3115 }
3116
3117
3118 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3119   jint jresult = 0 ;
3120   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3121   int result;
3122   
3123   (void)jenv;
3124   (void)jcls;
3125   (void)jarg1_;
3126   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3127   result = (int)((std::vector< ScicosID > const *)arg1)->size();
3128   jresult = (jint)result; 
3129   return jresult;
3130 }
3131
3132
3133 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3134   jboolean jresult = 0 ;
3135   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3136   bool result;
3137   
3138   (void)jenv;
3139   (void)jcls;
3140   (void)jarg1_;
3141   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3142   result = (bool)((std::vector< ScicosID > const *)arg1)->empty();
3143   jresult = (jboolean)result; 
3144   return jresult;
3145 }
3146
3147
3148 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3149   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3150   
3151   (void)jenv;
3152   (void)jcls;
3153   (void)jarg1_;
3154   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3155   (arg1)->clear();
3156 }
3157
3158
3159 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1add_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3160   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3161   std::vector< long long >::value_type *arg2 = 0 ;
3162   std::vector< long long >::value_type temp2 ;
3163   
3164   (void)jenv;
3165   (void)jcls;
3166   (void)jarg1_;
3167   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3168   temp2 = (std::vector< long long >::value_type)jarg2; 
3169   arg2 = &temp2; 
3170   (arg1)->push_back((std::vector< long long >::value_type const &)*arg2);
3171 }
3172
3173
3174 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3175   jboolean jresult = 0 ;
3176   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3177   long long *arg2 = 0 ;
3178   long long temp2 ;
3179   bool result;
3180   
3181   (void)jenv;
3182   (void)jcls;
3183   (void)jarg1_;
3184   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3185   temp2 = (long long)jarg2; 
3186   arg2 = &temp2; 
3187   result = (bool)std_vector_Sl_ScicosID_Sg__contains(arg1,(long long const &)*arg2);
3188   jresult = (jboolean)result; 
3189   return jresult;
3190 }
3191
3192
3193 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1indexOf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3194   jint jresult = 0 ;
3195   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3196   long long *arg2 = 0 ;
3197   long long temp2 ;
3198   int result;
3199   
3200   (void)jenv;
3201   (void)jcls;
3202   (void)jarg1_;
3203   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3204   temp2 = (long long)jarg2; 
3205   arg2 = &temp2; 
3206   result = (int)std_vector_Sl_ScicosID_Sg__indexOf(arg1,(long long const &)*arg2);
3207   jresult = (jint)result; 
3208   return jresult;
3209 }
3210
3211
3212 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3213   jlong jresult = 0 ;
3214   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3215   int arg2 ;
3216   std::vector< long long >::value_type *result = 0 ;
3217   
3218   (void)jenv;
3219   (void)jcls;
3220   (void)jarg1_;
3221   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3222   arg2 = (int)jarg2; 
3223   try {
3224     result = (std::vector< long long >::value_type *) &std_vector_Sl_ScicosID_Sg__get(arg1,arg2);
3225   }
3226   catch(std::out_of_range &_e) {
3227     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3228     return 0;
3229   }
3230   
3231   jresult = (jlong)*result; 
3232   return jresult;
3233 }
3234
3235
3236 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
3237   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3238   int arg2 ;
3239   std::vector< long long >::value_type *arg3 = 0 ;
3240   std::vector< long long >::value_type temp3 ;
3241   
3242   (void)jenv;
3243   (void)jcls;
3244   (void)jarg1_;
3245   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3246   arg2 = (int)jarg2; 
3247   temp3 = (std::vector< long long >::value_type)jarg3; 
3248   arg3 = &temp3; 
3249   try {
3250     std_vector_Sl_ScicosID_Sg__set(arg1,arg2,(long long const &)*arg3);
3251   }
3252   catch(std::out_of_range &_e) {
3253     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3254     return ;
3255   }
3256   
3257 }
3258
3259
3260 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) {
3261   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3262   int arg2 ;
3263   std::vector< long long >::value_type *arg3 = 0 ;
3264   std::vector< long long >::value_type temp3 ;
3265   
3266   (void)jenv;
3267   (void)jcls;
3268   (void)jarg1_;
3269   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3270   arg2 = (int)jarg2; 
3271   temp3 = (std::vector< long long >::value_type)jarg3; 
3272   arg3 = &temp3; 
3273   try {
3274     std_vector_Sl_ScicosID_Sg__add__SWIG_1(arg1,arg2,(long long const &)*arg3);
3275   }
3276   catch(std::out_of_range &_e) {
3277     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
3278     return ;
3279   }
3280   
3281 }
3282
3283
3284 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
3285   jboolean jresult = 0 ;
3286   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3287   std::vector< long long >::value_type *arg2 = 0 ;
3288   std::vector< long long >::value_type temp2 ;
3289   bool result;
3290   
3291   (void)jenv;
3292   (void)jcls;
3293   (void)jarg1_;
3294   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3295   temp2 = (std::vector< long long >::value_type)jarg2; 
3296   arg2 = &temp2; 
3297   result = (bool)std_vector_Sl_ScicosID_Sg__remove(arg1,(long long const &)*arg2);
3298   jresult = (jboolean)result; 
3299   return jresult;
3300 }
3301
3302
3303 SWIGEXPORT jobject JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1asByteBuffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
3304   jobject jresult = 0 ;
3305   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3306   int arg2 ;
3307   int arg3 ;
3308   void *result = 0 ;
3309   
3310   (void)jenv;
3311   (void)jcls;
3312   (void)jarg1_;
3313   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3314   arg2 = (int)jarg2; 
3315   arg3 = (int)jarg3; 
3316   result = (void *)std_vector_Sl_ScicosID_Sg__asByteBuffer(arg1,arg2,arg3);
3317   {
3318     if (arg3 <= 0) {
3319       arg3 = arg1->size() - arg2;
3320     } else if (arg1->size() < arg3) {
3321       throw std::out_of_range("vector index out of range");
3322     }
3323     jresult = jenv->NewDirectByteBuffer(result, arg3 * sizeof(decltype(arg1->back())));
3324   }
3325   return jresult;
3326 }
3327
3328
3329 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfScicosID(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3330   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
3331   
3332   (void)jenv;
3333   (void)jcls;
3334   arg1 = *(std::vector< ScicosID > **)&jarg1; 
3335   delete arg1;
3336 }
3337
3338
3339 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_register_1view(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
3340   std::string *arg1 = 0 ;
3341   org_scilab_modules_scicos::View *arg2 = (org_scilab_modules_scicos::View *) 0 ;
3342   
3343   (void)jenv;
3344   (void)jcls;
3345   (void)jarg2_;
3346   Swig::JavaString javaString(jenv, jarg1);
3347   *arg1 = std::string(javaString.c_str());
3348   arg2 = *(org_scilab_modules_scicos::View **)&jarg2; 
3349   register_view((std::string const &)*arg1,arg2);
3350   
3351 }
3352
3353
3354 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_unregister_1view(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3355   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
3356   
3357   (void)jenv;
3358   (void)jcls;
3359   (void)jarg1_;
3360   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
3361   unregister_view(arg1);
3362 }
3363
3364
3365 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) {
3366   int i;
3367   
3368   static struct {
3369     const char *method;
3370     const char *signature;
3371   } methods[5] = {
3372     {
3373       "SwigDirector_View_objectCreated", "(Lorg/scilab/modules/xcos/View;JI)V" 
3374     },
3375     {
3376       "SwigDirector_View_objectReferenced", "(Lorg/scilab/modules/xcos/View;JIJ)V" 
3377     },
3378     {
3379       "SwigDirector_View_objectUnreferenced", "(Lorg/scilab/modules/xcos/View;JIJ)V" 
3380     },
3381     {
3382       "SwigDirector_View_objectDeleted", "(Lorg/scilab/modules/xcos/View;JI)V" 
3383     },
3384     {
3385       "SwigDirector_View_propertyUpdated", "(Lorg/scilab/modules/xcos/View;JIII)V" 
3386     }
3387   };
3388   Swig::jclass_JavaControllerJNI = (jclass) jenv->NewGlobalRef(jcls);
3389   if (!Swig::jclass_JavaControllerJNI) return;
3390   for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {
3391     Swig::director_method_ids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);
3392     if (!Swig::director_method_ids[i]) return;
3393   }
3394 }
3395
3396
3397 #ifdef __cplusplus
3398 }
3399 #endif
3400