Xcos MVC: standardize C++ code
[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.2
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10
11 #define SWIGJAVA
12 #define SWIG_DIRECTORS
13
14
15 #ifdef __cplusplus
16 /* SwigValueWrapper is described in swig.swg */
17 template<typename T> class SwigValueWrapper {
18   struct SwigMovePointer {
19     T *ptr;
20     SwigMovePointer(T *p) : ptr(p) { }
21     ~SwigMovePointer() { delete ptr; }
22     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
23   } pointer;
24   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
26 public:
27   SwigValueWrapper() : pointer(0) { }
28   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
29   operator T&() const { return *pointer.ptr; }
30   T *operator&() { return pointer.ptr; }
31 };
32
33 template <typename T> T SwigValueInit() {
34   return T();
35 }
36 #endif
37
38 /* -----------------------------------------------------------------------------
39  *  This section contains generic SWIG labels for method/variable
40  *  declarations/attributes, and other compiler dependent labels.
41  * ----------------------------------------------------------------------------- */
42
43 /* template workaround for compilers that cannot correctly implement the C++ standard */
44 #ifndef SWIGTEMPLATEDISAMBIGUATOR
45 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
46 #  define SWIGTEMPLATEDISAMBIGUATOR template
47 # elif defined(__HP_aCC)
48 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
49 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
50 #  define SWIGTEMPLATEDISAMBIGUATOR template
51 # else
52 #  define SWIGTEMPLATEDISAMBIGUATOR
53 # endif
54 #endif
55
56 /* inline attribute */
57 #ifndef SWIGINLINE
58 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
59 #   define SWIGINLINE inline
60 # else
61 #   define SWIGINLINE
62 # endif
63 #endif
64
65 /* attribute recognised by some compilers to avoid 'unused' warnings */
66 #ifndef SWIGUNUSED
67 # if defined(__GNUC__)
68 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
69 #     define SWIGUNUSED __attribute__ ((__unused__))
70 #   else
71 #     define SWIGUNUSED
72 #   endif
73 # elif defined(__ICC)
74 #   define SWIGUNUSED __attribute__ ((__unused__))
75 # else
76 #   define SWIGUNUSED
77 # endif
78 #endif
79
80 #ifndef SWIG_MSC_UNSUPPRESS_4505
81 # if defined(_MSC_VER)
82 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
83 # endif
84 #endif
85
86 #ifndef SWIGUNUSEDPARM
87 # ifdef __cplusplus
88 #   define SWIGUNUSEDPARM(p)
89 # else
90 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
91 # endif
92 #endif
93
94 /* internal SWIG method */
95 #ifndef SWIGINTERN
96 # define SWIGINTERN static SWIGUNUSED
97 #endif
98
99 /* internal inline SWIG method */
100 #ifndef SWIGINTERNINLINE
101 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
102 #endif
103
104 /* exporting methods */
105 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
106 #  ifndef GCC_HASCLASSVISIBILITY
107 #    define GCC_HASCLASSVISIBILITY
108 #  endif
109 #endif
110
111 #ifndef SWIGEXPORT
112 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
113 #   if defined(STATIC_LINKED)
114 #     define SWIGEXPORT
115 #   else
116 #     define SWIGEXPORT __declspec(dllexport)
117 #   endif
118 # else
119 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
120 #     define SWIGEXPORT __attribute__ ((visibility("default")))
121 #   else
122 #     define SWIGEXPORT
123 #   endif
124 # endif
125 #endif
126
127 /* calling conventions for Windows */
128 #ifndef SWIGSTDCALL
129 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
130 #   define SWIGSTDCALL __stdcall
131 # else
132 #   define SWIGSTDCALL
133 # endif
134 #endif
135
136 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
137 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
138 # define _CRT_SECURE_NO_DEPRECATE
139 #endif
140
141 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
142 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
143 # define _SCL_SECURE_NO_DEPRECATE
144 #endif
145
146
147
148 /* Fix for jlong on some versions of gcc on Windows */
149 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
150   typedef long long __int64;
151 #endif
152
153 /* Fix for jlong on 64-bit x86 Solaris */
154 #if defined(__x86_64)
155 # ifdef _LP64
156 #   undef _LP64
157 # endif
158 #endif
159
160 #include <jni.h>
161 #include <stdlib.h>
162 #include <string.h>
163
164
165 /* Support for throwing Java exceptions */
166 typedef enum {
167   SWIG_JavaOutOfMemoryError = 1, 
168   SWIG_JavaIOException, 
169   SWIG_JavaRuntimeException, 
170   SWIG_JavaIndexOutOfBoundsException,
171   SWIG_JavaArithmeticException,
172   SWIG_JavaIllegalArgumentException,
173   SWIG_JavaNullPointerException,
174   SWIG_JavaDirectorPureVirtual,
175   SWIG_JavaUnknownError
176 } SWIG_JavaExceptionCodes;
177
178 typedef struct {
179   SWIG_JavaExceptionCodes code;
180   const char *java_exception;
181 } SWIG_JavaExceptions_t;
182
183
184 static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
185   jclass excep;
186   static const SWIG_JavaExceptions_t java_exceptions[] = {
187     { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
188     { SWIG_JavaIOException, "java/io/IOException" },
189     { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
190     { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
191     { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
192     { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
193     { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
194     { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
195     { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
196     { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
197   };
198   const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
199
200   while (except_ptr->code != code && except_ptr->code)
201     except_ptr++;
202
203   jenv->ExceptionClear();
204   excep = jenv->FindClass(except_ptr->java_exception);
205   if (excep)
206     jenv->ThrowNew(excep, msg);
207 }
208
209
210 /* Contract support */
211
212 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else
213
214 /* -----------------------------------------------------------------------------
215  * director.swg
216  *
217  * This file contains support for director classes so that Java proxy
218  * methods can be called from C++.
219  * ----------------------------------------------------------------------------- */
220
221 #if defined(DEBUG_DIRECTOR_OWNED) || defined(DEBUG_DIRECTOR_EXCEPTION)
222 #include <iostream>
223 #endif
224
225 #include <exception>
226
227 namespace Swig {
228
229   /* Java object wrapper */
230   class JObjectWrapper {
231   public:
232     JObjectWrapper() : jthis_(NULL), weak_global_(true) {
233     }
234
235     ~JObjectWrapper() {
236       jthis_ = NULL;
237       weak_global_ = true;
238     }
239
240     bool set(JNIEnv *jenv, jobject jobj, bool mem_own, bool weak_global) {
241       if (!jthis_) {
242         weak_global_ = weak_global || !mem_own; // hold as weak global if explicitly requested or not owned
243         if (jobj)
244           jthis_ = weak_global_ ? jenv->NewWeakGlobalRef(jobj) : jenv->NewGlobalRef(jobj);
245 #if defined(DEBUG_DIRECTOR_OWNED)
246         std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> " << jthis_ << std::endl;
247 #endif
248         return true;
249       } else {
250 #if defined(DEBUG_DIRECTOR_OWNED)
251         std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> already set" << std::endl;
252 #endif
253         return false;
254       }
255     }
256
257     jobject get(JNIEnv *jenv) const {
258 #if defined(DEBUG_DIRECTOR_OWNED)
259       std::cout << "JObjectWrapper::get(";
260       if (jthis_)
261         std::cout << jthis_;
262       else
263         std::cout << "null";
264       std::cout << ") -> return new local ref" << std::endl;
265 #endif
266       return (jthis_ ? jenv->NewLocalRef(jthis_) : jthis_);
267     }
268
269     void release(JNIEnv *jenv) {
270 #if defined(DEBUG_DIRECTOR_OWNED)
271       std::cout << "JObjectWrapper::release(" << jthis_ << "): " << (weak_global_ ? "weak global ref" : "global ref") << std::endl;
272 #endif
273       if (jthis_) {
274         if (weak_global_) {
275           if (jenv->IsSameObject(jthis_, NULL) == JNI_FALSE)
276             jenv->DeleteWeakGlobalRef((jweak)jthis_);
277         } else
278           jenv->DeleteGlobalRef(jthis_);
279       }
280
281       jthis_ = NULL;
282       weak_global_ = true;
283     }
284
285     /* Only call peek if you know what you are doing wrt to weak/global references */
286     jobject peek() {
287       return jthis_;
288     }
289
290     /* Java proxy releases ownership of C++ object, C++ object is now
291        responsible for destruction (creates NewGlobalRef to pin Java proxy) */
292     void java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
293       if (take_or_release) {  /* Java takes ownership of C++ object's lifetime. */
294         if (!weak_global_) {
295           jenv->DeleteGlobalRef(jthis_);
296           jthis_ = jenv->NewWeakGlobalRef(jself);
297           weak_global_ = true;
298         }
299       } else {
300         /* Java releases ownership of C++ object's lifetime */
301         if (weak_global_) {
302           jenv->DeleteWeakGlobalRef((jweak)jthis_);
303           jthis_ = jenv->NewGlobalRef(jself);
304           weak_global_ = false;
305         }
306       }
307     }
308
309   private:
310     /* pointer to Java object */
311     jobject jthis_;
312     /* Local or global reference flag */
313     bool weak_global_;
314   };
315
316   /* director base class */
317   class Director {
318     /* pointer to Java virtual machine */
319     JavaVM *swig_jvm_;
320
321   protected:
322 #if defined (_MSC_VER) && (_MSC_VER<1300)
323     class JNIEnvWrapper;
324     friend class JNIEnvWrapper;
325 #endif
326     /* Utility class for managing the JNI environment */
327     class JNIEnvWrapper {
328       const Director *director_;
329       JNIEnv *jenv_;
330       int env_status;
331     public:
332       JNIEnvWrapper(const Director *director) : director_(director), jenv_(0), env_status(0) {
333 #if defined(__ANDROID__)
334         JNIEnv **jenv = &jenv_;
335 #else
336         void **jenv = (void **)&jenv_;
337 #endif
338         env_status = director_->swig_jvm_->GetEnv((void **)&jenv_, JNI_VERSION_1_2);
339 #if defined(SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON)
340         // Attach a daemon thread to the JVM. Useful when the JVM should not wait for
341         // the thread to exit upon shutdown. Only for jdk-1.4 and later.
342         director_->swig_jvm_->AttachCurrentThreadAsDaemon(jenv, NULL);
343 #else
344         director_->swig_jvm_->AttachCurrentThread(jenv, NULL);
345 #endif
346       }
347       ~JNIEnvWrapper() {
348 #if !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD)
349         // Some JVMs, eg jdk-1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call.
350         // However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak.
351         if (env_status == JNI_EDETACHED)
352           director_->swig_jvm_->DetachCurrentThread();
353 #endif
354       }
355       JNIEnv *getJNIEnv() const {
356         return jenv_;
357       }
358     };
359
360     /* Java object wrapper */
361     JObjectWrapper swig_self_;
362
363     /* Disconnect director from Java object */
364     void swig_disconnect_director_self(const char *disconn_method) {
365       JNIEnvWrapper jnienv(this) ;
366       JNIEnv *jenv = jnienv.getJNIEnv() ;
367       jobject jobj = swig_self_.get(jenv);
368 #if defined(DEBUG_DIRECTOR_OWNED)
369       std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl;
370 #endif
371       if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) {
372         jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(jobj), disconn_method, "()V");
373         if (disconn_meth) {
374 #if defined(DEBUG_DIRECTOR_OWNED)
375           std::cout << "Swig::Director::disconnect_director_self upcall to " << disconn_method << std::endl;
376 #endif
377           jenv->CallVoidMethod(jobj, disconn_meth);
378         }
379       }
380       jenv->DeleteLocalRef(jobj);
381     }
382
383   public:
384     Director(JNIEnv *jenv) : swig_jvm_((JavaVM *) NULL), swig_self_() {
385       /* Acquire the Java VM pointer */
386       jenv->GetJavaVM(&swig_jvm_);
387     }
388
389     virtual ~Director() {
390       JNIEnvWrapper jnienv(this) ;
391       JNIEnv *jenv = jnienv.getJNIEnv() ;
392       swig_self_.release(jenv);
393     }
394
395     bool swig_set_self(JNIEnv *jenv, jobject jself, bool mem_own, bool weak_global) {
396       return swig_self_.set(jenv, jself, mem_own, weak_global);
397     }
398
399     jobject swig_get_self(JNIEnv *jenv) const {
400       return swig_self_.get(jenv);
401     }
402
403     // Change C++ object's ownership, relative to Java
404     void swig_java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
405       swig_self_.java_change_ownership(jenv, jself, take_or_release);
406     }
407   };
408
409
410   // Utility classes and functions for exception handling.
411
412   // Simple holder for a Java string during exception handling, providing access to a c-style string
413   class JavaString {
414   public:
415     JavaString(JNIEnv *jenv, jstring jstr) : jenv_(jenv), jstr_(jstr), cstr_(0) {
416       if (jenv_ && jstr_)
417         cstr_ = (const char *) jenv_->GetStringUTFChars(jstr_, NULL);
418     }
419
420     ~JavaString() {
421       if (jenv_ && jstr_ && cstr_)
422         jenv_->ReleaseStringUTFChars(jstr_, cstr_);
423     }
424
425     const char *c_str(const char *null_string = "null JavaString") const {
426       return cstr_ ? cstr_ : null_string;
427     }
428
429   private:
430     // non-copyable
431     JavaString(const JavaString &);
432     JavaString &operator=(const JavaString &);
433
434     JNIEnv *jenv_;
435     jstring jstr_;
436     const char *cstr_;
437   };
438
439   // Helper class to extract the exception message from a Java throwable
440   class JavaExceptionMessage {
441   public:
442     JavaExceptionMessage(JNIEnv *jenv, jthrowable throwable) : message_(jenv, exceptionMessageFromThrowable(jenv, throwable)) {
443     }
444
445     const char *message() const {
446       return message_.c_str("Could not get exception message in JavaExceptionMessage");
447     }
448
449   private:
450     // non-copyable
451     JavaExceptionMessage(const JavaExceptionMessage &);
452     JavaExceptionMessage &operator=(const JavaExceptionMessage &);
453
454     // Get exception message by calling Java method Throwable.getMessage()
455     static jstring exceptionMessageFromThrowable(JNIEnv *jenv, jthrowable throwable) {
456       jstring jmsg = NULL;
457       if (jenv && throwable) {
458         jenv->ExceptionClear(); // Cannot invoke methods with any pending exceptions
459         jclass throwclz = jenv->GetObjectClass(throwable);
460         if (throwclz) {
461           // All Throwable classes have a getMessage() method, so call it to extract the exception message
462           jmethodID getMessageMethodID = jenv->GetMethodID(throwclz, "getMessage", "()Ljava/lang/String;");
463           if (getMessageMethodID)
464             jmsg = (jstring)jenv->CallObjectMethod(throwable, getMessageMethodID);
465         }
466         if (jmsg == NULL && jenv->ExceptionCheck())
467           jenv->ExceptionClear();
468       }
469       return jmsg;
470     }
471
472     JavaString message_;
473   };
474
475   // C++ Exception class for handling Java exceptions thrown during a director method Java upcall
476   class DirectorException : public std::exception {
477   public:
478
479     // Construct exception from a Java throwable
480     DirectorException(JNIEnv *jenv, jthrowable throwable) : classname_(0), msg_(0) {
481
482       // Call Java method Object.getClass().getName() to obtain the throwable's class name (delimited by '/')
483       if (throwable) {
484         jclass throwclz = jenv->GetObjectClass(throwable);
485         if (throwclz) {
486           jclass clzclz = jenv->GetObjectClass(throwclz);
487           if (clzclz) {
488             jmethodID getNameMethodID = jenv->GetMethodID(clzclz, "getName", "()Ljava/lang/String;");
489             if (getNameMethodID) {
490               jstring jstr_classname = (jstring)(jenv->CallObjectMethod(throwclz, getNameMethodID));
491               // Copy strings, since there is no guarantee that jenv will be active when handled
492               if (jstr_classname) {
493                 JavaString jsclassname(jenv, jstr_classname);
494                 const char *classname = jsclassname.c_str(0);
495                 if (classname)
496                   classname_ = copypath(classname);
497               }
498             }
499           }
500         }
501       }
502
503       JavaExceptionMessage exceptionmsg(jenv, throwable);
504       msg_ = copystr(exceptionmsg.message());
505     }
506
507     // More general constructor for handling as a java.lang.RuntimeException
508     DirectorException(const char *msg) : classname_(0), msg_(copystr(msg ? msg : "Unspecified DirectorException message")) {
509     }
510
511     ~DirectorException() throw() {
512       delete[] classname_;
513       delete[] msg_;
514     }
515
516     const char *what() const throw() {
517       return msg_;
518     }
519
520     // Reconstruct and raise/throw the Java Exception that caused the DirectorException
521     // Note that any error in the JNI exception handling results in a Java RuntimeException
522     void raiseJavaException(JNIEnv *jenv) const {
523       if (jenv) {
524         jenv->ExceptionClear();
525
526         jmethodID ctorMethodID = 0;
527         jclass throwableclass = 0;
528         if (classname_) {
529           throwableclass = jenv->FindClass(classname_);
530           if (throwableclass)
531             ctorMethodID = jenv->GetMethodID(throwableclass, "<init>", "(Ljava/lang/String;)V");
532         }
533
534         if (ctorMethodID) {
535           jenv->ThrowNew(throwableclass, what());
536         } else {
537           SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, what());
538         }
539       }
540     }
541
542   private:
543     static char *copypath(const char *srcmsg) {
544       char *target = copystr(srcmsg);
545       for (char *c=target; *c; ++c) {
546         if ('.' == *c)
547           *c = '/';
548       }
549       return target;
550     }
551
552     static char *copystr(const char *srcmsg) {
553       char *target = 0;
554       if (srcmsg) {
555         int msglen = strlen(srcmsg) + 1;
556         target = new char[msglen];
557         strncpy(target, srcmsg, msglen);
558       }
559       return target;
560     }
561
562     const char *classname_;
563     const char *msg_;
564   };
565
566   // Helper method to determine if a Java throwable matches a particular Java class type
567   bool ExceptionMatches(JNIEnv *jenv, jthrowable throwable, const char *classname) {
568     bool matches = false;
569
570     if (throwable && jenv && classname) {
571       // Exceptions need to be cleared for correct behavior.
572       // The caller of ExceptionMatches should restore pending exceptions if desired -
573       // the caller already has the throwable.
574       jenv->ExceptionClear();
575
576       jclass clz = jenv->FindClass(classname);
577       if (clz) {
578         jclass classclz = jenv->GetObjectClass(clz);
579         jmethodID isInstanceMethodID = jenv->GetMethodID(classclz, "isInstance", "(Ljava/lang/Object;)Z");
580         if (isInstanceMethodID) {
581           matches = jenv->CallBooleanMethod(clz, isInstanceMethodID, throwable) != 0;
582         }
583       }
584
585 #if defined(DEBUG_DIRECTOR_EXCEPTION)
586       if (jenv->ExceptionCheck()) {
587         // Typically occurs when an invalid classname argument is passed resulting in a ClassNotFoundException
588         JavaExceptionMessage exc(jenv, jenv->ExceptionOccurred());
589         std::cout << "Error: ExceptionMatches: class '" << classname << "' : " << exc.message() << std::endl;
590       }
591 #endif
592     }
593     return matches;
594   }
595
596 }
597
598 namespace Swig {
599   namespace {
600     jclass jclass_JavaControllerJNI = NULL;
601     jmethodID director_methids[4];
602   }
603 }
604
605 #include <vector>
606 #include <string>
607
608 #include "utilities.hxx"
609 #include "View.hxx"
610 #include "Controller.hxx"
611
612
613 #include <stdexcept>
614
615
616 #include <vector>
617 #include <stdexcept>
618
619
620 #include <string>
621
622 SWIGINTERN std::vector< double >::const_reference std_vector_Sl_double_Sg__get(std::vector< double > *self,int i){
623                 int size = int(self->size());
624                 if (i>=0 && i<size)
625                     return (*self)[i];
626                 else
627                     throw std::out_of_range("vector index out of range");
628             }
629 SWIGINTERN void std_vector_Sl_double_Sg__set(std::vector< double > *self,int i,std::vector< double >::value_type const &val){
630                 int size = int(self->size());
631                 if (i>=0 && i<size)
632                     (*self)[i] = val;
633                 else
634                     throw std::out_of_range("vector index out of range");
635             }
636 SWIGINTERN std::vector< int >::const_reference std_vector_Sl_int_Sg__get(std::vector< int > *self,int i){
637                 int size = int(self->size());
638                 if (i>=0 && i<size)
639                     return (*self)[i];
640                 else
641                     throw std::out_of_range("vector index out of range");
642             }
643 SWIGINTERN void std_vector_Sl_int_Sg__set(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
644                 int size = int(self->size());
645                 if (i>=0 && i<size)
646                     (*self)[i] = val;
647                 else
648                     throw std::out_of_range("vector index out of range");
649             }
650 SWIGINTERN bool std_vector_Sl_bool_Sg__get(std::vector< bool > *self,int i){
651                 int size = int(self->size());
652                 if (i>=0 && i<size)
653                     return (*self)[i];
654                 else
655                     throw std::out_of_range("vector index out of range");
656             }
657 SWIGINTERN void std_vector_Sl_bool_Sg__set(std::vector< bool > *self,int i,std::vector< bool >::value_type const &val){
658                 int size = int(self->size());
659                 if (i>=0 && i<size)
660                     (*self)[i] = val;
661                 else
662                     throw std::out_of_range("vector index out of range");
663             }
664 SWIGINTERN std::vector< std::string >::const_reference std_vector_Sl_std_string_Sg__get(std::vector< std::string > *self,int i){
665                 int size = int(self->size());
666                 if (i>=0 && i<size)
667                     return (*self)[i];
668                 else
669                     throw std::out_of_range("vector index out of range");
670             }
671 SWIGINTERN void std_vector_Sl_std_string_Sg__set(std::vector< std::string > *self,int i,std::vector< std::string >::value_type const &val){
672                 int size = int(self->size());
673                 if (i>=0 && i<size)
674                     (*self)[i] = val;
675                 else
676                     throw std::out_of_range("vector index out of range");
677             }
678 SWIGINTERN std::vector< long long >::const_reference std_vector_Sl_ScicosID_Sg__get(std::vector< ScicosID > *self,int i){
679                 int size = int(self->size());
680                 if (i>=0 && i<size)
681                     return (*self)[i];
682                 else
683                     throw std::out_of_range("vector index out of range");
684             }
685 SWIGINTERN void std_vector_Sl_ScicosID_Sg__set(std::vector< ScicosID > *self,int i,std::vector< long long >::value_type const &val){
686                 int size = int(self->size());
687                 if (i>=0 && i<size)
688                     (*self)[i] = val;
689                 else
690                     throw std::out_of_range("vector index out of range");
691             }
692
693 static void register_view(org_scilab_modules_scicos::View* view) {
694         org_scilab_modules_scicos::Controller::register_view(view);
695 };
696
697
698
699 /* ---------------------------------------------------
700  * C++ director class methods
701  * --------------------------------------------------- */
702
703 #include "JavaController_wrap.h"
704
705 SwigDirector_View::SwigDirector_View(JNIEnv *jenv) : org_scilab_modules_scicos::View(), Swig::Director(jenv) {
706 }
707
708 SwigDirector_View::~SwigDirector_View() {
709   swig_disconnect_director_self("swigDirectorDisconnect");
710 }
711
712
713 void SwigDirector_View::objectCreated(ScicosID const &uid, kind_t k) {
714   JNIEnvWrapper swigjnienv(this) ;
715   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
716   jobject swigjobj = (jobject) NULL ;
717   jlong juid = 0 ;
718   jint jk  ;
719   
720   if (!swig_override[0]) {
721     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectCreated.");
722     return;
723   }
724   swigjobj = swig_get_self(jenv);
725   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
726     juid = (jlong)uid;
727     jk = (jint) k;
728     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_methids[0], swigjobj, juid, jk);
729     jthrowable swigerror = jenv->ExceptionOccurred();
730     if (swigerror) {
731       jenv->ExceptionClear();
732       throw Swig::DirectorException(jenv, swigerror);
733     }
734     
735   } else {
736     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectCreated ");
737   }
738   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
739 }
740
741 void SwigDirector_View::objectDeleted(ScicosID const &uid, kind_t k) {
742   JNIEnvWrapper swigjnienv(this) ;
743   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
744   jobject swigjobj = (jobject) NULL ;
745   jlong juid = 0 ;
746   jint jk  ;
747   
748   if (!swig_override[1]) {
749     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectDeleted.");
750     return;
751   }
752   swigjobj = swig_get_self(jenv);
753   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
754     juid = (jlong)uid;
755     jk = (jint) k;
756     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_methids[1], swigjobj, juid, jk);
757     jthrowable swigerror = jenv->ExceptionOccurred();
758     if (swigerror) {
759       jenv->ExceptionClear();
760       throw Swig::DirectorException(jenv, swigerror);
761     }
762     
763   } else {
764     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectDeleted ");
765   }
766   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
767 }
768
769 void SwigDirector_View::objectUpdated(ScicosID const &uid, kind_t k) {
770   JNIEnvWrapper swigjnienv(this) ;
771   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
772   jobject swigjobj = (jobject) NULL ;
773   jlong juid = 0 ;
774   jint jk  ;
775   
776   if (!swig_override[2]) {
777     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::objectUpdated.");
778     return;
779   }
780   swigjobj = swig_get_self(jenv);
781   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
782     juid = (jlong)uid;
783     jk = (jint) k;
784     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_methids[2], swigjobj, juid, jk);
785     jthrowable swigerror = jenv->ExceptionOccurred();
786     if (swigerror) {
787       jenv->ExceptionClear();
788       throw Swig::DirectorException(jenv, swigerror);
789     }
790     
791   } else {
792     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::objectUpdated ");
793   }
794   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
795 }
796
797 void SwigDirector_View::propertyUpdated(ScicosID const &uid, kind_t k, object_properties_t p) {
798   JNIEnvWrapper swigjnienv(this) ;
799   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
800   jobject swigjobj = (jobject) NULL ;
801   jlong juid = 0 ;
802   jint jk  ;
803   jint jp  ;
804   
805   if (!swig_override[3]) {
806     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method org_scilab_modules_scicos::View::propertyUpdated.");
807     return;
808   }
809   swigjobj = swig_get_self(jenv);
810   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
811     juid = (jlong)uid;
812     jk = (jint) k;
813     jp = (jint) p;
814     jenv->CallStaticVoidMethod(Swig::jclass_JavaControllerJNI, Swig::director_methids[3], swigjobj, juid, jk, jp);
815     jthrowable swigerror = jenv->ExceptionOccurred();
816     if (swigerror) {
817       jenv->ExceptionClear();
818       throw Swig::DirectorException(jenv, swigerror);
819     }
820     
821   } else {
822     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in org_scilab_modules_scicos::View::propertyUpdated ");
823   }
824   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
825 }
826
827 void SwigDirector_View::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
828   static struct {
829     const char *mname;
830     const char *mdesc;
831     jmethodID base_methid;
832   } methods[] = {
833     {
834       "objectCreated", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
835     },
836     {
837       "objectDeleted", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
838     },
839     {
840       "objectUpdated", "(JLorg/scilab/modules/xcos/Kind;)V", NULL 
841     },
842     {
843       "propertyUpdated", "(JLorg/scilab/modules/xcos/Kind;Lorg/scilab/modules/xcos/ObjectProperties;)V", NULL 
844     }
845   };
846   
847   static jclass baseclass = 0 ;
848   
849   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
850     if (!baseclass) {
851       baseclass = jenv->FindClass("org/scilab/modules/xcos/View");
852       if (!baseclass) return;
853       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
854     }
855     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
856     for (int i = 0; i < 4; ++i) {
857       if (!methods[i].base_methid) {
858         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
859         if (!methods[i].base_methid) return;
860       }
861       swig_override[i] = derived;
862     }
863   }
864 }
865
866
867
868 #ifdef __cplusplus
869 extern "C" {
870 #endif
871
872 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1View(JNIEnv *jenv, jclass jcls) {
873   jlong jresult = 0 ;
874   org_scilab_modules_scicos::View *result = 0 ;
875   
876   (void)jenv;
877   (void)jcls;
878   result = (org_scilab_modules_scicos::View *)new SwigDirector_View(jenv);
879   *(org_scilab_modules_scicos::View **)&jresult = result; 
880   return jresult;
881 }
882
883
884 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1View(JNIEnv *jenv, jclass jcls, jlong jarg1) {
885   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
886   
887   (void)jenv;
888   (void)jcls;
889   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
890   delete arg1;
891 }
892
893
894 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectCreated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
895   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
896   ScicosID *arg2 = 0 ;
897   kind_t arg3 ;
898   ScicosID temp2 ;
899   
900   (void)jenv;
901   (void)jcls;
902   (void)jarg1_;
903   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
904   temp2 = (ScicosID)jarg2; 
905   arg2 = &temp2; 
906   arg3 = (kind_t)jarg3; 
907   (arg1)->objectCreated((ScicosID const &)*arg2,arg3);
908 }
909
910
911 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectDeleted(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
912   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
913   ScicosID *arg2 = 0 ;
914   kind_t arg3 ;
915   ScicosID temp2 ;
916   
917   (void)jenv;
918   (void)jcls;
919   (void)jarg1_;
920   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
921   temp2 = (ScicosID)jarg2; 
922   arg2 = &temp2; 
923   arg3 = (kind_t)jarg3; 
924   (arg1)->objectDeleted((ScicosID const &)*arg2,arg3);
925 }
926
927
928 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1objectUpdated(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) {
929   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
930   ScicosID *arg2 = 0 ;
931   kind_t arg3 ;
932   ScicosID temp2 ;
933   
934   (void)jenv;
935   (void)jcls;
936   (void)jarg1_;
937   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
938   temp2 = (ScicosID)jarg2; 
939   arg2 = &temp2; 
940   arg3 = (kind_t)jarg3; 
941   (arg1)->objectUpdated((ScicosID const &)*arg2,arg3);
942 }
943
944
945 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1propertyUpdated_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4) {
946   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
947   ScicosID *arg2 = 0 ;
948   kind_t arg3 ;
949   object_properties_t arg4 ;
950   ScicosID temp2 ;
951   
952   (void)jenv;
953   (void)jcls;
954   (void)jarg1_;
955   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
956   temp2 = (ScicosID)jarg2; 
957   arg2 = &temp2; 
958   arg3 = (kind_t)jarg3; 
959   arg4 = (object_properties_t)jarg4; 
960   (arg1)->propertyUpdated((ScicosID const &)*arg2,arg3,arg4);
961 }
962
963
964 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1propertyUpdated_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jint jarg5) {
965   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
966   ScicosID *arg2 = 0 ;
967   kind_t arg3 ;
968   object_properties_t arg4 ;
969   update_status_t arg5 ;
970   ScicosID temp2 ;
971   
972   (void)jenv;
973   (void)jcls;
974   (void)jarg1_;
975   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
976   temp2 = (ScicosID)jarg2; 
977   arg2 = &temp2; 
978   arg3 = (kind_t)jarg3; 
979   arg4 = (object_properties_t)jarg4; 
980   arg5 = (update_status_t)jarg5; 
981   (arg1)->propertyUpdated((ScicosID const &)*arg2,arg3,arg4,arg5);
982 }
983
984
985 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) {
986   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
987   (void)jcls;
988   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
989   if (director) {
990     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
991   }
992 }
993
994
995 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_View_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
996   org_scilab_modules_scicos::View *obj = *((org_scilab_modules_scicos::View **)&objarg);
997   SwigDirector_View *director = dynamic_cast<SwigDirector_View *>(obj);
998   (void)jcls;
999   if (director) {
1000     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
1001   }
1002 }
1003
1004
1005 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1Controller(JNIEnv *jenv, jclass jcls) {
1006   jlong jresult = 0 ;
1007   org_scilab_modules_scicos::Controller *result = 0 ;
1008   
1009   (void)jenv;
1010   (void)jcls;
1011   result = (org_scilab_modules_scicos::Controller *)new org_scilab_modules_scicos::Controller();
1012   *(org_scilab_modules_scicos::Controller **)&jresult = result; 
1013   return jresult;
1014 }
1015
1016
1017 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1Controller(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1018   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1019   
1020   (void)jenv;
1021   (void)jcls;
1022   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1023   delete arg1;
1024 }
1025
1026
1027 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1createObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1028   jlong jresult = 0 ;
1029   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1030   kind_t arg2 ;
1031   ScicosID result;
1032   
1033   (void)jenv;
1034   (void)jcls;
1035   (void)jarg1_;
1036   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1037   arg2 = (kind_t)jarg2; 
1038   result = (ScicosID)(arg1)->createObject(arg2);
1039   jresult = (jlong)result; 
1040   return jresult;
1041 }
1042
1043
1044 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1deleteObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1045   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1046   ScicosID arg2 ;
1047   
1048   (void)jenv;
1049   (void)jcls;
1050   (void)jarg1_;
1051   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1052   arg2 = (ScicosID)jarg2; 
1053   (arg1)->deleteObject(arg2);
1054 }
1055
1056
1057 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1cloneObject(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1058   jlong jresult = 0 ;
1059   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1060   ScicosID arg2 ;
1061   ScicosID result;
1062   
1063   (void)jenv;
1064   (void)jcls;
1065   (void)jarg1_;
1066   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1067   arg2 = (ScicosID)jarg2; 
1068   result = (ScicosID)(arg1)->cloneObject(arg2);
1069   jresult = (jlong)result; 
1070   return jresult;
1071 }
1072
1073
1074 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jintArray jarg5) {
1075   jboolean jresult = 0 ;
1076   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1077   ScicosID arg2 ;
1078   kind_t arg3 ;
1079   object_properties_t arg4 ;
1080   int *arg5 = 0 ;
1081   int temp5 ;
1082   bool result;
1083   
1084   (void)jenv;
1085   (void)jcls;
1086   (void)jarg1_;
1087   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1088   arg2 = (ScicosID)jarg2; 
1089   arg3 = (kind_t)jarg3; 
1090   arg4 = (object_properties_t)jarg4; 
1091   {
1092     if (!jarg5) {
1093       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1094       return 0;
1095     }
1096     if (jenv->GetArrayLength(jarg5) == 0) {
1097       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1098       return 0;
1099     }
1100     temp5 = (int)0;
1101     arg5 = &temp5; 
1102   }
1103   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< int >(arg2,arg3,arg4,*arg5);
1104   jresult = (jboolean)result; 
1105   {
1106     jint jvalue = (jint)temp5;
1107     jenv->SetIntArrayRegion(jarg5, 0, 1, &jvalue);
1108   }
1109   
1110   return jresult;
1111 }
1112
1113
1114 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, jdoubleArray jarg5) {
1115   jboolean jresult = 0 ;
1116   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1117   ScicosID arg2 ;
1118   kind_t arg3 ;
1119   object_properties_t arg4 ;
1120   double *arg5 = 0 ;
1121   double temp5 ;
1122   bool result;
1123   
1124   (void)jenv;
1125   (void)jcls;
1126   (void)jarg1_;
1127   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1128   arg2 = (ScicosID)jarg2; 
1129   arg3 = (kind_t)jarg3; 
1130   arg4 = (object_properties_t)jarg4; 
1131   {
1132     if (!jarg5) {
1133       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1134       return 0;
1135     }
1136     if (jenv->GetArrayLength(jarg5) == 0) {
1137       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1138       return 0;
1139     }
1140     temp5 = (double)0;
1141     arg5 = &temp5; 
1142   }
1143   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< double >(arg2,arg3,arg4,*arg5);
1144   jresult = (jboolean)result; 
1145   {
1146     jdouble jvalue = (jdouble)temp5;
1147     jenv->SetDoubleArrayRegion(jarg5, 0, 1, &jvalue);
1148   }
1149   
1150   return jresult;
1151 }
1152
1153
1154 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jobjectArray jarg5) {
1155   jboolean jresult = 0 ;
1156   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1157   ScicosID arg2 ;
1158   kind_t arg3 ;
1159   object_properties_t arg4 ;
1160   std::string *arg5 = 0 ;
1161   std::string temp5 ;
1162   bool result;
1163   
1164   (void)jenv;
1165   (void)jcls;
1166   (void)jarg1_;
1167   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1168   arg2 = (ScicosID)jarg2; 
1169   arg3 = (kind_t)jarg3; 
1170   arg4 = (object_properties_t)jarg4; 
1171   {
1172     if (!jarg5) {
1173       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1174       return 0;
1175     }
1176     if (jenv->GetArrayLength(jarg5) == 0) {
1177       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1178       return 0;
1179     }
1180     arg5 = &temp5; 
1181     *arg5 = "";
1182   }
1183   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::string >(arg2,arg3,arg4,*arg5);
1184   jresult = (jboolean)result; 
1185   {
1186     jstring jnewstring = NULL;
1187     if (arg5) {
1188       jnewstring = jenv->NewStringUTF(arg5->c_str());
1189     }
1190     jenv->SetObjectArrayElement(jarg5, 0, jnewstring); 
1191   }
1192   return jresult;
1193 }
1194
1195
1196 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlongArray jarg5) {
1197   jboolean jresult = 0 ;
1198   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1199   ScicosID arg2 ;
1200   kind_t arg3 ;
1201   object_properties_t arg4 ;
1202   long long *arg5 = 0 ;
1203   long long temp5 ;
1204   bool result;
1205   
1206   (void)jenv;
1207   (void)jcls;
1208   (void)jarg1_;
1209   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1210   arg2 = (ScicosID)jarg2; 
1211   arg3 = (kind_t)jarg3; 
1212   arg4 = (object_properties_t)jarg4; 
1213   {
1214     if (!jarg5) {
1215       SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1216       return 0;
1217     }
1218     if (jenv->GetArrayLength(jarg5) == 0) {
1219       SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1220       return 0;
1221     }
1222     temp5 = (long long)0;
1223     arg5 = &temp5; 
1224   }
1225   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< ScicosID >(arg2,arg3,arg4,*arg5);
1226   jresult = (jboolean)result; 
1227   {
1228     jlong jvalue = (jlong)temp5;
1229     jenv->SetLongArrayRegion(jarg5, 0, 1, &jvalue);
1230   }
1231   
1232   return jresult;
1233 }
1234
1235
1236 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1getObjectProperty_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1237   jboolean jresult = 0 ;
1238   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1239   ScicosID arg2 ;
1240   kind_t arg3 ;
1241   object_properties_t arg4 ;
1242   std::vector< int > *arg5 = 0 ;
1243   bool result;
1244   
1245   (void)jenv;
1246   (void)jcls;
1247   (void)jarg1_;
1248   (void)jarg5_;
1249   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1250   arg2 = (ScicosID)jarg2; 
1251   arg3 = (kind_t)jarg3; 
1252   arg4 = (object_properties_t)jarg4; 
1253   arg5 = *(std::vector< int > **)&jarg5;
1254   if (!arg5) {
1255     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > & reference is null");
1256     return 0;
1257   } 
1258   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< int > >(arg2,arg3,arg4,*arg5);
1259   jresult = (jboolean)result; 
1260   return jresult;
1261 }
1262
1263
1264 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_) {
1265   jboolean jresult = 0 ;
1266   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1267   ScicosID arg2 ;
1268   kind_t arg3 ;
1269   object_properties_t arg4 ;
1270   std::vector< double > *arg5 = 0 ;
1271   bool result;
1272   
1273   (void)jenv;
1274   (void)jcls;
1275   (void)jarg1_;
1276   (void)jarg5_;
1277   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1278   arg2 = (ScicosID)jarg2; 
1279   arg3 = (kind_t)jarg3; 
1280   arg4 = (object_properties_t)jarg4; 
1281   arg5 = *(std::vector< double > **)&jarg5;
1282   if (!arg5) {
1283     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< double > & reference is null");
1284     return 0;
1285   } 
1286   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< double > >(arg2,arg3,arg4,*arg5);
1287   jresult = (jboolean)result; 
1288   return jresult;
1289 }
1290
1291
1292 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_) {
1293   jboolean jresult = 0 ;
1294   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1295   ScicosID arg2 ;
1296   kind_t arg3 ;
1297   object_properties_t arg4 ;
1298   std::vector< std::string > *arg5 = 0 ;
1299   bool result;
1300   
1301   (void)jenv;
1302   (void)jcls;
1303   (void)jarg1_;
1304   (void)jarg5_;
1305   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1306   arg2 = (ScicosID)jarg2; 
1307   arg3 = (kind_t)jarg3; 
1308   arg4 = (object_properties_t)jarg4; 
1309   arg5 = *(std::vector< std::string > **)&jarg5;
1310   if (!arg5) {
1311     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > & reference is null");
1312     return 0;
1313   } 
1314   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< std::string > >(arg2,arg3,arg4,*arg5);
1315   jresult = (jboolean)result; 
1316   return jresult;
1317 }
1318
1319
1320 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_) {
1321   jboolean jresult = 0 ;
1322   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1323   ScicosID arg2 ;
1324   kind_t arg3 ;
1325   object_properties_t arg4 ;
1326   std::vector< long long > *arg5 = 0 ;
1327   bool result;
1328   
1329   (void)jenv;
1330   (void)jcls;
1331   (void)jarg1_;
1332   (void)jarg5_;
1333   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1334   arg2 = (ScicosID)jarg2; 
1335   arg3 = (kind_t)jarg3; 
1336   arg4 = (object_properties_t)jarg4; 
1337   arg5 = *(std::vector< long long > **)&jarg5;
1338   if (!arg5) {
1339     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< long long > & reference is null");
1340     return 0;
1341   } 
1342   result = (bool)((org_scilab_modules_scicos::Controller const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getObjectProperty< std::vector< ScicosID > >(arg2,arg3,arg4,*arg5);
1343   jresult = (jboolean)result; 
1344   return jresult;
1345 }
1346
1347
1348 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jint jarg5) {
1349   jint jresult = 0 ;
1350   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1351   ScicosID arg2 ;
1352   kind_t arg3 ;
1353   object_properties_t arg4 ;
1354   int arg5 ;
1355   update_status_t result;
1356   
1357   (void)jenv;
1358   (void)jcls;
1359   (void)jarg1_;
1360   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1361   arg2 = (ScicosID)jarg2; 
1362   arg3 = (kind_t)jarg3; 
1363   arg4 = (object_properties_t)jarg4; 
1364   arg5 = (int)jarg5; 
1365   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< int >(arg2,arg3,arg4,arg5);
1366   jresult = (jint)result; 
1367   return jresult;
1368 }
1369
1370
1371 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, jdouble jarg5) {
1372   jint jresult = 0 ;
1373   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1374   ScicosID arg2 ;
1375   kind_t arg3 ;
1376   object_properties_t arg4 ;
1377   double arg5 ;
1378   update_status_t result;
1379   
1380   (void)jenv;
1381   (void)jcls;
1382   (void)jarg1_;
1383   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1384   arg2 = (ScicosID)jarg2; 
1385   arg3 = (kind_t)jarg3; 
1386   arg4 = (object_properties_t)jarg4; 
1387   arg5 = (double)jarg5; 
1388   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< double >(arg2,arg3,arg4,arg5);
1389   jresult = (jint)result; 
1390   return jresult;
1391 }
1392
1393
1394 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, jstring jarg5) {
1395   jint jresult = 0 ;
1396   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1397   ScicosID arg2 ;
1398   kind_t arg3 ;
1399   object_properties_t arg4 ;
1400   std::string arg5 ;
1401   update_status_t result;
1402   
1403   (void)jenv;
1404   (void)jcls;
1405   (void)jarg1_;
1406   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1407   arg2 = (ScicosID)jarg2; 
1408   arg3 = (kind_t)jarg3; 
1409   arg4 = (object_properties_t)jarg4; 
1410   if(!jarg5) {
1411     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
1412     return 0;
1413   } 
1414   const char *arg5_pstr = (const char *)jenv->GetStringUTFChars(jarg5, 0); 
1415   if (!arg5_pstr) return 0;
1416   (&arg5)->assign(arg5_pstr);
1417   jenv->ReleaseStringUTFChars(jarg5, arg5_pstr); 
1418   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::string >(arg2,arg3,arg4,arg5);
1419   jresult = (jint)result; 
1420   return jresult;
1421 }
1422
1423
1424 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) {
1425   jint jresult = 0 ;
1426   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1427   ScicosID arg2 ;
1428   kind_t arg3 ;
1429   object_properties_t arg4 ;
1430   long long arg5 ;
1431   update_status_t result;
1432   
1433   (void)jenv;
1434   (void)jcls;
1435   (void)jarg1_;
1436   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1437   arg2 = (ScicosID)jarg2; 
1438   arg3 = (kind_t)jarg3; 
1439   arg4 = (object_properties_t)jarg4; 
1440   arg5 = (long long)jarg5; 
1441   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< ScicosID >(arg2,arg3,arg4,arg5);
1442   jresult = (jint)result; 
1443   return jresult;
1444 }
1445
1446
1447 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_Controller_1setObjectProperty_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jint jarg4, jlong jarg5, jobject jarg5_) {
1448   jint jresult = 0 ;
1449   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1450   ScicosID arg2 ;
1451   kind_t arg3 ;
1452   object_properties_t arg4 ;
1453   std::vector< int > arg5 ;
1454   std::vector< int > *argp5 ;
1455   update_status_t result;
1456   
1457   (void)jenv;
1458   (void)jcls;
1459   (void)jarg1_;
1460   (void)jarg5_;
1461   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1462   arg2 = (ScicosID)jarg2; 
1463   arg3 = (kind_t)jarg3; 
1464   arg4 = (object_properties_t)jarg4; 
1465   argp5 = *(std::vector< int > **)&jarg5; 
1466   if (!argp5) {
1467     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< int >");
1468     return 0;
1469   }
1470   arg5 = *argp5; 
1471   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< int > >(arg2,arg3,arg4,arg5);
1472   jresult = (jint)result; 
1473   return jresult;
1474 }
1475
1476
1477 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_) {
1478   jint jresult = 0 ;
1479   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1480   ScicosID arg2 ;
1481   kind_t arg3 ;
1482   object_properties_t arg4 ;
1483   std::vector< double > arg5 ;
1484   std::vector< double > *argp5 ;
1485   update_status_t result;
1486   
1487   (void)jenv;
1488   (void)jcls;
1489   (void)jarg1_;
1490   (void)jarg5_;
1491   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1492   arg2 = (ScicosID)jarg2; 
1493   arg3 = (kind_t)jarg3; 
1494   arg4 = (object_properties_t)jarg4; 
1495   argp5 = *(std::vector< double > **)&jarg5; 
1496   if (!argp5) {
1497     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< double >");
1498     return 0;
1499   }
1500   arg5 = *argp5; 
1501   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< double > >(arg2,arg3,arg4,arg5);
1502   jresult = (jint)result; 
1503   return jresult;
1504 }
1505
1506
1507 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_) {
1508   jint jresult = 0 ;
1509   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1510   ScicosID arg2 ;
1511   kind_t arg3 ;
1512   object_properties_t arg4 ;
1513   std::vector< std::string > arg5 ;
1514   std::vector< std::string > *argp5 ;
1515   update_status_t result;
1516   
1517   (void)jenv;
1518   (void)jcls;
1519   (void)jarg1_;
1520   (void)jarg5_;
1521   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1522   arg2 = (ScicosID)jarg2; 
1523   arg3 = (kind_t)jarg3; 
1524   arg4 = (object_properties_t)jarg4; 
1525   argp5 = *(std::vector< std::string > **)&jarg5; 
1526   if (!argp5) {
1527     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::string >");
1528     return 0;
1529   }
1530   arg5 = *argp5; 
1531   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< std::string > >(arg2,arg3,arg4,arg5);
1532   jresult = (jint)result; 
1533   return jresult;
1534 }
1535
1536
1537 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_) {
1538   jint jresult = 0 ;
1539   org_scilab_modules_scicos::Controller *arg1 = (org_scilab_modules_scicos::Controller *) 0 ;
1540   ScicosID arg2 ;
1541   kind_t arg3 ;
1542   object_properties_t arg4 ;
1543   std::vector< long long > arg5 ;
1544   std::vector< long long > *argp5 ;
1545   update_status_t result;
1546   
1547   (void)jenv;
1548   (void)jcls;
1549   (void)jarg1_;
1550   (void)jarg5_;
1551   arg1 = *(org_scilab_modules_scicos::Controller **)&jarg1; 
1552   arg2 = (ScicosID)jarg2; 
1553   arg3 = (kind_t)jarg3; 
1554   arg4 = (object_properties_t)jarg4; 
1555   argp5 = *(std::vector< long long > **)&jarg5; 
1556   if (!argp5) {
1557     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< long long >");
1558     return 0;
1559   }
1560   arg5 = *argp5; 
1561   result = (update_status_t)(arg1)->SWIGTEMPLATEDISAMBIGUATOR setObjectProperty< std::vector< ScicosID > >(arg2,arg3,arg4,arg5);
1562   jresult = (jint)result; 
1563   return jresult;
1564 }
1565
1566
1567 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
1568   jlong jresult = 0 ;
1569   std::vector< double > *result = 0 ;
1570   
1571   (void)jenv;
1572   (void)jcls;
1573   result = (std::vector< double > *)new std::vector< double >();
1574   *(std::vector< double > **)&jresult = result; 
1575   return jresult;
1576 }
1577
1578
1579 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfDouble_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1580   jlong jresult = 0 ;
1581   std::vector< double >::size_type arg1 ;
1582   std::vector< double > *result = 0 ;
1583   
1584   (void)jenv;
1585   (void)jcls;
1586   arg1 = (std::vector< double >::size_type)jarg1; 
1587   result = (std::vector< double > *)new std::vector< double >(arg1);
1588   *(std::vector< double > **)&jresult = result; 
1589   return jresult;
1590 }
1591
1592
1593 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1594   jlong jresult = 0 ;
1595   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1596   std::vector< double >::size_type result;
1597   
1598   (void)jenv;
1599   (void)jcls;
1600   (void)jarg1_;
1601   arg1 = *(std::vector< double > **)&jarg1; 
1602   result = ((std::vector< double > const *)arg1)->size();
1603   jresult = (jlong)result; 
1604   return jresult;
1605 }
1606
1607
1608 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1609   jlong jresult = 0 ;
1610   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1611   std::vector< double >::size_type result;
1612   
1613   (void)jenv;
1614   (void)jcls;
1615   (void)jarg1_;
1616   arg1 = *(std::vector< double > **)&jarg1; 
1617   result = ((std::vector< double > const *)arg1)->capacity();
1618   jresult = (jlong)result; 
1619   return jresult;
1620 }
1621
1622
1623 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1624   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1625   std::vector< double >::size_type arg2 ;
1626   
1627   (void)jenv;
1628   (void)jcls;
1629   (void)jarg1_;
1630   arg1 = *(std::vector< double > **)&jarg1; 
1631   arg2 = (std::vector< double >::size_type)jarg2; 
1632   (arg1)->reserve(arg2);
1633 }
1634
1635
1636 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1637   jboolean jresult = 0 ;
1638   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1639   bool result;
1640   
1641   (void)jenv;
1642   (void)jcls;
1643   (void)jarg1_;
1644   arg1 = *(std::vector< double > **)&jarg1; 
1645   result = (bool)((std::vector< double > const *)arg1)->empty();
1646   jresult = (jboolean)result; 
1647   return jresult;
1648 }
1649
1650
1651 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1652   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1653   
1654   (void)jenv;
1655   (void)jcls;
1656   (void)jarg1_;
1657   arg1 = *(std::vector< double > **)&jarg1; 
1658   (arg1)->clear();
1659 }
1660
1661
1662 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
1663   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1664   std::vector< double >::value_type *arg2 = 0 ;
1665   std::vector< double >::value_type temp2 ;
1666   
1667   (void)jenv;
1668   (void)jcls;
1669   (void)jarg1_;
1670   arg1 = *(std::vector< double > **)&jarg1; 
1671   temp2 = (std::vector< double >::value_type)jarg2; 
1672   arg2 = &temp2; 
1673   (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
1674 }
1675
1676
1677 SWIGEXPORT jdouble JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1678   jdouble jresult = 0 ;
1679   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1680   int arg2 ;
1681   std::vector< double >::value_type *result = 0 ;
1682   
1683   (void)jenv;
1684   (void)jcls;
1685   (void)jarg1_;
1686   arg1 = *(std::vector< double > **)&jarg1; 
1687   arg2 = (int)jarg2; 
1688   try {
1689     result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg__get(arg1,arg2);
1690   }
1691   catch(std::out_of_range &_e) {
1692     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
1693     return 0;
1694   }
1695   
1696   jresult = (jdouble)*result; 
1697   return jresult;
1698 }
1699
1700
1701 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfDouble_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdouble jarg3) {
1702   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1703   int arg2 ;
1704   std::vector< double >::value_type *arg3 = 0 ;
1705   std::vector< double >::value_type temp3 ;
1706   
1707   (void)jenv;
1708   (void)jcls;
1709   (void)jarg1_;
1710   arg1 = *(std::vector< double > **)&jarg1; 
1711   arg2 = (int)jarg2; 
1712   temp3 = (std::vector< double >::value_type)jarg3; 
1713   arg3 = &temp3; 
1714   try {
1715     std_vector_Sl_double_Sg__set(arg1,arg2,(double const &)*arg3);
1716   }
1717   catch(std::out_of_range &_e) {
1718     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
1719     return ;
1720   }
1721   
1722 }
1723
1724
1725 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfDouble(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1726   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
1727   
1728   (void)jenv;
1729   (void)jcls;
1730   arg1 = *(std::vector< double > **)&jarg1; 
1731   delete arg1;
1732 }
1733
1734
1735 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
1736   jlong jresult = 0 ;
1737   std::vector< int > *result = 0 ;
1738   
1739   (void)jenv;
1740   (void)jcls;
1741   result = (std::vector< int > *)new std::vector< int >();
1742   *(std::vector< int > **)&jresult = result; 
1743   return jresult;
1744 }
1745
1746
1747 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfInt_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1748   jlong jresult = 0 ;
1749   std::vector< int >::size_type arg1 ;
1750   std::vector< int > *result = 0 ;
1751   
1752   (void)jenv;
1753   (void)jcls;
1754   arg1 = (std::vector< int >::size_type)jarg1; 
1755   result = (std::vector< int > *)new std::vector< int >(arg1);
1756   *(std::vector< int > **)&jresult = result; 
1757   return jresult;
1758 }
1759
1760
1761 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1762   jlong jresult = 0 ;
1763   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1764   std::vector< int >::size_type result;
1765   
1766   (void)jenv;
1767   (void)jcls;
1768   (void)jarg1_;
1769   arg1 = *(std::vector< int > **)&jarg1; 
1770   result = ((std::vector< int > const *)arg1)->size();
1771   jresult = (jlong)result; 
1772   return jresult;
1773 }
1774
1775
1776 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1777   jlong jresult = 0 ;
1778   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1779   std::vector< int >::size_type result;
1780   
1781   (void)jenv;
1782   (void)jcls;
1783   (void)jarg1_;
1784   arg1 = *(std::vector< int > **)&jarg1; 
1785   result = ((std::vector< int > const *)arg1)->capacity();
1786   jresult = (jlong)result; 
1787   return jresult;
1788 }
1789
1790
1791 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1792   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1793   std::vector< int >::size_type arg2 ;
1794   
1795   (void)jenv;
1796   (void)jcls;
1797   (void)jarg1_;
1798   arg1 = *(std::vector< int > **)&jarg1; 
1799   arg2 = (std::vector< int >::size_type)jarg2; 
1800   (arg1)->reserve(arg2);
1801 }
1802
1803
1804 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1805   jboolean jresult = 0 ;
1806   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1807   bool result;
1808   
1809   (void)jenv;
1810   (void)jcls;
1811   (void)jarg1_;
1812   arg1 = *(std::vector< int > **)&jarg1; 
1813   result = (bool)((std::vector< int > const *)arg1)->empty();
1814   jresult = (jboolean)result; 
1815   return jresult;
1816 }
1817
1818
1819 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1820   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1821   
1822   (void)jenv;
1823   (void)jcls;
1824   (void)jarg1_;
1825   arg1 = *(std::vector< int > **)&jarg1; 
1826   (arg1)->clear();
1827 }
1828
1829
1830 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1831   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1832   std::vector< int >::value_type *arg2 = 0 ;
1833   std::vector< int >::value_type temp2 ;
1834   
1835   (void)jenv;
1836   (void)jcls;
1837   (void)jarg1_;
1838   arg1 = *(std::vector< int > **)&jarg1; 
1839   temp2 = (std::vector< int >::value_type)jarg2; 
1840   arg2 = &temp2; 
1841   (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
1842 }
1843
1844
1845 SWIGEXPORT jint JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
1846   jint jresult = 0 ;
1847   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1848   int arg2 ;
1849   std::vector< int >::value_type *result = 0 ;
1850   
1851   (void)jenv;
1852   (void)jcls;
1853   (void)jarg1_;
1854   arg1 = *(std::vector< int > **)&jarg1; 
1855   arg2 = (int)jarg2; 
1856   try {
1857     result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__get(arg1,arg2);
1858   }
1859   catch(std::out_of_range &_e) {
1860     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
1861     return 0;
1862   }
1863   
1864   jresult = (jint)*result; 
1865   return jresult;
1866 }
1867
1868
1869 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfInt_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
1870   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1871   int arg2 ;
1872   std::vector< int >::value_type *arg3 = 0 ;
1873   std::vector< int >::value_type temp3 ;
1874   
1875   (void)jenv;
1876   (void)jcls;
1877   (void)jarg1_;
1878   arg1 = *(std::vector< int > **)&jarg1; 
1879   arg2 = (int)jarg2; 
1880   temp3 = (std::vector< int >::value_type)jarg3; 
1881   arg3 = &temp3; 
1882   try {
1883     std_vector_Sl_int_Sg__set(arg1,arg2,(int const &)*arg3);
1884   }
1885   catch(std::out_of_range &_e) {
1886     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
1887     return ;
1888   }
1889   
1890 }
1891
1892
1893 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfInt(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1894   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1895   
1896   (void)jenv;
1897   (void)jcls;
1898   arg1 = *(std::vector< int > **)&jarg1; 
1899   delete arg1;
1900 }
1901
1902
1903 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
1904   jlong jresult = 0 ;
1905   std::vector< bool > *result = 0 ;
1906   
1907   (void)jenv;
1908   (void)jcls;
1909   result = (std::vector< bool > *)new std::vector< bool >();
1910   *(std::vector< bool > **)&jresult = result; 
1911   return jresult;
1912 }
1913
1914
1915 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfBool_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
1916   jlong jresult = 0 ;
1917   std::vector< bool >::size_type arg1 ;
1918   std::vector< bool > *result = 0 ;
1919   
1920   (void)jenv;
1921   (void)jcls;
1922   arg1 = (std::vector< bool >::size_type)jarg1; 
1923   result = (std::vector< bool > *)new std::vector< bool >(arg1);
1924   *(std::vector< bool > **)&jresult = result; 
1925   return jresult;
1926 }
1927
1928
1929 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1930   jlong jresult = 0 ;
1931   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
1932   std::vector< bool >::size_type result;
1933   
1934   (void)jenv;
1935   (void)jcls;
1936   (void)jarg1_;
1937   arg1 = *(std::vector< bool > **)&jarg1; 
1938   result = ((std::vector< bool > const *)arg1)->size();
1939   jresult = (jlong)result; 
1940   return jresult;
1941 }
1942
1943
1944 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1945   jlong jresult = 0 ;
1946   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
1947   std::vector< bool >::size_type result;
1948   
1949   (void)jenv;
1950   (void)jcls;
1951   (void)jarg1_;
1952   arg1 = *(std::vector< bool > **)&jarg1; 
1953   result = ((std::vector< bool > const *)arg1)->capacity();
1954   jresult = (jlong)result; 
1955   return jresult;
1956 }
1957
1958
1959 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
1960   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
1961   std::vector< bool >::size_type arg2 ;
1962   
1963   (void)jenv;
1964   (void)jcls;
1965   (void)jarg1_;
1966   arg1 = *(std::vector< bool > **)&jarg1; 
1967   arg2 = (std::vector< bool >::size_type)jarg2; 
1968   (arg1)->reserve(arg2);
1969 }
1970
1971
1972 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1973   jboolean jresult = 0 ;
1974   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
1975   bool result;
1976   
1977   (void)jenv;
1978   (void)jcls;
1979   (void)jarg1_;
1980   arg1 = *(std::vector< bool > **)&jarg1; 
1981   result = (bool)((std::vector< bool > const *)arg1)->empty();
1982   jresult = (jboolean)result; 
1983   return jresult;
1984 }
1985
1986
1987 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
1988   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
1989   
1990   (void)jenv;
1991   (void)jcls;
1992   (void)jarg1_;
1993   arg1 = *(std::vector< bool > **)&jarg1; 
1994   (arg1)->clear();
1995 }
1996
1997
1998 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
1999   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2000   std::vector< bool >::value_type *arg2 = 0 ;
2001   std::vector< bool >::value_type temp2 ;
2002   
2003   (void)jenv;
2004   (void)jcls;
2005   (void)jarg1_;
2006   arg1 = *(std::vector< bool > **)&jarg1; 
2007   temp2 = jarg2 ? true : false; 
2008   arg2 = &temp2; 
2009   (arg1)->push_back((std::vector< bool >::value_type const &)*arg2);
2010 }
2011
2012
2013 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2014   jboolean jresult = 0 ;
2015   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2016   int arg2 ;
2017   bool result;
2018   
2019   (void)jenv;
2020   (void)jcls;
2021   (void)jarg1_;
2022   arg1 = *(std::vector< bool > **)&jarg1; 
2023   arg2 = (int)jarg2; 
2024   try {
2025     result = (bool)std_vector_Sl_bool_Sg__get(arg1,arg2);
2026   }
2027   catch(std::out_of_range &_e) {
2028     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2029     return 0;
2030   }
2031   
2032   jresult = (jboolean)result; 
2033   return jresult;
2034 }
2035
2036
2037 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfBool_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
2038   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2039   int arg2 ;
2040   std::vector< bool >::value_type *arg3 = 0 ;
2041   std::vector< bool >::value_type temp3 ;
2042   
2043   (void)jenv;
2044   (void)jcls;
2045   (void)jarg1_;
2046   arg1 = *(std::vector< bool > **)&jarg1; 
2047   arg2 = (int)jarg2; 
2048   temp3 = jarg3 ? true : false; 
2049   arg3 = &temp3; 
2050   try {
2051     std_vector_Sl_bool_Sg__set(arg1,arg2,(bool const &)*arg3);
2052   }
2053   catch(std::out_of_range &_e) {
2054     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2055     return ;
2056   }
2057   
2058 }
2059
2060
2061 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfBool(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2062   std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
2063   
2064   (void)jenv;
2065   (void)jcls;
2066   arg1 = *(std::vector< bool > **)&jarg1; 
2067   delete arg1;
2068 }
2069
2070
2071 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2072   jlong jresult = 0 ;
2073   std::vector< std::string > *result = 0 ;
2074   
2075   (void)jenv;
2076   (void)jcls;
2077   result = (std::vector< std::string > *)new std::vector< std::string >();
2078   *(std::vector< std::string > **)&jresult = result; 
2079   return jresult;
2080 }
2081
2082
2083 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfString_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2084   jlong jresult = 0 ;
2085   std::vector< std::string >::size_type arg1 ;
2086   std::vector< std::string > *result = 0 ;
2087   
2088   (void)jenv;
2089   (void)jcls;
2090   arg1 = (std::vector< std::string >::size_type)jarg1; 
2091   result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
2092   *(std::vector< std::string > **)&jresult = result; 
2093   return jresult;
2094 }
2095
2096
2097 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2098   jlong jresult = 0 ;
2099   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2100   std::vector< std::string >::size_type result;
2101   
2102   (void)jenv;
2103   (void)jcls;
2104   (void)jarg1_;
2105   arg1 = *(std::vector< std::string > **)&jarg1; 
2106   result = ((std::vector< std::string > const *)arg1)->size();
2107   jresult = (jlong)result; 
2108   return jresult;
2109 }
2110
2111
2112 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2113   jlong jresult = 0 ;
2114   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2115   std::vector< std::string >::size_type result;
2116   
2117   (void)jenv;
2118   (void)jcls;
2119   (void)jarg1_;
2120   arg1 = *(std::vector< std::string > **)&jarg1; 
2121   result = ((std::vector< std::string > const *)arg1)->capacity();
2122   jresult = (jlong)result; 
2123   return jresult;
2124 }
2125
2126
2127 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2128   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2129   std::vector< std::string >::size_type arg2 ;
2130   
2131   (void)jenv;
2132   (void)jcls;
2133   (void)jarg1_;
2134   arg1 = *(std::vector< std::string > **)&jarg1; 
2135   arg2 = (std::vector< std::string >::size_type)jarg2; 
2136   (arg1)->reserve(arg2);
2137 }
2138
2139
2140 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2141   jboolean jresult = 0 ;
2142   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2143   bool result;
2144   
2145   (void)jenv;
2146   (void)jcls;
2147   (void)jarg1_;
2148   arg1 = *(std::vector< std::string > **)&jarg1; 
2149   result = (bool)((std::vector< std::string > const *)arg1)->empty();
2150   jresult = (jboolean)result; 
2151   return jresult;
2152 }
2153
2154
2155 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2156   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2157   
2158   (void)jenv;
2159   (void)jcls;
2160   (void)jarg1_;
2161   arg1 = *(std::vector< std::string > **)&jarg1; 
2162   (arg1)->clear();
2163 }
2164
2165
2166 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
2167   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2168   std::vector< std::string >::value_type *arg2 = 0 ;
2169   
2170   (void)jenv;
2171   (void)jcls;
2172   (void)jarg1_;
2173   arg1 = *(std::vector< std::string > **)&jarg1; 
2174   if(!jarg2) {
2175     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2176     return ;
2177   }
2178   const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
2179   if (!arg2_pstr) return ;
2180   std::vector< std::string >::value_type arg2_str(arg2_pstr);
2181   arg2 = &arg2_str;
2182   jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
2183   (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
2184 }
2185
2186
2187 SWIGEXPORT jstring JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2188   jstring jresult = 0 ;
2189   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2190   int arg2 ;
2191   std::vector< std::string >::value_type *result = 0 ;
2192   
2193   (void)jenv;
2194   (void)jcls;
2195   (void)jarg1_;
2196   arg1 = *(std::vector< std::string > **)&jarg1; 
2197   arg2 = (int)jarg2; 
2198   try {
2199     result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__get(arg1,arg2);
2200   }
2201   catch(std::out_of_range &_e) {
2202     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2203     return 0;
2204   }
2205   
2206   jresult = jenv->NewStringUTF(result->c_str()); 
2207   return jresult;
2208 }
2209
2210
2211 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfString_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
2212   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2213   int arg2 ;
2214   std::vector< std::string >::value_type *arg3 = 0 ;
2215   
2216   (void)jenv;
2217   (void)jcls;
2218   (void)jarg1_;
2219   arg1 = *(std::vector< std::string > **)&jarg1; 
2220   arg2 = (int)jarg2; 
2221   if(!jarg3) {
2222     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
2223     return ;
2224   }
2225   const char *arg3_pstr = (const char *)jenv->GetStringUTFChars(jarg3, 0); 
2226   if (!arg3_pstr) return ;
2227   std::vector< std::string >::value_type arg3_str(arg3_pstr);
2228   arg3 = &arg3_str;
2229   jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
2230   try {
2231     std_vector_Sl_std_string_Sg__set(arg1,arg2,(std::string const &)*arg3);
2232   }
2233   catch(std::out_of_range &_e) {
2234     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2235     return ;
2236   }
2237   
2238 }
2239
2240
2241 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfString(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2242   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
2243   
2244   (void)jenv;
2245   (void)jcls;
2246   arg1 = *(std::vector< std::string > **)&jarg1; 
2247   delete arg1;
2248 }
2249
2250
2251 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
2252   jlong jresult = 0 ;
2253   std::vector< ScicosID > *result = 0 ;
2254   
2255   (void)jenv;
2256   (void)jcls;
2257   result = (std::vector< ScicosID > *)new std::vector< ScicosID >();
2258   *(std::vector< ScicosID > **)&jresult = result; 
2259   return jresult;
2260 }
2261
2262
2263 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_new_1VectorOfScicosID_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2264   jlong jresult = 0 ;
2265   std::vector< long long >::size_type arg1 ;
2266   std::vector< ScicosID > *result = 0 ;
2267   
2268   (void)jenv;
2269   (void)jcls;
2270   arg1 = (std::vector< long long >::size_type)jarg1; 
2271   result = (std::vector< ScicosID > *)new std::vector< ScicosID >(arg1);
2272   *(std::vector< ScicosID > **)&jresult = result; 
2273   return jresult;
2274 }
2275
2276
2277 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2278   jlong jresult = 0 ;
2279   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2280   std::vector< long long >::size_type result;
2281   
2282   (void)jenv;
2283   (void)jcls;
2284   (void)jarg1_;
2285   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2286   result = ((std::vector< ScicosID > const *)arg1)->size();
2287   jresult = (jlong)result; 
2288   return jresult;
2289 }
2290
2291
2292 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2293   jlong jresult = 0 ;
2294   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2295   std::vector< long long >::size_type result;
2296   
2297   (void)jenv;
2298   (void)jcls;
2299   (void)jarg1_;
2300   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2301   result = ((std::vector< ScicosID > const *)arg1)->capacity();
2302   jresult = (jlong)result; 
2303   return jresult;
2304 }
2305
2306
2307 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2308   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2309   std::vector< long long >::size_type arg2 ;
2310   
2311   (void)jenv;
2312   (void)jcls;
2313   (void)jarg1_;
2314   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2315   arg2 = (std::vector< long long >::size_type)jarg2; 
2316   (arg1)->reserve(arg2);
2317 }
2318
2319
2320 SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2321   jboolean jresult = 0 ;
2322   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2323   bool result;
2324   
2325   (void)jenv;
2326   (void)jcls;
2327   (void)jarg1_;
2328   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2329   result = (bool)((std::vector< ScicosID > const *)arg1)->empty();
2330   jresult = (jboolean)result; 
2331   return jresult;
2332 }
2333
2334
2335 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2336   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2337   
2338   (void)jenv;
2339   (void)jcls;
2340   (void)jarg1_;
2341   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2342   (arg1)->clear();
2343 }
2344
2345
2346 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
2347   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2348   std::vector< long long >::value_type *arg2 = 0 ;
2349   std::vector< long long >::value_type temp2 ;
2350   
2351   (void)jenv;
2352   (void)jcls;
2353   (void)jarg1_;
2354   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2355   temp2 = (std::vector< long long >::value_type)jarg2; 
2356   arg2 = &temp2; 
2357   (arg1)->push_back((std::vector< long long >::value_type const &)*arg2);
2358 }
2359
2360
2361 SWIGEXPORT jlong JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
2362   jlong jresult = 0 ;
2363   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2364   int arg2 ;
2365   std::vector< long long >::value_type *result = 0 ;
2366   
2367   (void)jenv;
2368   (void)jcls;
2369   (void)jarg1_;
2370   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2371   arg2 = (int)jarg2; 
2372   try {
2373     result = (std::vector< long long >::value_type *) &std_vector_Sl_ScicosID_Sg__get(arg1,arg2);
2374   }
2375   catch(std::out_of_range &_e) {
2376     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2377     return 0;
2378   }
2379   
2380   jresult = (jlong)*result; 
2381   return jresult;
2382 }
2383
2384
2385 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_VectorOfScicosID_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
2386   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2387   int arg2 ;
2388   std::vector< long long >::value_type *arg3 = 0 ;
2389   std::vector< long long >::value_type temp3 ;
2390   
2391   (void)jenv;
2392   (void)jcls;
2393   (void)jarg1_;
2394   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2395   arg2 = (int)jarg2; 
2396   temp3 = (std::vector< long long >::value_type)jarg3; 
2397   arg3 = &temp3; 
2398   try {
2399     std_vector_Sl_ScicosID_Sg__set(arg1,arg2,(long long const &)*arg3);
2400   }
2401   catch(std::out_of_range &_e) {
2402     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
2403     return ;
2404   }
2405   
2406 }
2407
2408
2409 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_delete_1VectorOfScicosID(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2410   std::vector< ScicosID > *arg1 = (std::vector< ScicosID > *) 0 ;
2411   
2412   (void)jenv;
2413   (void)jcls;
2414   arg1 = *(std::vector< ScicosID > **)&jarg1; 
2415   delete arg1;
2416 }
2417
2418
2419 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_register_1view(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2420   org_scilab_modules_scicos::View *arg1 = (org_scilab_modules_scicos::View *) 0 ;
2421   
2422   (void)jenv;
2423   (void)jcls;
2424   (void)jarg1_;
2425   arg1 = *(org_scilab_modules_scicos::View **)&jarg1; 
2426   register_view(arg1);
2427 }
2428
2429
2430 SWIGEXPORT void JNICALL Java_org_scilab_modules_xcos_JavaControllerJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) {
2431   int i;
2432   
2433   static struct {
2434     const char *method;
2435     const char *signature;
2436   } methods[4] = {
2437     {
2438       "SwigDirector_View_objectCreated", "(Lorg/scilab/modules/xcos/View;JI)V" 
2439     },
2440     {
2441       "SwigDirector_View_objectDeleted", "(Lorg/scilab/modules/xcos/View;JI)V" 
2442     },
2443     {
2444       "SwigDirector_View_objectUpdated", "(Lorg/scilab/modules/xcos/View;JI)V" 
2445     },
2446     {
2447       "SwigDirector_View_propertyUpdated__SWIG_0", "(Lorg/scilab/modules/xcos/View;JII)V" 
2448     }
2449   };
2450   Swig::jclass_JavaControllerJNI = (jclass) jenv->NewGlobalRef(jcls);
2451   if (!Swig::jclass_JavaControllerJNI) return;
2452   for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {
2453     Swig::director_methids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);
2454     if (!Swig::director_methids[i]) return;
2455   }
2456 }
2457
2458
2459 #ifdef __cplusplus
2460 }
2461 #endif
2462