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