Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Fix dllexport/dllimport declarations (Windows)
[simgrid.git] / src / bindings / java / surfJAVA_wrap.cxx
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 2.0.12
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 that proxy
218  * method calls from C++ to Java extensions.
219  * ----------------------------------------------------------------------------- */
220
221 #ifdef __cplusplus
222
223 #if defined(DEBUG_DIRECTOR_OWNED)
224 #include <iostream>
225 #endif
226
227 namespace Swig {
228   /* Java object wrapper */
229   class JObjectWrapper {
230   public:
231     JObjectWrapper() : jthis_(NULL), weak_global_(true) {
232     }
233
234     ~JObjectWrapper() {
235       jthis_ = NULL;
236       weak_global_ = true;
237     }
238
239     bool set(JNIEnv *jenv, jobject jobj, bool mem_own, bool weak_global) {
240       if (!jthis_) {
241         weak_global_ = weak_global || !mem_own; // hold as weak global if explicitly requested or not owned
242         if (jobj)
243           jthis_ = weak_global_ ? jenv->NewWeakGlobalRef(jobj) : jenv->NewGlobalRef(jobj);
244 #if defined(DEBUG_DIRECTOR_OWNED)
245         std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> " << jthis_ << std::endl;
246 #endif
247         return true;
248       } else {
249 #if defined(DEBUG_DIRECTOR_OWNED)
250         std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> already set" << std::endl;
251 #endif
252         return false;
253       }
254     }
255
256     jobject get(JNIEnv *jenv) const {
257 #if defined(DEBUG_DIRECTOR_OWNED)
258       std::cout << "JObjectWrapper::get(";
259       if (jthis_)
260         std::cout << jthis_;
261       else
262         std::cout << "null";
263       std::cout << ") -> return new local ref" << std::endl;
264 #endif
265       return (jthis_ ? jenv->NewLocalRef(jthis_) : jthis_);
266     }
267
268     void release(JNIEnv *jenv) {
269 #if defined(DEBUG_DIRECTOR_OWNED)
270       std::cout << "JObjectWrapper::release(" << jthis_ << "): " << (weak_global_ ? "weak global ref" : "global ref") << std::endl;
271 #endif
272       if (jthis_) {
273         if (weak_global_) {
274           if (jenv->IsSameObject(jthis_, NULL) == JNI_FALSE)
275             jenv->DeleteWeakGlobalRef((jweak)jthis_);
276         } else
277           jenv->DeleteGlobalRef(jthis_);
278       }
279
280       jthis_ = NULL;
281       weak_global_ = true;
282     }
283
284     /* Only call peek if you know what you are doing wrt to weak/global references */
285     jobject peek() {
286       return jthis_;
287     }
288
289     /* Java proxy releases ownership of C++ object, C++ object is now
290        responsible for destruction (creates NewGlobalRef to pin Java
291        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 { /* Java releases ownership of C++ object's lifetime */
300         if (weak_global_) {
301           jenv->DeleteWeakGlobalRef((jweak)jthis_);
302           jthis_ = jenv->NewGlobalRef(jself);
303           weak_global_ = false;
304         }
305       }
306     }
307
308   private:
309     /* pointer to Java object */
310     jobject jthis_;
311     /* Local or global reference flag */
312     bool weak_global_;
313   };
314
315   /* director base class */
316   class Director {
317     /* pointer to Java virtual machine */
318     JavaVM *swig_jvm_;
319
320   protected:
321 #if defined (_MSC_VER) && (_MSC_VER<1300)
322     class JNIEnvWrapper;
323     friend class JNIEnvWrapper;
324 #endif
325     /* Utility class for managing the JNI environment */
326     class JNIEnvWrapper {
327       const Director *director_;
328       JNIEnv *jenv_;
329       int env_status;
330     public:
331       JNIEnvWrapper(const Director *director) : director_(director), jenv_(0), env_status(0) {
332 #if defined(__ANDROID__)
333         JNIEnv **jenv = &jenv_;
334 #else
335         void **jenv = (void **)&jenv_;
336 #endif
337         env_status = director_->swig_jvm_->GetEnv((void **)&jenv_, JNI_VERSION_1_2);
338 #if defined(SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON)
339         // Attach a daemon thread to the JVM. Useful when the JVM should not wait for 
340         // the thread to exit upon shutdown. Only for jdk-1.4 and later.
341         director_->swig_jvm_->AttachCurrentThreadAsDaemon(jenv, NULL);
342 #else
343         director_->swig_jvm_->AttachCurrentThread(jenv, NULL);
344 #endif
345       }
346       ~JNIEnvWrapper() {
347 #if !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD)
348         // Some JVMs, eg jdk-1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call.
349         // However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak.
350         if (env_status == JNI_EDETACHED)
351           director_->swig_jvm_->DetachCurrentThread();
352 #endif
353       }
354       JNIEnv *getJNIEnv() const {
355         return jenv_;
356       }
357     };
358
359     /* Java object wrapper */
360     JObjectWrapper swig_self_;
361
362     /* Disconnect director from Java object */
363     void swig_disconnect_director_self(const char *disconn_method) {
364       JNIEnvWrapper jnienv(this) ;
365       JNIEnv *jenv = jnienv.getJNIEnv() ;
366       jobject jobj = swig_self_.get(jenv);
367 #if defined(DEBUG_DIRECTOR_OWNED)
368       std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl;
369 #endif
370       if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) {
371         jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(jobj), disconn_method, "()V");
372         if (disconn_meth) {
373 #if defined(DEBUG_DIRECTOR_OWNED)
374           std::cout << "Swig::Director::disconnect_director_self upcall to " << disconn_method << std::endl;
375 #endif
376           jenv->CallVoidMethod(jobj, disconn_meth);
377         }
378       }
379       jenv->DeleteLocalRef(jobj);
380     }
381
382   public:
383     Director(JNIEnv *jenv) : swig_jvm_((JavaVM *) NULL), swig_self_() {
384       /* Acquire the Java VM pointer */
385       jenv->GetJavaVM(&swig_jvm_);
386     }
387
388     virtual ~Director() {
389       JNIEnvWrapper jnienv(this) ;
390       JNIEnv *jenv = jnienv.getJNIEnv() ;
391       swig_self_.release(jenv);
392     }
393
394     bool swig_set_self(JNIEnv *jenv, jobject jself, bool mem_own, bool weak_global) {
395       return swig_self_.set(jenv, jself, mem_own, weak_global);
396     }
397
398     jobject swig_get_self(JNIEnv *jenv) const {
399       return swig_self_.get(jenv);
400     }
401
402     // Change C++ object's ownership, relative to Java
403     void swig_java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
404       swig_self_.java_change_ownership(jenv, jself, take_or_release);
405     }
406   };
407 }
408
409 #endif /* __cplusplus */
410
411
412 namespace Swig {
413   namespace {
414     jclass jclass_SurfJNI = NULL;
415     jmethodID director_methids[33];
416   }
417 }
418
419 #if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS)
420
421
422 static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input);
423 static void SWIG_JavaArrayArgoutBool (JNIEnv *jenv, jboolean *jarr, bool *carr, jbooleanArray input);
424 static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz);
425
426
427 static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input);
428 static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input);
429 static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz);
430
431
432 static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input);
433 static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input);
434 static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz);
435
436
437 static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input);
438 static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input);
439 static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz);
440
441
442 static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input);
443 static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input);
444 static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz);
445
446
447 static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input);
448 static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input);
449 static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz);
450
451
452 static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input);
453 static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input);
454 static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz);
455
456
457 static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input);
458 static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input);
459 static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz);
460
461
462 static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input);
463 static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input);
464 static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz);
465
466
467 static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input);
468 static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input);
469 static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz);
470
471
472 static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input);
473 static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input);
474 static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz);
475
476
477 static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input);
478 static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input);
479 static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz);
480
481
482 #else
483
484
485 /* bool[] support */
486 static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input) {
487   int i;
488   jsize sz;
489   if (!input) {
490     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
491     return 0;
492   }
493   sz = jenv->GetArrayLength(input);
494   *jarr = jenv->GetBooleanArrayElements(input, 0);
495   if (!*jarr)
496     return 0; 
497   *carr = new bool[sz]; 
498   if (!*carr) {
499     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
500     return 0;
501   }
502   for (i=0; i<sz; i++)
503     (*carr)[i] = ((*jarr)[i] != 0);
504   return 1;
505 }
506
507 static void SWIG_JavaArrayArgoutBool (JNIEnv *jenv, jboolean *jarr, bool *carr, jbooleanArray input) {
508   int i;
509   jsize sz = jenv->GetArrayLength(input);
510   for (i=0; i<sz; i++)
511     jarr[i] = (jboolean)carr[i];
512   jenv->ReleaseBooleanArrayElements(input, jarr, 0);
513 }
514
515 static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz) {
516   jboolean *arr;
517   int i;
518   jbooleanArray jresult = jenv->NewBooleanArray(sz);
519   if (!jresult)
520     return NULL;
521   arr = jenv->GetBooleanArrayElements(jresult, 0);
522   if (!arr)
523     return NULL;
524   for (i=0; i<sz; i++)
525     arr[i] = (jboolean)result[i];
526   jenv->ReleaseBooleanArrayElements(jresult, arr, 0);
527   return jresult;
528 }
529
530
531 /* signed char[] support */
532 static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input) {
533   int i;
534   jsize sz;
535   if (!input) {
536     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
537     return 0;
538   }
539   sz = jenv->GetArrayLength(input);
540   *jarr = jenv->GetByteArrayElements(input, 0);
541   if (!*jarr)
542     return 0; 
543   *carr = new signed char[sz]; 
544   if (!*carr) {
545     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
546     return 0;
547   }
548   for (i=0; i<sz; i++)
549     (*carr)[i] = (signed char)(*jarr)[i];
550   return 1;
551 }
552
553 static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input) {
554   int i;
555   jsize sz = jenv->GetArrayLength(input);
556   for (i=0; i<sz; i++)
557     jarr[i] = (jbyte)carr[i];
558   jenv->ReleaseByteArrayElements(input, jarr, 0);
559 }
560
561 static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz) {
562   jbyte *arr;
563   int i;
564   jbyteArray jresult = jenv->NewByteArray(sz);
565   if (!jresult)
566     return NULL;
567   arr = jenv->GetByteArrayElements(jresult, 0);
568   if (!arr)
569     return NULL;
570   for (i=0; i<sz; i++)
571     arr[i] = (jbyte)result[i];
572   jenv->ReleaseByteArrayElements(jresult, arr, 0);
573   return jresult;
574 }
575
576
577 /* unsigned char[] support */
578 static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input) {
579   int i;
580   jsize sz;
581   if (!input) {
582     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
583     return 0;
584   }
585   sz = jenv->GetArrayLength(input);
586   *jarr = jenv->GetShortArrayElements(input, 0);
587   if (!*jarr)
588     return 0; 
589   *carr = new unsigned char[sz]; 
590   if (!*carr) {
591     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
592     return 0;
593   }
594   for (i=0; i<sz; i++)
595     (*carr)[i] = (unsigned char)(*jarr)[i];
596   return 1;
597 }
598
599 static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input) {
600   int i;
601   jsize sz = jenv->GetArrayLength(input);
602   for (i=0; i<sz; i++)
603     jarr[i] = (jshort)carr[i];
604   jenv->ReleaseShortArrayElements(input, jarr, 0);
605 }
606
607 static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz) {
608   jshort *arr;
609   int i;
610   jshortArray jresult = jenv->NewShortArray(sz);
611   if (!jresult)
612     return NULL;
613   arr = jenv->GetShortArrayElements(jresult, 0);
614   if (!arr)
615     return NULL;
616   for (i=0; i<sz; i++)
617     arr[i] = (jshort)result[i];
618   jenv->ReleaseShortArrayElements(jresult, arr, 0);
619   return jresult;
620 }
621
622
623 /* short[] support */
624 static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input) {
625   int i;
626   jsize sz;
627   if (!input) {
628     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
629     return 0;
630   }
631   sz = jenv->GetArrayLength(input);
632   *jarr = jenv->GetShortArrayElements(input, 0);
633   if (!*jarr)
634     return 0; 
635   *carr = new short[sz]; 
636   if (!*carr) {
637     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
638     return 0;
639   }
640   for (i=0; i<sz; i++)
641     (*carr)[i] = (short)(*jarr)[i];
642   return 1;
643 }
644
645 static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input) {
646   int i;
647   jsize sz = jenv->GetArrayLength(input);
648   for (i=0; i<sz; i++)
649     jarr[i] = (jshort)carr[i];
650   jenv->ReleaseShortArrayElements(input, jarr, 0);
651 }
652
653 static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz) {
654   jshort *arr;
655   int i;
656   jshortArray jresult = jenv->NewShortArray(sz);
657   if (!jresult)
658     return NULL;
659   arr = jenv->GetShortArrayElements(jresult, 0);
660   if (!arr)
661     return NULL;
662   for (i=0; i<sz; i++)
663     arr[i] = (jshort)result[i];
664   jenv->ReleaseShortArrayElements(jresult, arr, 0);
665   return jresult;
666 }
667
668
669 /* unsigned short[] support */
670 static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input) {
671   int i;
672   jsize sz;
673   if (!input) {
674     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
675     return 0;
676   }
677   sz = jenv->GetArrayLength(input);
678   *jarr = jenv->GetIntArrayElements(input, 0);
679   if (!*jarr)
680     return 0; 
681   *carr = new unsigned short[sz]; 
682   if (!*carr) {
683     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
684     return 0;
685   }
686   for (i=0; i<sz; i++)
687     (*carr)[i] = (unsigned short)(*jarr)[i];
688   return 1;
689 }
690
691 static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input) {
692   int i;
693   jsize sz = jenv->GetArrayLength(input);
694   for (i=0; i<sz; i++)
695     jarr[i] = (jint)carr[i];
696   jenv->ReleaseIntArrayElements(input, jarr, 0);
697 }
698
699 static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz) {
700   jint *arr;
701   int i;
702   jintArray jresult = jenv->NewIntArray(sz);
703   if (!jresult)
704     return NULL;
705   arr = jenv->GetIntArrayElements(jresult, 0);
706   if (!arr)
707     return NULL;
708   for (i=0; i<sz; i++)
709     arr[i] = (jint)result[i];
710   jenv->ReleaseIntArrayElements(jresult, arr, 0);
711   return jresult;
712 }
713
714
715 /* int[] support */
716 static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input) {
717   int i;
718   jsize sz;
719   if (!input) {
720     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
721     return 0;
722   }
723   sz = jenv->GetArrayLength(input);
724   *jarr = jenv->GetIntArrayElements(input, 0);
725   if (!*jarr)
726     return 0; 
727   *carr = new int[sz]; 
728   if (!*carr) {
729     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
730     return 0;
731   }
732   for (i=0; i<sz; i++)
733     (*carr)[i] = (int)(*jarr)[i];
734   return 1;
735 }
736
737 static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input) {
738   int i;
739   jsize sz = jenv->GetArrayLength(input);
740   for (i=0; i<sz; i++)
741     jarr[i] = (jint)carr[i];
742   jenv->ReleaseIntArrayElements(input, jarr, 0);
743 }
744
745 static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz) {
746   jint *arr;
747   int i;
748   jintArray jresult = jenv->NewIntArray(sz);
749   if (!jresult)
750     return NULL;
751   arr = jenv->GetIntArrayElements(jresult, 0);
752   if (!arr)
753     return NULL;
754   for (i=0; i<sz; i++)
755     arr[i] = (jint)result[i];
756   jenv->ReleaseIntArrayElements(jresult, arr, 0);
757   return jresult;
758 }
759
760
761 /* unsigned int[] support */
762 static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input) {
763   int i;
764   jsize sz;
765   if (!input) {
766     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
767     return 0;
768   }
769   sz = jenv->GetArrayLength(input);
770   *jarr = jenv->GetLongArrayElements(input, 0);
771   if (!*jarr)
772     return 0; 
773   *carr = new unsigned int[sz]; 
774   if (!*carr) {
775     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
776     return 0;
777   }
778   for (i=0; i<sz; i++)
779     (*carr)[i] = (unsigned int)(*jarr)[i];
780   return 1;
781 }
782
783 static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input) {
784   int i;
785   jsize sz = jenv->GetArrayLength(input);
786   for (i=0; i<sz; i++)
787     jarr[i] = (jlong)carr[i];
788   jenv->ReleaseLongArrayElements(input, jarr, 0);
789 }
790
791 static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz) {
792   jlong *arr;
793   int i;
794   jlongArray jresult = jenv->NewLongArray(sz);
795   if (!jresult)
796     return NULL;
797   arr = jenv->GetLongArrayElements(jresult, 0);
798   if (!arr)
799     return NULL;
800   for (i=0; i<sz; i++)
801     arr[i] = (jlong)result[i];
802   jenv->ReleaseLongArrayElements(jresult, arr, 0);
803   return jresult;
804 }
805
806
807 /* long[] support */
808 static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input) {
809   int i;
810   jsize sz;
811   if (!input) {
812     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
813     return 0;
814   }
815   sz = jenv->GetArrayLength(input);
816   *jarr = jenv->GetIntArrayElements(input, 0);
817   if (!*jarr)
818     return 0; 
819   *carr = new long[sz]; 
820   if (!*carr) {
821     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
822     return 0;
823   }
824   for (i=0; i<sz; i++)
825     (*carr)[i] = (long)(*jarr)[i];
826   return 1;
827 }
828
829 static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input) {
830   int i;
831   jsize sz = jenv->GetArrayLength(input);
832   for (i=0; i<sz; i++)
833     jarr[i] = (jint)carr[i];
834   jenv->ReleaseIntArrayElements(input, jarr, 0);
835 }
836
837 static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz) {
838   jint *arr;
839   int i;
840   jintArray jresult = jenv->NewIntArray(sz);
841   if (!jresult)
842     return NULL;
843   arr = jenv->GetIntArrayElements(jresult, 0);
844   if (!arr)
845     return NULL;
846   for (i=0; i<sz; i++)
847     arr[i] = (jint)result[i];
848   jenv->ReleaseIntArrayElements(jresult, arr, 0);
849   return jresult;
850 }
851
852
853 /* unsigned long[] support */
854 static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input) {
855   int i;
856   jsize sz;
857   if (!input) {
858     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
859     return 0;
860   }
861   sz = jenv->GetArrayLength(input);
862   *jarr = jenv->GetLongArrayElements(input, 0);
863   if (!*jarr)
864     return 0; 
865   *carr = new unsigned long[sz]; 
866   if (!*carr) {
867     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
868     return 0;
869   }
870   for (i=0; i<sz; i++)
871     (*carr)[i] = (unsigned long)(*jarr)[i];
872   return 1;
873 }
874
875 static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input) {
876   int i;
877   jsize sz = jenv->GetArrayLength(input);
878   for (i=0; i<sz; i++)
879     jarr[i] = (jlong)carr[i];
880   jenv->ReleaseLongArrayElements(input, jarr, 0);
881 }
882
883 static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz) {
884   jlong *arr;
885   int i;
886   jlongArray jresult = jenv->NewLongArray(sz);
887   if (!jresult)
888     return NULL;
889   arr = jenv->GetLongArrayElements(jresult, 0);
890   if (!arr)
891     return NULL;
892   for (i=0; i<sz; i++)
893     arr[i] = (jlong)result[i];
894   jenv->ReleaseLongArrayElements(jresult, arr, 0);
895   return jresult;
896 }
897
898
899 /* jlong[] support */
900 static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input) {
901   int i;
902   jsize sz;
903   if (!input) {
904     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
905     return 0;
906   }
907   sz = jenv->GetArrayLength(input);
908   *jarr = jenv->GetLongArrayElements(input, 0);
909   if (!*jarr)
910     return 0; 
911   *carr = new jlong[sz]; 
912   if (!*carr) {
913     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
914     return 0;
915   }
916   for (i=0; i<sz; i++)
917     (*carr)[i] = (jlong)(*jarr)[i];
918   return 1;
919 }
920
921 static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input) {
922   int i;
923   jsize sz = jenv->GetArrayLength(input);
924   for (i=0; i<sz; i++)
925     jarr[i] = (jlong)carr[i];
926   jenv->ReleaseLongArrayElements(input, jarr, 0);
927 }
928
929 static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz) {
930   jlong *arr;
931   int i;
932   jlongArray jresult = jenv->NewLongArray(sz);
933   if (!jresult)
934     return NULL;
935   arr = jenv->GetLongArrayElements(jresult, 0);
936   if (!arr)
937     return NULL;
938   for (i=0; i<sz; i++)
939     arr[i] = (jlong)result[i];
940   jenv->ReleaseLongArrayElements(jresult, arr, 0);
941   return jresult;
942 }
943
944
945 /* float[] support */
946 static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input) {
947   int i;
948   jsize sz;
949   if (!input) {
950     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
951     return 0;
952   }
953   sz = jenv->GetArrayLength(input);
954   *jarr = jenv->GetFloatArrayElements(input, 0);
955   if (!*jarr)
956     return 0; 
957   *carr = new float[sz]; 
958   if (!*carr) {
959     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
960     return 0;
961   }
962   for (i=0; i<sz; i++)
963     (*carr)[i] = (float)(*jarr)[i];
964   return 1;
965 }
966
967 static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input) {
968   int i;
969   jsize sz = jenv->GetArrayLength(input);
970   for (i=0; i<sz; i++)
971     jarr[i] = (jfloat)carr[i];
972   jenv->ReleaseFloatArrayElements(input, jarr, 0);
973 }
974
975 static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz) {
976   jfloat *arr;
977   int i;
978   jfloatArray jresult = jenv->NewFloatArray(sz);
979   if (!jresult)
980     return NULL;
981   arr = jenv->GetFloatArrayElements(jresult, 0);
982   if (!arr)
983     return NULL;
984   for (i=0; i<sz; i++)
985     arr[i] = (jfloat)result[i];
986   jenv->ReleaseFloatArrayElements(jresult, arr, 0);
987   return jresult;
988 }
989
990
991 /* double[] support */
992 static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input) {
993   int i;
994   jsize sz;
995   if (!input) {
996     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
997     return 0;
998   }
999   sz = jenv->GetArrayLength(input);
1000   *jarr = jenv->GetDoubleArrayElements(input, 0);
1001   if (!*jarr)
1002     return 0; 
1003   *carr = new double[sz]; 
1004   if (!*carr) {
1005     SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
1006     return 0;
1007   }
1008   for (i=0; i<sz; i++)
1009     (*carr)[i] = (double)(*jarr)[i];
1010   return 1;
1011 }
1012
1013 static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input) {
1014   int i;
1015   jsize sz = jenv->GetArrayLength(input);
1016   for (i=0; i<sz; i++)
1017     jarr[i] = (jdouble)carr[i];
1018   jenv->ReleaseDoubleArrayElements(input, jarr, 0);
1019 }
1020
1021 static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz) {
1022   jdouble *arr;
1023   int i;
1024   jdoubleArray jresult = jenv->NewDoubleArray(sz);
1025   if (!jresult)
1026     return NULL;
1027   arr = jenv->GetDoubleArrayElements(jresult, 0);
1028   if (!arr)
1029     return NULL;
1030   for (i=0; i<sz; i++)
1031     arr[i] = (jdouble)result[i];
1032   jenv->ReleaseDoubleArrayElements(jresult, arr, 0);
1033   return jresult;
1034 }
1035
1036
1037 #endif
1038
1039
1040 #include <string>
1041
1042
1043 #include "src/surf/surf_interface.hpp"
1044 #include "src/surf/cpu_interface.hpp"
1045 #include "src/surf/network_interface.hpp"
1046 #include "src/surf/trace_mgr_private.h"
1047 #include "src/bindings/java/surf_swig.hpp"
1048 #include "src/xbt/dict_private.h"
1049
1050 typedef struct lmm_constraint *lmm_constraint_t;
1051 typedef xbt_dynar_t DoubleDynar;
1052
1053 SWIGINTERN ActionArrayPtr ActionList_getArray(ActionList *self){
1054     return self;
1055   }
1056 SWIGINTERN unsigned int tmgr_trace_event_getIdx(tmgr_trace_event *self){return 0;}
1057 SWIGINTERN Cpu *CpuAction_getCpu(CpuAction *self){return getActionCpu(self);}
1058 SWIGINTERN double NetworkAction_getLatency(NetworkAction *self){return self->m_latency;}
1059 SWIGINTERN double lmm_constraint_getUsage(lmm_constraint *self){return lmm_constraint_get_usage(self);}
1060 SWIGINTERN double lmm_variable_getValue(lmm_variable *self){return lmm_variable_getvalue(self);}
1061 SWIGINTERN char *s_xbt_dict_getValue(s_xbt_dict *self,char *key){return (char*)xbt_dict_get_or_null(self, key);}
1062
1063
1064 /* ---------------------------------------------------
1065  * C++ director class methods
1066  * --------------------------------------------------- */
1067
1068 #include "surfJAVA_wrap.h"
1069
1070 SwigDirector_Plugin::SwigDirector_Plugin(JNIEnv *jenv) : Plugin(), Swig::Director(jenv) {
1071 }
1072
1073 SwigDirector_Plugin::~SwigDirector_Plugin() {
1074   swig_disconnect_director_self("swigDirectorDisconnect");
1075 }
1076
1077
1078 void SwigDirector_Plugin::cpuCreatedCallback(Cpu *cpu) {
1079   JNIEnvWrapper swigjnienv(this) ;
1080   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1081   jobject swigjobj = (jobject) NULL ;
1082   jlong jcpu = 0 ;
1083   
1084   if (!swig_override[0]) {
1085     Plugin::cpuCreatedCallback(cpu);
1086     return;
1087   }
1088   swigjobj = swig_get_self(jenv);
1089   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1090     *((Cpu **)&jcpu) = (Cpu *) cpu; 
1091     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[0], swigjobj, jcpu);
1092     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1093   } else {
1094     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1095   }
1096   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1097 }
1098
1099 void SwigDirector_Plugin::cpuDestructedCallback(Cpu *cpu) {
1100   JNIEnvWrapper swigjnienv(this) ;
1101   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1102   jobject swigjobj = (jobject) NULL ;
1103   jlong jcpu = 0 ;
1104   
1105   if (!swig_override[1]) {
1106     Plugin::cpuDestructedCallback(cpu);
1107     return;
1108   }
1109   swigjobj = swig_get_self(jenv);
1110   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1111     *((Cpu **)&jcpu) = (Cpu *) cpu; 
1112     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[1], swigjobj, jcpu);
1113     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1114   } else {
1115     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1116   }
1117   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1118 }
1119
1120 void SwigDirector_Plugin::cpuStateChangedCallback(Cpu *cpu, e_surf_resource_state_t arg1, e_surf_resource_state_t arg2) {
1121   JNIEnvWrapper swigjnienv(this) ;
1122   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1123   jobject swigjobj = (jobject) NULL ;
1124   jlong jcpu = 0 ;
1125   jint jarg1  ;
1126   jint jarg2  ;
1127   
1128   if (!swig_override[2]) {
1129     Plugin::cpuStateChangedCallback(cpu,arg1,arg2);
1130     return;
1131   }
1132   swigjobj = swig_get_self(jenv);
1133   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1134     *((Cpu **)&jcpu) = (Cpu *) cpu; 
1135     jarg1 = (jint) arg1;
1136     jarg2 = (jint) arg2;
1137     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[2], swigjobj, jcpu, jarg1, jarg2);
1138     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1139   } else {
1140     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1141   }
1142   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1143 }
1144
1145 void SwigDirector_Plugin::cpuActionStateChangedCallback(CpuAction *action, e_surf_action_state_t arg1, e_surf_action_state_t arg2) {
1146   JNIEnvWrapper swigjnienv(this) ;
1147   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1148   jobject swigjobj = (jobject) NULL ;
1149   jlong jaction = 0 ;
1150   jint jarg1  ;
1151   jint jarg2  ;
1152   
1153   if (!swig_override[3]) {
1154     Plugin::cpuActionStateChangedCallback(action,arg1,arg2);
1155     return;
1156   }
1157   swigjobj = swig_get_self(jenv);
1158   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1159     *((CpuAction **)&jaction) = (CpuAction *) action; 
1160     jarg1 = (jint) arg1;
1161     jarg2 = (jint) arg2;
1162     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[3], swigjobj, jaction, jarg1, jarg2);
1163     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1164   } else {
1165     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1166   }
1167   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1168 }
1169
1170 void SwigDirector_Plugin::networkLinkCreatedCallback(NetworkLink *link) {
1171   JNIEnvWrapper swigjnienv(this) ;
1172   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1173   jobject swigjobj = (jobject) NULL ;
1174   jlong jlink = 0 ;
1175   
1176   if (!swig_override[4]) {
1177     Plugin::networkLinkCreatedCallback(link);
1178     return;
1179   }
1180   swigjobj = swig_get_self(jenv);
1181   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1182     *((NetworkLink **)&jlink) = (NetworkLink *) link; 
1183     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[4], swigjobj, jlink);
1184     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1185   } else {
1186     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1187   }
1188   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1189 }
1190
1191 void SwigDirector_Plugin::networkLinkDestructedCallback(NetworkLink *link) {
1192   JNIEnvWrapper swigjnienv(this) ;
1193   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1194   jobject swigjobj = (jobject) NULL ;
1195   jlong jlink = 0 ;
1196   
1197   if (!swig_override[5]) {
1198     Plugin::networkLinkDestructedCallback(link);
1199     return;
1200   }
1201   swigjobj = swig_get_self(jenv);
1202   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1203     *((NetworkLink **)&jlink) = (NetworkLink *) link; 
1204     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[5], swigjobj, jlink);
1205     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1206   } else {
1207     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1208   }
1209   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1210 }
1211
1212 void SwigDirector_Plugin::networkLinkStateChangedCallback(NetworkLink *link, e_surf_resource_state_t arg1, e_surf_resource_state_t arg2) {
1213   JNIEnvWrapper swigjnienv(this) ;
1214   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1215   jobject swigjobj = (jobject) NULL ;
1216   jlong jlink = 0 ;
1217   jint jarg1  ;
1218   jint jarg2  ;
1219   
1220   if (!swig_override[6]) {
1221     Plugin::networkLinkStateChangedCallback(link,arg1,arg2);
1222     return;
1223   }
1224   swigjobj = swig_get_self(jenv);
1225   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1226     *((NetworkLink **)&jlink) = (NetworkLink *) link; 
1227     jarg1 = (jint) arg1;
1228     jarg2 = (jint) arg2;
1229     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[6], swigjobj, jlink, jarg1, jarg2);
1230     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1231   } else {
1232     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1233   }
1234   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1235 }
1236
1237 void SwigDirector_Plugin::networkActionStateChangedCallback(NetworkAction *action, e_surf_action_state_t old, e_surf_action_state_t cur) {
1238   JNIEnvWrapper swigjnienv(this) ;
1239   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1240   jobject swigjobj = (jobject) NULL ;
1241   jlong jaction = 0 ;
1242   jint jold  ;
1243   jint jcur  ;
1244   
1245   if (!swig_override[7]) {
1246     Plugin::networkActionStateChangedCallback(action,old,cur);
1247     return;
1248   }
1249   swigjobj = swig_get_self(jenv);
1250   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1251     *((NetworkAction **)&jaction) = (NetworkAction *) action; 
1252     jold = (jint) old;
1253     jcur = (jint) cur;
1254     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[7], swigjobj, jaction, jold, jcur);
1255     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1256   } else {
1257     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1258   }
1259   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1260 }
1261
1262 void SwigDirector_Plugin::networkCommunicateCallback(NetworkAction *action, RoutingEdge *src, RoutingEdge *dst, double size, double rate) {
1263   JNIEnvWrapper swigjnienv(this) ;
1264   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1265   jobject swigjobj = (jobject) NULL ;
1266   jlong jaction = 0 ;
1267   jlong jsrc = 0 ;
1268   jlong jdst = 0 ;
1269   jdouble jsize  ;
1270   jdouble jrate  ;
1271   
1272   if (!swig_override[8]) {
1273     Plugin::networkCommunicateCallback(action,src,dst,size,rate);
1274     return;
1275   }
1276   swigjobj = swig_get_self(jenv);
1277   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1278     *((NetworkAction **)&jaction) = (NetworkAction *) action; 
1279     *((RoutingEdge **)&jsrc) = (RoutingEdge *) src; 
1280     *((RoutingEdge **)&jdst) = (RoutingEdge *) dst; 
1281     jsize = (jdouble) size;
1282     jrate = (jdouble) rate;
1283     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[8], swigjobj, jaction, jsrc, jdst, jsize, jrate);
1284     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1285   } else {
1286     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1287   }
1288   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1289 }
1290
1291 void SwigDirector_Plugin::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
1292   static struct {
1293     const char *mname;
1294     const char *mdesc;
1295     jmethodID base_methid;
1296   } methods[] = {
1297     {
1298       "cpuCreatedCallback", "(Lorg/simgrid/surf/Cpu;)V", NULL 
1299     },
1300     {
1301       "cpuDestructedCallback", "(Lorg/simgrid/surf/Cpu;)V", NULL 
1302     },
1303     {
1304       "cpuStateChangedCallback", "(Lorg/simgrid/surf/Cpu;Lorg/simgrid/surf/ResourceState;Lorg/simgrid/surf/ResourceState;)V", NULL 
1305     },
1306     {
1307       "cpuActionStateChangedCallback", "(Lorg/simgrid/surf/CpuAction;Lorg/simgrid/surf/ActionState;Lorg/simgrid/surf/ActionState;)V", NULL 
1308     },
1309     {
1310       "networkLinkCreatedCallback", "(Lorg/simgrid/surf/NetworkLink;)V", NULL 
1311     },
1312     {
1313       "networkLinkDestructedCallback", "(Lorg/simgrid/surf/NetworkLink;)V", NULL 
1314     },
1315     {
1316       "networkLinkStateChangedCallback", "(Lorg/simgrid/surf/NetworkLink;Lorg/simgrid/surf/ResourceState;Lorg/simgrid/surf/ResourceState;)V", NULL 
1317     },
1318     {
1319       "networkActionStateChangedCallback", "(Lorg/simgrid/surf/NetworkAction;Lorg/simgrid/surf/ActionState;Lorg/simgrid/surf/ActionState;)V", NULL 
1320     },
1321     {
1322       "networkCommunicateCallback", "(Lorg/simgrid/surf/NetworkAction;Lorg/simgrid/surf/RoutingEdge;Lorg/simgrid/surf/RoutingEdge;DD)V", NULL 
1323     }
1324   };
1325   
1326   static jclass baseclass = 0 ;
1327   
1328   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
1329     if (!baseclass) {
1330       baseclass = jenv->FindClass("org/simgrid/surf/Plugin");
1331       if (!baseclass) return;
1332       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
1333     }
1334     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
1335     for (int i = 0; i < 9; ++i) {
1336       if (!methods[i].base_methid) {
1337         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
1338         if (!methods[i].base_methid) return;
1339       }
1340       swig_override[i] = false;
1341       if (derived) {
1342         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
1343         swig_override[i] = (methid != methods[i].base_methid);
1344         jenv->ExceptionClear();
1345       }
1346     }
1347   }
1348 }
1349
1350
1351 SwigDirector_CpuModel::SwigDirector_CpuModel(JNIEnv *jenv, char const *name) : CpuModel(name), Swig::Director(jenv) {
1352 }
1353
1354 double SwigDirector_CpuModel::shareResources(double now) {
1355   double c_result = SwigValueInit< double >() ;
1356   jdouble jresult = 0 ;
1357   JNIEnvWrapper swigjnienv(this) ;
1358   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1359   jobject swigjobj = (jobject) NULL ;
1360   jdouble jnow  ;
1361   
1362   if (!swig_override[0]) {
1363     return Model::shareResources(now);
1364   }
1365   swigjobj = swig_get_self(jenv);
1366   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1367     jnow = (jdouble) now;
1368     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[9], swigjobj, jnow);
1369     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1370     c_result = (double)jresult; 
1371   } else {
1372     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1373   }
1374   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1375   return c_result;
1376 }
1377
1378 double SwigDirector_CpuModel::shareResourcesLazy(double now) {
1379   double c_result = SwigValueInit< double >() ;
1380   jdouble jresult = 0 ;
1381   JNIEnvWrapper swigjnienv(this) ;
1382   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1383   jobject swigjobj = (jobject) NULL ;
1384   jdouble jnow  ;
1385   
1386   if (!swig_override[1]) {
1387     return Model::shareResourcesLazy(now);
1388   }
1389   swigjobj = swig_get_self(jenv);
1390   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1391     jnow = (jdouble) now;
1392     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[10], swigjobj, jnow);
1393     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1394     c_result = (double)jresult; 
1395   } else {
1396     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1397   }
1398   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1399   return c_result;
1400 }
1401
1402 double SwigDirector_CpuModel::shareResourcesFull(double now) {
1403   double c_result = SwigValueInit< double >() ;
1404   jdouble jresult = 0 ;
1405   JNIEnvWrapper swigjnienv(this) ;
1406   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1407   jobject swigjobj = (jobject) NULL ;
1408   jdouble jnow  ;
1409   
1410   if (!swig_override[2]) {
1411     return Model::shareResourcesFull(now);
1412   }
1413   swigjobj = swig_get_self(jenv);
1414   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1415     jnow = (jdouble) now;
1416     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[11], swigjobj, jnow);
1417     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1418     c_result = (double)jresult; 
1419   } else {
1420     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1421   }
1422   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1423   return c_result;
1424 }
1425
1426 void SwigDirector_CpuModel::updateActionsState(double now, double delta) {
1427   JNIEnvWrapper swigjnienv(this) ;
1428   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1429   jobject swigjobj = (jobject) NULL ;
1430   jdouble jnow  ;
1431   jdouble jdelta  ;
1432   
1433   if (!swig_override[3]) {
1434     Model::updateActionsState(now,delta);
1435     return;
1436   }
1437   swigjobj = swig_get_self(jenv);
1438   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1439     jnow = (jdouble) now;
1440     jdelta = (jdouble) delta;
1441     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[12], swigjobj, jnow, jdelta);
1442     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1443   } else {
1444     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1445   }
1446   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1447 }
1448
1449 void SwigDirector_CpuModel::updateActionsStateLazy(double now, double delta) {
1450   JNIEnvWrapper swigjnienv(this) ;
1451   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1452   jobject swigjobj = (jobject) NULL ;
1453   jdouble jnow  ;
1454   jdouble jdelta  ;
1455   
1456   if (!swig_override[4]) {
1457     Model::updateActionsStateLazy(now,delta);
1458     return;
1459   }
1460   swigjobj = swig_get_self(jenv);
1461   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1462     jnow = (jdouble) now;
1463     jdelta = (jdouble) delta;
1464     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[13], swigjobj, jnow, jdelta);
1465     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1466   } else {
1467     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1468   }
1469   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1470 }
1471
1472 void SwigDirector_CpuModel::updateActionsStateFull(double now, double delta) {
1473   JNIEnvWrapper swigjnienv(this) ;
1474   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1475   jobject swigjobj = (jobject) NULL ;
1476   jdouble jnow  ;
1477   jdouble jdelta  ;
1478   
1479   if (!swig_override[5]) {
1480     Model::updateActionsStateFull(now,delta);
1481     return;
1482   }
1483   swigjobj = swig_get_self(jenv);
1484   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1485     jnow = (jdouble) now;
1486     jdelta = (jdouble) delta;
1487     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[14], swigjobj, jnow, jdelta);
1488     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1489   } else {
1490     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1491   }
1492   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1493 }
1494
1495 ActionList *SwigDirector_CpuModel::getRunningActionSet() {
1496   ActionList *c_result = 0 ;
1497   jlong jresult = 0 ;
1498   JNIEnvWrapper swigjnienv(this) ;
1499   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1500   jobject swigjobj = (jobject) NULL ;
1501   
1502   if (!swig_override[6]) {
1503     return Model::getRunningActionSet();
1504   }
1505   swigjobj = swig_get_self(jenv);
1506   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1507     jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_SurfJNI, Swig::director_methids[15], swigjobj);
1508     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1509     c_result = *(ActionList **)&jresult; 
1510   } else {
1511     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1512   }
1513   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1514   return c_result;
1515 }
1516
1517 void SwigDirector_CpuModel::addTraces() {
1518   JNIEnvWrapper swigjnienv(this) ;
1519   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1520   jobject swigjobj = (jobject) NULL ;
1521   
1522   if (!swig_override[7]) {
1523     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method CpuModel::addTraces.");
1524     return;
1525   }
1526   swigjobj = swig_get_self(jenv);
1527   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1528     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[16], swigjobj);
1529     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1530   } else {
1531     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1532   }
1533   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1534 }
1535
1536 SwigDirector_CpuModel::~SwigDirector_CpuModel() {
1537   swig_disconnect_director_self("swigDirectorDisconnect");
1538 }
1539
1540
1541 Cpu *SwigDirector_CpuModel::createCpu(char const *name, DoubleDynar power_peak, int pstate, double power_scale, tmgr_trace *power_trace, int core, e_surf_resource_state_t state_initial, tmgr_trace *state_trace, s_xbt_dict *cpu_properties) {
1542   Cpu *c_result = 0 ;
1543   jlong jresult = 0 ;
1544   JNIEnvWrapper swigjnienv(this) ;
1545   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1546   jobject swigjobj = (jobject) NULL ;
1547   jstring jname = 0 ;
1548   jdoubleArray jpower_peak  ;
1549   jint jpstate  ;
1550   jdouble jpower_scale  ;
1551   jlong jpower_trace = 0 ;
1552   jint jcore  ;
1553   jint jstate_initial  ;
1554   jlong jstate_trace = 0 ;
1555   jlong jcpu_properties = 0 ;
1556   
1557   if (!swig_override[8]) {
1558     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method CpuModel::createCpu.");
1559     return c_result;
1560   }
1561   swigjobj = swig_get_self(jenv);
1562   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1563     jname = 0;
1564     if (name) {
1565       jname = jenv->NewStringUTF((const char *)name);
1566       if (!jname) return c_result;
1567     }
1568     
1569     long l = xbt_dynar_length(power_peak);
1570     jpower_peak = jenv->NewDoubleArray(l);
1571     double *lout = (double *)xbt_dynar_to_array(power_peak);
1572     jenv->SetDoubleArrayRegion(jpower_peak, 0, l, (jdouble*)lout);
1573     free(lout);
1574     
1575     jpstate = (jint) pstate;
1576     jpower_scale = (jdouble) power_scale;
1577     *((tmgr_trace **)&jpower_trace) = (tmgr_trace *) power_trace; 
1578     jcore = (jint) core;
1579     jstate_initial = (jint) state_initial;
1580     *((tmgr_trace **)&jstate_trace) = (tmgr_trace *) state_trace; 
1581     *((s_xbt_dict **)&jcpu_properties) = (s_xbt_dict *) cpu_properties; 
1582     jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_SurfJNI, Swig::director_methids[17], swigjobj, jname, jpower_peak, jpstate, jpower_scale, jpower_trace, jcore, jstate_initial, jstate_trace, jcpu_properties);
1583     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1584     c_result = *(Cpu **)&jresult; 
1585   } else {
1586     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1587   }
1588   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1589   return c_result;
1590 }
1591
1592 void SwigDirector_CpuModel::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
1593   static struct {
1594     const char *mname;
1595     const char *mdesc;
1596     jmethodID base_methid;
1597   } methods[] = {
1598     {
1599       "shareResources", "(D)D", NULL 
1600     },
1601     {
1602       "shareResourcesLazy", "(D)D", NULL 
1603     },
1604     {
1605       "shareResourcesFull", "(D)D", NULL 
1606     },
1607     {
1608       "updateActionsState", "(DD)V", NULL 
1609     },
1610     {
1611       "updateActionsStateLazy", "(DD)V", NULL 
1612     },
1613     {
1614       "updateActionsStateFull", "(DD)V", NULL 
1615     },
1616     {
1617       "getRunningActionSet", "()Lorg/simgrid/surf/ActionList;", NULL 
1618     },
1619     {
1620       "addTraces", "()V", NULL 
1621     },
1622     {
1623       "createCpu", "(Ljava/lang/String;[DIDLorg/simgrid/surf/TmgrTrace;ILorg/simgrid/surf/ResourceState;Lorg/simgrid/surf/TmgrTrace;Lorg/simgrid/surf/XbtDict;)Lorg/simgrid/surf/Cpu;", NULL 
1624     }
1625   };
1626   
1627   static jclass baseclass = 0 ;
1628   
1629   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
1630     if (!baseclass) {
1631       baseclass = jenv->FindClass("org/simgrid/surf/CpuModel");
1632       if (!baseclass) return;
1633       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
1634     }
1635     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
1636     for (int i = 0; i < 9; ++i) {
1637       if (!methods[i].base_methid) {
1638         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
1639         if (!methods[i].base_methid) return;
1640       }
1641       swig_override[i] = false;
1642       if (derived) {
1643         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
1644         swig_override[i] = (methid != methods[i].base_methid);
1645         jenv->ExceptionClear();
1646       }
1647     }
1648   }
1649 }
1650
1651
1652 SwigDirector_Cpu::SwigDirector_Cpu(JNIEnv *jenv, Model *model, char const *name, s_xbt_dict *props, lmm_constraint *constraint, int core, double powerPeak, double powerScale) : Cpu(model, name, props, constraint, core, powerPeak, powerScale), Swig::Director(jenv) {
1653 }
1654
1655 SwigDirector_Cpu::SwigDirector_Cpu(JNIEnv *jenv, Model *model, char const *name, s_xbt_dict *props, int core, double powerPeak, double powerScale) : Cpu(model, name, props, core, powerPeak, powerScale), Swig::Director(jenv) {
1656 }
1657
1658 bool SwigDirector_Cpu::isUsed() {
1659   bool c_result = SwigValueInit< bool >() ;
1660   jboolean jresult = 0 ;
1661   JNIEnvWrapper swigjnienv(this) ;
1662   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1663   jobject swigjobj = (jobject) NULL ;
1664   
1665   if (!swig_override[0]) {
1666     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::isUsed.");
1667     return c_result;
1668   }
1669   swigjobj = swig_get_self(jenv);
1670   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1671     jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_SurfJNI, Swig::director_methids[18], swigjobj);
1672     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1673     c_result = jresult ? true : false; 
1674   } else {
1675     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1676   }
1677   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1678   return c_result;
1679 }
1680
1681 e_surf_resource_state_t SwigDirector_Cpu::getState() {
1682   e_surf_resource_state_t c_result = SwigValueInit< e_surf_resource_state_t >() ;
1683   jint jresult = 0 ;
1684   JNIEnvWrapper swigjnienv(this) ;
1685   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1686   jobject swigjobj = (jobject) NULL ;
1687   
1688   if (!swig_override[1]) {
1689     return Resource::getState();
1690   }
1691   swigjobj = swig_get_self(jenv);
1692   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1693     jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SurfJNI, Swig::director_methids[19], swigjobj);
1694     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1695     c_result = (e_surf_resource_state_t)jresult; 
1696   } else {
1697     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1698   }
1699   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1700   return c_result;
1701 }
1702
1703 void SwigDirector_Cpu::updateState(tmgr_trace_event *event_type, double value, double date) {
1704   JNIEnvWrapper swigjnienv(this) ;
1705   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1706   jobject swigjobj = (jobject) NULL ;
1707   jlong jevent_type = 0 ;
1708   jdouble jvalue  ;
1709   jdouble jdate  ;
1710   
1711   if (!swig_override[2]) {
1712     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::updateState.");
1713     return;
1714   }
1715   swigjobj = swig_get_self(jenv);
1716   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1717     *((tmgr_trace_event **)&jevent_type) = (tmgr_trace_event *) event_type; 
1718     jvalue = (jdouble) value;
1719     jdate = (jdouble) date;
1720     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[20], swigjobj, jevent_type, jvalue, jdate);
1721     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1722   } else {
1723     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1724   }
1725   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1726 }
1727
1728 SwigDirector_Cpu::~SwigDirector_Cpu() {
1729   swig_disconnect_director_self("swigDirectorDisconnect");
1730 }
1731
1732
1733 double SwigDirector_Cpu::getCurrentPowerPeak() {
1734   double c_result = SwigValueInit< double >() ;
1735   jdouble jresult = 0 ;
1736   JNIEnvWrapper swigjnienv(this) ;
1737   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1738   jobject swigjobj = (jobject) NULL ;
1739   
1740   if (!swig_override[3]) {
1741     return Cpu::getCurrentPowerPeak();
1742   }
1743   swigjobj = swig_get_self(jenv);
1744   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1745     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[21], swigjobj);
1746     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1747     c_result = (double)jresult; 
1748   } else {
1749     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1750   }
1751   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1752   return c_result;
1753 }
1754
1755 CpuAction *SwigDirector_Cpu::execute(double size) {
1756   CpuAction *c_result = 0 ;
1757   jlong jresult = 0 ;
1758   JNIEnvWrapper swigjnienv(this) ;
1759   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1760   jobject swigjobj = (jobject) NULL ;
1761   jdouble jsize  ;
1762   
1763   if (!swig_override[4]) {
1764     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::execute.");
1765     return c_result;
1766   }
1767   swigjobj = swig_get_self(jenv);
1768   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1769     jsize = (jdouble) size;
1770     jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_SurfJNI, Swig::director_methids[22], swigjobj, jsize);
1771     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1772     c_result = *(CpuAction **)&jresult; 
1773   } else {
1774     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1775   }
1776   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1777   return c_result;
1778 }
1779
1780 CpuAction *SwigDirector_Cpu::sleep(double duration) {
1781   CpuAction *c_result = 0 ;
1782   jlong jresult = 0 ;
1783   JNIEnvWrapper swigjnienv(this) ;
1784   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1785   jobject swigjobj = (jobject) NULL ;
1786   jdouble jduration  ;
1787   
1788   if (!swig_override[5]) {
1789     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::sleep.");
1790     return c_result;
1791   }
1792   swigjobj = swig_get_self(jenv);
1793   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1794     jduration = (jdouble) duration;
1795     jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_SurfJNI, Swig::director_methids[23], swigjobj, jduration);
1796     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1797     c_result = *(CpuAction **)&jresult; 
1798   } else {
1799     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1800   }
1801   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1802   return c_result;
1803 }
1804
1805 int SwigDirector_Cpu::getCore() {
1806   int c_result = SwigValueInit< int >() ;
1807   jint jresult = 0 ;
1808   JNIEnvWrapper swigjnienv(this) ;
1809   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1810   jobject swigjobj = (jobject) NULL ;
1811   
1812   if (!swig_override[6]) {
1813     return Cpu::getCore();
1814   }
1815   swigjobj = swig_get_self(jenv);
1816   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1817     jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SurfJNI, Swig::director_methids[24], swigjobj);
1818     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1819     c_result = (int)jresult; 
1820   } else {
1821     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1822   }
1823   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1824   return c_result;
1825 }
1826
1827 double SwigDirector_Cpu::getSpeed(double load) {
1828   double c_result = SwigValueInit< double >() ;
1829   jdouble jresult = 0 ;
1830   JNIEnvWrapper swigjnienv(this) ;
1831   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1832   jobject swigjobj = (jobject) NULL ;
1833   jdouble jload  ;
1834   
1835   if (!swig_override[7]) {
1836     return Cpu::getSpeed(load);
1837   }
1838   swigjobj = swig_get_self(jenv);
1839   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1840     jload = (jdouble) load;
1841     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[25], swigjobj, jload);
1842     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1843     c_result = (double)jresult; 
1844   } else {
1845     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1846   }
1847   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1848   return c_result;
1849 }
1850
1851 double SwigDirector_Cpu::getAvailableSpeed() {
1852   double c_result = SwigValueInit< double >() ;
1853   jdouble jresult = 0 ;
1854   JNIEnvWrapper swigjnienv(this) ;
1855   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1856   jobject swigjobj = (jobject) NULL ;
1857   
1858   if (!swig_override[8]) {
1859     return Cpu::getAvailableSpeed();
1860   }
1861   swigjobj = swig_get_self(jenv);
1862   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1863     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[26], swigjobj);
1864     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1865     c_result = (double)jresult; 
1866   } else {
1867     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1868   }
1869   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1870   return c_result;
1871 }
1872
1873 double SwigDirector_Cpu::getPowerPeakAt(int pstate_index) {
1874   double c_result = SwigValueInit< double >() ;
1875   jdouble jresult = 0 ;
1876   JNIEnvWrapper swigjnienv(this) ;
1877   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1878   jobject swigjobj = (jobject) NULL ;
1879   jint jpstate_index  ;
1880   
1881   if (!swig_override[9]) {
1882     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::getPowerPeakAt.");
1883     return c_result;
1884   }
1885   swigjobj = swig_get_self(jenv);
1886   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1887     jpstate_index = (jint) pstate_index;
1888     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[27], swigjobj, jpstate_index);
1889     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1890     c_result = (double)jresult; 
1891   } else {
1892     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1893   }
1894   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1895   return c_result;
1896 }
1897
1898 int SwigDirector_Cpu::getNbPstates() {
1899   int c_result = SwigValueInit< int >() ;
1900   jint jresult = 0 ;
1901   JNIEnvWrapper swigjnienv(this) ;
1902   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1903   jobject swigjobj = (jobject) NULL ;
1904   
1905   if (!swig_override[10]) {
1906     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::getNbPstates.");
1907     return c_result;
1908   }
1909   swigjobj = swig_get_self(jenv);
1910   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1911     jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SurfJNI, Swig::director_methids[28], swigjobj);
1912     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1913     c_result = (int)jresult; 
1914   } else {
1915     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1916   }
1917   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1918   return c_result;
1919 }
1920
1921 void SwigDirector_Cpu::setPowerPeakAt(int pstate_index) {
1922   JNIEnvWrapper swigjnienv(this) ;
1923   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1924   jobject swigjobj = (jobject) NULL ;
1925   jint jpstate_index  ;
1926   
1927   if (!swig_override[11]) {
1928     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::setPowerPeakAt.");
1929     return;
1930   }
1931   swigjobj = swig_get_self(jenv);
1932   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1933     jpstate_index = (jint) pstate_index;
1934     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[29], swigjobj, jpstate_index);
1935     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1936   } else {
1937     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1938   }
1939   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1940 }
1941
1942 void SwigDirector_Cpu::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
1943   static struct {
1944     const char *mname;
1945     const char *mdesc;
1946     jmethodID base_methid;
1947   } methods[] = {
1948     {
1949       "isUsed", "()Z", NULL 
1950     },
1951     {
1952       "getState", "()Lorg/simgrid/surf/ResourceState;", NULL 
1953     },
1954     {
1955       "updateState", "(Lorg/simgrid/surf/TmgrTraceEvent;DD)V", NULL 
1956     },
1957     {
1958       "getCurrentPowerPeak", "()D", NULL 
1959     },
1960     {
1961       "execute", "(D)Lorg/simgrid/surf/CpuAction;", NULL 
1962     },
1963     {
1964       "sleep", "(D)Lorg/simgrid/surf/CpuAction;", NULL 
1965     },
1966     {
1967       "getCore", "()I", NULL 
1968     },
1969     {
1970       "getSpeed", "(D)D", NULL 
1971     },
1972     {
1973       "getAvailableSpeed", "()D", NULL 
1974     },
1975     {
1976       "getPowerPeakAt", "(I)D", NULL 
1977     },
1978     {
1979       "getNbPstates", "()I", NULL 
1980     },
1981     {
1982       "setPowerPeakAt", "(I)V", NULL 
1983     }
1984   };
1985   
1986   static jclass baseclass = 0 ;
1987   
1988   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
1989     if (!baseclass) {
1990       baseclass = jenv->FindClass("org/simgrid/surf/Cpu");
1991       if (!baseclass) return;
1992       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
1993     }
1994     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
1995     for (int i = 0; i < 12; ++i) {
1996       if (!methods[i].base_methid) {
1997         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
1998         if (!methods[i].base_methid) return;
1999       }
2000       swig_override[i] = false;
2001       if (derived) {
2002         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
2003         swig_override[i] = (methid != methods[i].base_methid);
2004         jenv->ExceptionClear();
2005       }
2006     }
2007   }
2008 }
2009
2010
2011 SwigDirector_CpuAction::SwigDirector_CpuAction(JNIEnv *jenv, Model *model, double cost, bool failed) : CpuAction(model, cost, failed), Swig::Director(jenv) {
2012 }
2013
2014 SwigDirector_CpuAction::~SwigDirector_CpuAction() {
2015   swig_disconnect_director_self("swigDirectorDisconnect");
2016 }
2017
2018
2019 double SwigDirector_CpuAction::getRemains() {
2020   double c_result = SwigValueInit< double >() ;
2021   jdouble jresult = 0 ;
2022   JNIEnvWrapper swigjnienv(this) ;
2023   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
2024   jobject swigjobj = (jobject) NULL ;
2025   
2026   if (!swig_override[0]) {
2027     return Action::getRemains();
2028   }
2029   swigjobj = swig_get_self(jenv);
2030   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
2031     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[30], swigjobj);
2032     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
2033     c_result = (double)jresult; 
2034   } else {
2035     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
2036   }
2037   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
2038   return c_result;
2039 }
2040
2041 void SwigDirector_CpuAction::setPriority(double priority) {
2042   JNIEnvWrapper swigjnienv(this) ;
2043   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
2044   jobject swigjobj = (jobject) NULL ;
2045   jdouble jpriority  ;
2046   
2047   if (!swig_override[1]) {
2048     Action::setPriority(priority);
2049     return;
2050   }
2051   swigjobj = swig_get_self(jenv);
2052   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
2053     jpriority = (jdouble) priority;
2054     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[31], swigjobj, jpriority);
2055     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
2056   } else {
2057     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
2058   }
2059   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
2060 }
2061
2062 void SwigDirector_CpuAction::setState(e_surf_action_state_t state) {
2063   JNIEnvWrapper swigjnienv(this) ;
2064   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
2065   jobject swigjobj = (jobject) NULL ;
2066   jint jstate  ;
2067   
2068   if (!swig_override[2]) {
2069     Action::setState(state);
2070     return;
2071   }
2072   swigjobj = swig_get_self(jenv);
2073   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
2074     jstate = (jint) state;
2075     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[32], swigjobj, jstate);
2076     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
2077   } else {
2078     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
2079   }
2080   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
2081 }
2082
2083 void SwigDirector_CpuAction::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
2084   static struct {
2085     const char *mname;
2086     const char *mdesc;
2087     jmethodID base_methid;
2088   } methods[] = {
2089     {
2090       "getRemains", "()D", NULL 
2091     },
2092     {
2093       "setPriority", "(D)V", NULL 
2094     },
2095     {
2096       "setState", "(Lorg/simgrid/surf/ActionState;)V", NULL 
2097     }
2098   };
2099   
2100   static jclass baseclass = 0 ;
2101   
2102   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
2103     if (!baseclass) {
2104       baseclass = jenv->FindClass("org/simgrid/surf/CpuAction");
2105       if (!baseclass) return;
2106       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
2107     }
2108     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
2109     for (int i = 0; i < 3; ++i) {
2110       if (!methods[i].base_methid) {
2111         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
2112         if (!methods[i].base_methid) return;
2113       }
2114       swig_override[i] = false;
2115       if (derived) {
2116         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
2117         swig_override[i] = (methid != methods[i].base_methid);
2118         jenv->ExceptionClear();
2119       }
2120     }
2121   }
2122 }
2123
2124
2125
2126 #ifdef __cplusplus
2127 extern "C" {
2128 #endif
2129
2130
2131 #ifdef __cplusplus
2132 extern "C" {
2133 #endif
2134
2135 JNIEXPORT jobject JNICALL Java_org_simgrid_surf_SurfJNI_getAction(JNIEnv *env, jclass cls, jlong jarg1) {
2136   Action * action = (Action *)jarg1;
2137   jobject res;
2138   CpuAction *cpu_action = dynamic_cast<CpuAction*>(action);
2139   if (cpu_action) {
2140     SwigDirector_CpuAction *dir_cpu_action = dynamic_cast<SwigDirector_CpuAction*>(cpu_action);
2141     if (dir_cpu_action) {
2142       res = dir_cpu_action->swig_get_self(env);\
2143     } else {
2144       jclass clss = env->FindClass("org/simgrid/surf/CpuAction");\
2145       jmethodID constru = env->GetMethodID(clss, "<init>", "()V");\
2146       res = env->NewObject(clss, constru);\
2147       res = env->NewGlobalRef(res);\
2148     }
2149   } else {
2150     jclass clss = env->FindClass("org/simgrid/surf/Action");\
2151     jmethodID constru = env->GetMethodID(clss, "<init>", "()V");\
2152     res = env->NewObject(clss, constru);\
2153     res = env->NewGlobalRef(res);\
2154   }
2155   return res;
2156 }
2157
2158 #define GETDIRECTOR(NAME) \
2159 JNIEXPORT jobject JNICALL Java_org_simgrid_surf_SurfJNI_get## NAME ## Director(JNIEnv *env, jclass cls, jlong jarg1)\
2160 {\
2161   NAME * arg1 = (NAME*)jarg1;\
2162   SwigDirector_ ##NAME *director = dynamic_cast<SwigDirector_ ##NAME *>(arg1);\
2163   jobject res;\
2164   if (director) {\
2165     res = director->swig_get_self(env);\
2166   } else {\
2167     jclass clss = env->FindClass("org/simgrid/surf/NAME");\
2168     jmethodID constru = env->GetMethodID(clss, "<init>", "()V");\
2169     res = env->NewObject(clss, constru);\
2170     res = env->NewGlobalRef(res);\
2171   }\
2172   return res;\
2173 }
2174
2175 GETDIRECTOR(CpuModel)
2176 GETDIRECTOR(Cpu)
2177 GETDIRECTOR(CpuAction)
2178
2179 #ifdef __cplusplus
2180 }
2181 #endif
2182
2183
2184 SWIGEXPORT jlongArray JNICALL Java_org_simgrid_surf_SurfJNI_ActionList_1getArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2185   jlongArray jresult = 0 ;
2186   ActionList *arg1 = (ActionList *) 0 ;
2187   ActionArrayPtr result;
2188   
2189   (void)jenv;
2190   (void)jcls;
2191   (void)jarg1_;
2192   arg1 = *(ActionList **)&jarg1; 
2193   result = (ActionArrayPtr)ActionList_getArray(arg1);
2194   {
2195     long l = 0;
2196     for(ActionList::iterator it(result->begin()), itend(result->end()); it != itend ; ++it) {
2197       l++;
2198     }
2199     jresult = jenv->NewLongArray(l);
2200     jlong *elts = jenv->GetLongArrayElements(jresult, NULL);
2201     l = 0;
2202     for(ActionList::iterator it(result->begin()), itend(result->end()); it != itend ; ++it) {
2203       elts[l++] = (jlong)static_cast<ActionPtr>(&*it);
2204     }
2205     jenv->ReleaseLongArrayElements(jresult, elts, 0);
2206   }
2207   return jresult;
2208 }
2209
2210
2211 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1ActionList(JNIEnv *jenv, jclass jcls) {
2212   jlong jresult = 0 ;
2213   ActionList *result = 0 ;
2214   
2215   (void)jenv;
2216   (void)jcls;
2217   result = (ActionList *)new ActionList();
2218   *(ActionList **)&jresult = result; 
2219   return jresult;
2220 }
2221
2222
2223 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1ActionList(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2224   ActionList *arg1 = (ActionList *) 0 ;
2225   
2226   (void)jenv;
2227   (void)jcls;
2228   arg1 = *(ActionList **)&jarg1; 
2229   delete arg1;
2230 }
2231
2232
2233 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_getClock(JNIEnv *jenv, jclass jcls) {
2234   jdouble jresult = 0 ;
2235   double result;
2236   
2237   (void)jenv;
2238   (void)jcls;
2239   result = (double)getClock();
2240   jresult = (jdouble)result; 
2241   return jresult;
2242 }
2243
2244
2245 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_clean(JNIEnv *jenv, jclass jcls) {
2246   (void)jenv;
2247   (void)jcls;
2248   clean();
2249 }
2250
2251
2252 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_getCpuModel(JNIEnv *jenv, jclass jcls) {
2253   jlong jresult = 0 ;
2254   CpuModel *result = 0 ;
2255   
2256   (void)jenv;
2257   (void)jcls;
2258   result = (CpuModel *)getCpuModel();
2259   *(CpuModel **)&jresult = result; 
2260   return jresult;
2261 }
2262
2263
2264 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_setCpuModel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2265   CpuModel *arg1 = (CpuModel *) 0 ;
2266   
2267   (void)jenv;
2268   (void)jcls;
2269   (void)jarg1_;
2270   arg1 = *(CpuModel **)&jarg1; 
2271   setCpuModel(arg1);
2272 }
2273
2274
2275 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_setCpu(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
2276   char *arg1 = (char *) 0 ;
2277   Cpu *arg2 = (Cpu *) 0 ;
2278   
2279   (void)jenv;
2280   (void)jcls;
2281   (void)jarg2_;
2282   arg1 = 0;
2283   if (jarg1) {
2284     arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
2285     if (!arg1) return ;
2286   }
2287   arg2 = *(Cpu **)&jarg2; 
2288   setCpu(arg1,arg2);
2289   {
2290     
2291   }
2292 }
2293
2294
2295 SWIGEXPORT jlongArray JNICALL Java_org_simgrid_surf_SurfJNI_getRoute(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
2296   jlongArray jresult = 0 ;
2297   char *arg1 = (char *) 0 ;
2298   char *arg2 = (char *) 0 ;
2299   NetworkLinkDynar result;
2300   
2301   (void)jenv;
2302   (void)jcls;
2303   arg1 = 0;
2304   if (jarg1) {
2305     arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
2306     if (!arg1) return 0;
2307   }
2308   arg2 = 0;
2309   if (jarg2) {
2310     arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
2311     if (!arg2) return 0;
2312   }
2313   result = getRoute(arg1,arg2);
2314   {
2315     long l = xbt_dynar_length(result);
2316     jresult = jenv->NewLongArray(l);
2317     unsigned i;
2318     NetworkLink *link;
2319     jlong *elts = jenv->GetLongArrayElements(jresult, NULL);
2320     xbt_dynar_foreach(result, i, link) {
2321       elts[i] = (jlong)link;
2322     }
2323     jenv->ReleaseLongArrayElements(jresult, elts, 0);
2324     xbt_dynar_free(&result);
2325   }
2326   if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
2327   if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
2328   return jresult;
2329 }
2330
2331
2332 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1Plugin(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2333   Plugin *arg1 = (Plugin *) 0 ;
2334   
2335   (void)jenv;
2336   (void)jcls;
2337   arg1 = *(Plugin **)&jarg1; 
2338   delete arg1;
2339 }
2340
2341
2342 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateCpuCreatedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2343   Plugin *arg1 = (Plugin *) 0 ;
2344   
2345   (void)jenv;
2346   (void)jcls;
2347   (void)jarg1_;
2348   arg1 = *(Plugin **)&jarg1; 
2349   (arg1)->activateCpuCreatedCallback();
2350 }
2351
2352
2353 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuCreatedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2354   Plugin *arg1 = (Plugin *) 0 ;
2355   Cpu *arg2 = (Cpu *) 0 ;
2356   
2357   (void)jenv;
2358   (void)jcls;
2359   (void)jarg1_;
2360   (void)jarg2_;
2361   arg1 = *(Plugin **)&jarg1; 
2362   arg2 = *(Cpu **)&jarg2; 
2363   (arg1)->cpuCreatedCallback(arg2);
2364 }
2365
2366
2367 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuCreatedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2368   Plugin *arg1 = (Plugin *) 0 ;
2369   Cpu *arg2 = (Cpu *) 0 ;
2370   
2371   (void)jenv;
2372   (void)jcls;
2373   (void)jarg1_;
2374   (void)jarg2_;
2375   arg1 = *(Plugin **)&jarg1; 
2376   arg2 = *(Cpu **)&jarg2; 
2377   (arg1)->Plugin::cpuCreatedCallback(arg2);
2378 }
2379
2380
2381 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateCpuDestructedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2382   Plugin *arg1 = (Plugin *) 0 ;
2383   
2384   (void)jenv;
2385   (void)jcls;
2386   (void)jarg1_;
2387   arg1 = *(Plugin **)&jarg1; 
2388   (arg1)->activateCpuDestructedCallback();
2389 }
2390
2391
2392 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuDestructedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2393   Plugin *arg1 = (Plugin *) 0 ;
2394   Cpu *arg2 = (Cpu *) 0 ;
2395   
2396   (void)jenv;
2397   (void)jcls;
2398   (void)jarg1_;
2399   (void)jarg2_;
2400   arg1 = *(Plugin **)&jarg1; 
2401   arg2 = *(Cpu **)&jarg2; 
2402   (arg1)->cpuDestructedCallback(arg2);
2403 }
2404
2405
2406 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuDestructedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2407   Plugin *arg1 = (Plugin *) 0 ;
2408   Cpu *arg2 = (Cpu *) 0 ;
2409   
2410   (void)jenv;
2411   (void)jcls;
2412   (void)jarg1_;
2413   (void)jarg2_;
2414   arg1 = *(Plugin **)&jarg1; 
2415   arg2 = *(Cpu **)&jarg2; 
2416   (arg1)->Plugin::cpuDestructedCallback(arg2);
2417 }
2418
2419
2420 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateCpuStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2421   Plugin *arg1 = (Plugin *) 0 ;
2422   
2423   (void)jenv;
2424   (void)jcls;
2425   (void)jarg1_;
2426   arg1 = *(Plugin **)&jarg1; 
2427   (arg1)->activateCpuStateChangedCallback();
2428 }
2429
2430
2431 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jint jarg4) {
2432   Plugin *arg1 = (Plugin *) 0 ;
2433   Cpu *arg2 = (Cpu *) 0 ;
2434   e_surf_resource_state_t arg3 ;
2435   e_surf_resource_state_t arg4 ;
2436   
2437   (void)jenv;
2438   (void)jcls;
2439   (void)jarg1_;
2440   (void)jarg2_;
2441   arg1 = *(Plugin **)&jarg1; 
2442   arg2 = *(Cpu **)&jarg2; 
2443   arg3 = (e_surf_resource_state_t)jarg3; 
2444   arg4 = (e_surf_resource_state_t)jarg4; 
2445   (arg1)->cpuStateChangedCallback(arg2,arg3,arg4);
2446 }
2447
2448
2449 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuStateChangedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jint jarg4) {
2450   Plugin *arg1 = (Plugin *) 0 ;
2451   Cpu *arg2 = (Cpu *) 0 ;
2452   e_surf_resource_state_t arg3 ;
2453   e_surf_resource_state_t arg4 ;
2454   
2455   (void)jenv;
2456   (void)jcls;
2457   (void)jarg1_;
2458   (void)jarg2_;
2459   arg1 = *(Plugin **)&jarg1; 
2460   arg2 = *(Cpu **)&jarg2; 
2461   arg3 = (e_surf_resource_state_t)jarg3; 
2462   arg4 = (e_surf_resource_state_t)jarg4; 
2463   (arg1)->Plugin::cpuStateChangedCallback(arg2,arg3,arg4);
2464 }
2465
2466
2467 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateCpuActionStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2468   Plugin *arg1 = (Plugin *) 0 ;
2469   
2470   (void)jenv;
2471   (void)jcls;
2472   (void)jarg1_;
2473   arg1 = *(Plugin **)&jarg1; 
2474   (arg1)->activateCpuActionStateChangedCallback();
2475 }
2476
2477
2478 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuActionStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jint jarg4) {
2479   Plugin *arg1 = (Plugin *) 0 ;
2480   CpuAction *arg2 = (CpuAction *) 0 ;
2481   e_surf_action_state_t arg3 ;
2482   e_surf_action_state_t arg4 ;
2483   
2484   (void)jenv;
2485   (void)jcls;
2486   (void)jarg1_;
2487   (void)jarg2_;
2488   arg1 = *(Plugin **)&jarg1; 
2489   arg2 = *(CpuAction **)&jarg2; 
2490   arg3 = (e_surf_action_state_t)jarg3; 
2491   arg4 = (e_surf_action_state_t)jarg4; 
2492   (arg1)->cpuActionStateChangedCallback(arg2,arg3,arg4);
2493 }
2494
2495
2496 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuActionStateChangedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jint jarg4) {
2497   Plugin *arg1 = (Plugin *) 0 ;
2498   CpuAction *arg2 = (CpuAction *) 0 ;
2499   e_surf_action_state_t arg3 ;
2500   e_surf_action_state_t arg4 ;
2501   
2502   (void)jenv;
2503   (void)jcls;
2504   (void)jarg1_;
2505   (void)jarg2_;
2506   arg1 = *(Plugin **)&jarg1; 
2507   arg2 = *(CpuAction **)&jarg2; 
2508   arg3 = (e_surf_action_state_t)jarg3; 
2509   arg4 = (e_surf_action_state_t)jarg4; 
2510   (arg1)->Plugin::cpuActionStateChangedCallback(arg2,arg3,arg4);
2511 }
2512
2513
2514 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateNetworkLinkCreatedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2515   Plugin *arg1 = (Plugin *) 0 ;
2516   
2517   (void)jenv;
2518   (void)jcls;
2519   (void)jarg1_;
2520   arg1 = *(Plugin **)&jarg1; 
2521   (arg1)->activateNetworkLinkCreatedCallback();
2522 }
2523
2524
2525 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkLinkCreatedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2526   Plugin *arg1 = (Plugin *) 0 ;
2527   NetworkLink *arg2 = (NetworkLink *) 0 ;
2528   
2529   (void)jenv;
2530   (void)jcls;
2531   (void)jarg1_;
2532   (void)jarg2_;
2533   arg1 = *(Plugin **)&jarg1; 
2534   arg2 = *(NetworkLink **)&jarg2; 
2535   (arg1)->networkLinkCreatedCallback(arg2);
2536 }
2537
2538
2539 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkLinkCreatedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2540   Plugin *arg1 = (Plugin *) 0 ;
2541   NetworkLink *arg2 = (NetworkLink *) 0 ;
2542   
2543   (void)jenv;
2544   (void)jcls;
2545   (void)jarg1_;
2546   (void)jarg2_;
2547   arg1 = *(Plugin **)&jarg1; 
2548   arg2 = *(NetworkLink **)&jarg2; 
2549   (arg1)->Plugin::networkLinkCreatedCallback(arg2);
2550 }
2551
2552
2553 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateNetworkLinkDestructedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2554   Plugin *arg1 = (Plugin *) 0 ;
2555   
2556   (void)jenv;
2557   (void)jcls;
2558   (void)jarg1_;
2559   arg1 = *(Plugin **)&jarg1; 
2560   (arg1)->activateNetworkLinkDestructedCallback();
2561 }
2562
2563
2564 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkLinkDestructedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2565   Plugin *arg1 = (Plugin *) 0 ;
2566   NetworkLink *arg2 = (NetworkLink *) 0 ;
2567   
2568   (void)jenv;
2569   (void)jcls;
2570   (void)jarg1_;
2571   (void)jarg2_;
2572   arg1 = *(Plugin **)&jarg1; 
2573   arg2 = *(NetworkLink **)&jarg2; 
2574   (arg1)->networkLinkDestructedCallback(arg2);
2575 }
2576
2577
2578 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkLinkDestructedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2579   Plugin *arg1 = (Plugin *) 0 ;
2580   NetworkLink *arg2 = (NetworkLink *) 0 ;
2581   
2582   (void)jenv;
2583   (void)jcls;
2584   (void)jarg1_;
2585   (void)jarg2_;
2586   arg1 = *(Plugin **)&jarg1; 
2587   arg2 = *(NetworkLink **)&jarg2; 
2588   (arg1)->Plugin::networkLinkDestructedCallback(arg2);
2589 }
2590
2591
2592 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateNetworkLinkStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2593   Plugin *arg1 = (Plugin *) 0 ;
2594   
2595   (void)jenv;
2596   (void)jcls;
2597   (void)jarg1_;
2598   arg1 = *(Plugin **)&jarg1; 
2599   (arg1)->activateNetworkLinkStateChangedCallback();
2600 }
2601
2602
2603 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkLinkStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jint jarg4) {
2604   Plugin *arg1 = (Plugin *) 0 ;
2605   NetworkLink *arg2 = (NetworkLink *) 0 ;
2606   e_surf_resource_state_t arg3 ;
2607   e_surf_resource_state_t arg4 ;
2608   
2609   (void)jenv;
2610   (void)jcls;
2611   (void)jarg1_;
2612   (void)jarg2_;
2613   arg1 = *(Plugin **)&jarg1; 
2614   arg2 = *(NetworkLink **)&jarg2; 
2615   arg3 = (e_surf_resource_state_t)jarg3; 
2616   arg4 = (e_surf_resource_state_t)jarg4; 
2617   (arg1)->networkLinkStateChangedCallback(arg2,arg3,arg4);
2618 }
2619
2620
2621 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkLinkStateChangedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jint jarg4) {
2622   Plugin *arg1 = (Plugin *) 0 ;
2623   NetworkLink *arg2 = (NetworkLink *) 0 ;
2624   e_surf_resource_state_t arg3 ;
2625   e_surf_resource_state_t arg4 ;
2626   
2627   (void)jenv;
2628   (void)jcls;
2629   (void)jarg1_;
2630   (void)jarg2_;
2631   arg1 = *(Plugin **)&jarg1; 
2632   arg2 = *(NetworkLink **)&jarg2; 
2633   arg3 = (e_surf_resource_state_t)jarg3; 
2634   arg4 = (e_surf_resource_state_t)jarg4; 
2635   (arg1)->Plugin::networkLinkStateChangedCallback(arg2,arg3,arg4);
2636 }
2637
2638
2639 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateNetworkActionStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2640   Plugin *arg1 = (Plugin *) 0 ;
2641   
2642   (void)jenv;
2643   (void)jcls;
2644   (void)jarg1_;
2645   arg1 = *(Plugin **)&jarg1; 
2646   (arg1)->activateNetworkActionStateChangedCallback();
2647 }
2648
2649
2650 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkActionStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jint jarg4) {
2651   Plugin *arg1 = (Plugin *) 0 ;
2652   NetworkAction *arg2 = (NetworkAction *) 0 ;
2653   e_surf_action_state_t arg3 ;
2654   e_surf_action_state_t arg4 ;
2655   
2656   (void)jenv;
2657   (void)jcls;
2658   (void)jarg1_;
2659   (void)jarg2_;
2660   arg1 = *(Plugin **)&jarg1; 
2661   arg2 = *(NetworkAction **)&jarg2; 
2662   arg3 = (e_surf_action_state_t)jarg3; 
2663   arg4 = (e_surf_action_state_t)jarg4; 
2664   (arg1)->networkActionStateChangedCallback(arg2,arg3,arg4);
2665 }
2666
2667
2668 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkActionStateChangedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jint jarg4) {
2669   Plugin *arg1 = (Plugin *) 0 ;
2670   NetworkAction *arg2 = (NetworkAction *) 0 ;
2671   e_surf_action_state_t arg3 ;
2672   e_surf_action_state_t arg4 ;
2673   
2674   (void)jenv;
2675   (void)jcls;
2676   (void)jarg1_;
2677   (void)jarg2_;
2678   arg1 = *(Plugin **)&jarg1; 
2679   arg2 = *(NetworkAction **)&jarg2; 
2680   arg3 = (e_surf_action_state_t)jarg3; 
2681   arg4 = (e_surf_action_state_t)jarg4; 
2682   (arg1)->Plugin::networkActionStateChangedCallback(arg2,arg3,arg4);
2683 }
2684
2685
2686 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateNetworkCommunicateCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2687   Plugin *arg1 = (Plugin *) 0 ;
2688   
2689   (void)jenv;
2690   (void)jcls;
2691   (void)jarg1_;
2692   arg1 = *(Plugin **)&jarg1; 
2693   (arg1)->activateNetworkCommunicateCallback();
2694 }
2695
2696
2697 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkCommunicateCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jdouble jarg5, jdouble jarg6) {
2698   Plugin *arg1 = (Plugin *) 0 ;
2699   NetworkAction *arg2 = (NetworkAction *) 0 ;
2700   RoutingEdge *arg3 = (RoutingEdge *) 0 ;
2701   RoutingEdge *arg4 = (RoutingEdge *) 0 ;
2702   double arg5 ;
2703   double arg6 ;
2704   
2705   (void)jenv;
2706   (void)jcls;
2707   (void)jarg1_;
2708   (void)jarg2_;
2709   (void)jarg3_;
2710   (void)jarg4_;
2711   arg1 = *(Plugin **)&jarg1; 
2712   arg2 = *(NetworkAction **)&jarg2; 
2713   arg3 = *(RoutingEdge **)&jarg3; 
2714   arg4 = *(RoutingEdge **)&jarg4; 
2715   arg5 = (double)jarg5; 
2716   arg6 = (double)jarg6; 
2717   (arg1)->networkCommunicateCallback(arg2,arg3,arg4,arg5,arg6);
2718 }
2719
2720
2721 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkCommunicateCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jdouble jarg5, jdouble jarg6) {
2722   Plugin *arg1 = (Plugin *) 0 ;
2723   NetworkAction *arg2 = (NetworkAction *) 0 ;
2724   RoutingEdge *arg3 = (RoutingEdge *) 0 ;
2725   RoutingEdge *arg4 = (RoutingEdge *) 0 ;
2726   double arg5 ;
2727   double arg6 ;
2728   
2729   (void)jenv;
2730   (void)jcls;
2731   (void)jarg1_;
2732   (void)jarg2_;
2733   (void)jarg3_;
2734   (void)jarg4_;
2735   arg1 = *(Plugin **)&jarg1; 
2736   arg2 = *(NetworkAction **)&jarg2; 
2737   arg3 = *(RoutingEdge **)&jarg3; 
2738   arg4 = *(RoutingEdge **)&jarg4; 
2739   arg5 = (double)jarg5; 
2740   arg6 = (double)jarg6; 
2741   (arg1)->Plugin::networkCommunicateCallback(arg2,arg3,arg4,arg5,arg6);
2742 }
2743
2744
2745 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1Plugin(JNIEnv *jenv, jclass jcls) {
2746   jlong jresult = 0 ;
2747   Plugin *result = 0 ;
2748   
2749   (void)jenv;
2750   (void)jcls;
2751   result = (Plugin *)new SwigDirector_Plugin(jenv);
2752   *(Plugin **)&jresult = result; 
2753   return jresult;
2754 }
2755
2756
2757 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
2758   Plugin *obj = *((Plugin **)&objarg);
2759   (void)jcls;
2760   SwigDirector_Plugin *director = dynamic_cast<SwigDirector_Plugin *>(obj);
2761   if (director) {
2762     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
2763   }
2764 }
2765
2766
2767 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
2768   Plugin *obj = *((Plugin **)&objarg);
2769   SwigDirector_Plugin *director = dynamic_cast<SwigDirector_Plugin *>(obj);
2770   (void)jcls;
2771   if (director) {
2772     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
2773   }
2774 }
2775
2776
2777 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1TmgrTrace(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2778   tmgr_trace *arg1 = (tmgr_trace *) 0 ;
2779   
2780   (void)jenv;
2781   (void)jcls;
2782   arg1 = *(tmgr_trace **)&jarg1; 
2783   delete arg1;
2784 }
2785
2786
2787 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_TmgrTraceEvent_1getIdx(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2788   jlong jresult = 0 ;
2789   tmgr_trace_event *arg1 = (tmgr_trace_event *) 0 ;
2790   unsigned int result;
2791   
2792   (void)jenv;
2793   (void)jcls;
2794   (void)jarg1_;
2795   arg1 = *(tmgr_trace_event **)&jarg1; 
2796   result = (unsigned int)tmgr_trace_event_getIdx(arg1);
2797   jresult = (jlong)result; 
2798   return jresult;
2799 }
2800
2801
2802 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1TmgrTraceEvent(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2803   tmgr_trace_event *arg1 = (tmgr_trace_event *) 0 ;
2804   
2805   (void)jenv;
2806   (void)jcls;
2807   arg1 = *(tmgr_trace_event **)&jarg1; 
2808   delete arg1;
2809 }
2810
2811
2812 SWIGEXPORT jstring JNICALL Java_org_simgrid_surf_SurfJNI_Model_1getName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2813   jstring jresult = 0 ;
2814   Model *arg1 = (Model *) 0 ;
2815   char *result = 0 ;
2816   
2817   (void)jenv;
2818   (void)jcls;
2819   (void)jarg1_;
2820   arg1 = *(Model **)&jarg1; 
2821   result = (char *)(arg1)->getName();
2822   if (result) jresult = jenv->NewStringUTF((const char *)result);
2823   return jresult;
2824 }
2825
2826
2827 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Model_1shareResources(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2828   jdouble jresult = 0 ;
2829   Model *arg1 = (Model *) 0 ;
2830   double arg2 ;
2831   double result;
2832   
2833   (void)jenv;
2834   (void)jcls;
2835   (void)jarg1_;
2836   arg1 = *(Model **)&jarg1; 
2837   arg2 = (double)jarg2; 
2838   result = (double)(arg1)->shareResources(arg2);
2839   jresult = (jdouble)result; 
2840   return jresult;
2841 }
2842
2843
2844 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Model_1shareResourcesLazy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2845   jdouble jresult = 0 ;
2846   Model *arg1 = (Model *) 0 ;
2847   double arg2 ;
2848   double result;
2849   
2850   (void)jenv;
2851   (void)jcls;
2852   (void)jarg1_;
2853   arg1 = *(Model **)&jarg1; 
2854   arg2 = (double)jarg2; 
2855   result = (double)(arg1)->shareResourcesLazy(arg2);
2856   jresult = (jdouble)result; 
2857   return jresult;
2858 }
2859
2860
2861 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Model_1shareResourcesFull(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2862   jdouble jresult = 0 ;
2863   Model *arg1 = (Model *) 0 ;
2864   double arg2 ;
2865   double result;
2866   
2867   (void)jenv;
2868   (void)jcls;
2869   (void)jarg1_;
2870   arg1 = *(Model **)&jarg1; 
2871   arg2 = (double)jarg2; 
2872   result = (double)(arg1)->shareResourcesFull(arg2);
2873   jresult = (jdouble)result; 
2874   return jresult;
2875 }
2876
2877
2878 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Model_1updateActionsState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3) {
2879   Model *arg1 = (Model *) 0 ;
2880   double arg2 ;
2881   double arg3 ;
2882   
2883   (void)jenv;
2884   (void)jcls;
2885   (void)jarg1_;
2886   arg1 = *(Model **)&jarg1; 
2887   arg2 = (double)jarg2; 
2888   arg3 = (double)jarg3; 
2889   (arg1)->updateActionsState(arg2,arg3);
2890 }
2891
2892
2893 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Model_1updateActionsStateLazy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3) {
2894   Model *arg1 = (Model *) 0 ;
2895   double arg2 ;
2896   double arg3 ;
2897   
2898   (void)jenv;
2899   (void)jcls;
2900   (void)jarg1_;
2901   arg1 = *(Model **)&jarg1; 
2902   arg2 = (double)jarg2; 
2903   arg3 = (double)jarg3; 
2904   (arg1)->updateActionsStateLazy(arg2,arg3);
2905 }
2906
2907
2908 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Model_1updateActionsStateFull(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3) {
2909   Model *arg1 = (Model *) 0 ;
2910   double arg2 ;
2911   double arg3 ;
2912   
2913   (void)jenv;
2914   (void)jcls;
2915   (void)jarg1_;
2916   arg1 = *(Model **)&jarg1; 
2917   arg2 = (double)jarg2; 
2918   arg3 = (double)jarg3; 
2919   (arg1)->updateActionsStateFull(arg2,arg3);
2920 }
2921
2922
2923 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Model_1getRunningActionSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2924   jlong jresult = 0 ;
2925   Model *arg1 = (Model *) 0 ;
2926   ActionList *result = 0 ;
2927   
2928   (void)jenv;
2929   (void)jcls;
2930   (void)jarg1_;
2931   arg1 = *(Model **)&jarg1; 
2932   result = (ActionList *)(arg1)->getRunningActionSet();
2933   *(ActionList **)&jresult = result; 
2934   return jresult;
2935 }
2936
2937
2938 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Model_1addTraces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2939   Model *arg1 = (Model *) 0 ;
2940   
2941   (void)jenv;
2942   (void)jcls;
2943   (void)jarg1_;
2944   arg1 = *(Model **)&jarg1; 
2945   (arg1)->addTraces();
2946 }
2947
2948
2949 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1Model(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2950   Model *arg1 = (Model *) 0 ;
2951   
2952   (void)jenv;
2953   (void)jcls;
2954   arg1 = *(Model **)&jarg1; 
2955   delete arg1;
2956 }
2957
2958
2959 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1CpuModel(JNIEnv *jenv, jclass jcls, jstring jarg1) {
2960   jlong jresult = 0 ;
2961   char *arg1 = (char *) 0 ;
2962   CpuModel *result = 0 ;
2963   
2964   (void)jenv;
2965   (void)jcls;
2966   arg1 = 0;
2967   if (jarg1) {
2968     arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
2969     if (!arg1) return 0;
2970   }
2971   result = (CpuModel *)new SwigDirector_CpuModel(jenv,(char const *)arg1);
2972   *(CpuModel **)&jresult = result; 
2973   {
2974     
2975   }
2976   return jresult;
2977 }
2978
2979
2980 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1CpuModel(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2981   CpuModel *arg1 = (CpuModel *) 0 ;
2982   
2983   (void)jenv;
2984   (void)jcls;
2985   arg1 = *(CpuModel **)&jarg1; 
2986   delete arg1;
2987 }
2988
2989
2990 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_CpuModel_1createCpu(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jdoubleArray jarg3, jint jarg4, jdouble jarg5, jlong jarg6, jobject jarg6_, jint jarg7, jint jarg8, jlong jarg9, jobject jarg9_, jlong jarg10, jobject jarg10_) {
2991   jlong jresult = 0 ;
2992   CpuModel *arg1 = (CpuModel *) 0 ;
2993   char *arg2 = (char *) 0 ;
2994   DoubleDynar arg3 ;
2995   int arg4 ;
2996   double arg5 ;
2997   tmgr_trace *arg6 = (tmgr_trace *) 0 ;
2998   int arg7 ;
2999   e_surf_resource_state_t arg8 ;
3000   tmgr_trace *arg9 = (tmgr_trace *) 0 ;
3001   s_xbt_dict *arg10 = (s_xbt_dict *) 0 ;
3002   DoubleDynar *argp3 ;
3003   Cpu *result = 0 ;
3004   
3005   (void)jenv;
3006   (void)jcls;
3007   (void)jarg1_;
3008   (void)jarg6_;
3009   (void)jarg9_;
3010   (void)jarg10_;
3011   arg1 = *(CpuModel **)&jarg1; 
3012   arg2 = 0;
3013   if (jarg2) {
3014     arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
3015     if (!arg2) return 0;
3016   }
3017   argp3 = *(DoubleDynar **)&jarg3; 
3018   if (!argp3) {
3019     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null DoubleDynar");
3020     return 0;
3021   }
3022   arg3 = *argp3; 
3023   arg4 = (int)jarg4; 
3024   arg5 = (double)jarg5; 
3025   arg6 = *(tmgr_trace **)&jarg6; 
3026   arg7 = (int)jarg7; 
3027   arg8 = (e_surf_resource_state_t)jarg8; 
3028   arg9 = *(tmgr_trace **)&jarg9; 
3029   arg10 = *(s_xbt_dict **)&jarg10; 
3030   result = (Cpu *)(arg1)->createCpu((char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
3031   *(Cpu **)&jresult = result; 
3032   {
3033     
3034   }
3035   return jresult;
3036 }
3037
3038
3039 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_CpuModel_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
3040   CpuModel *obj = *((CpuModel **)&objarg);
3041   (void)jcls;
3042   SwigDirector_CpuModel *director = dynamic_cast<SwigDirector_CpuModel *>(obj);
3043   if (director) {
3044     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
3045   }
3046 }
3047
3048
3049 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_CpuModel_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
3050   CpuModel *obj = *((CpuModel **)&objarg);
3051   SwigDirector_CpuModel *director = dynamic_cast<SwigDirector_CpuModel *>(obj);
3052   (void)jcls;
3053   if (director) {
3054     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
3055   }
3056 }
3057
3058
3059 SWIGEXPORT jstring JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1getName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3060   jstring jresult = 0 ;
3061   Resource *arg1 = (Resource *) 0 ;
3062   char *result = 0 ;
3063   
3064   (void)jenv;
3065   (void)jcls;
3066   (void)jarg1_;
3067   arg1 = *(Resource **)&jarg1; 
3068   result = (char *)(arg1)->getName();
3069   if (result) jresult = jenv->NewStringUTF((const char *)result);
3070   return jresult;
3071 }
3072
3073
3074 SWIGEXPORT jboolean JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1isUsed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3075   jboolean jresult = 0 ;
3076   Resource *arg1 = (Resource *) 0 ;
3077   bool result;
3078   
3079   (void)jenv;
3080   (void)jcls;
3081   (void)jarg1_;
3082   arg1 = *(Resource **)&jarg1; 
3083   result = (bool)(arg1)->isUsed();
3084   jresult = (jboolean)result; 
3085   return jresult;
3086 }
3087
3088
3089 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1getModel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3090   jlong jresult = 0 ;
3091   Resource *arg1 = (Resource *) 0 ;
3092   Model *result = 0 ;
3093   
3094   (void)jenv;
3095   (void)jcls;
3096   (void)jarg1_;
3097   arg1 = *(Resource **)&jarg1; 
3098   result = (Model *)(arg1)->getModel();
3099   *(Model **)&jresult = result; 
3100   return jresult;
3101 }
3102
3103
3104 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1getState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3105   jint jresult = 0 ;
3106   Resource *arg1 = (Resource *) 0 ;
3107   e_surf_resource_state_t result;
3108   
3109   (void)jenv;
3110   (void)jcls;
3111   (void)jarg1_;
3112   arg1 = *(Resource **)&jarg1; 
3113   result = (e_surf_resource_state_t)(arg1)->getState();
3114   jresult = (jint)result; 
3115   return jresult;
3116 }
3117
3118
3119 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1getConstraint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3120   jlong jresult = 0 ;
3121   Resource *arg1 = (Resource *) 0 ;
3122   lmm_constraint *result = 0 ;
3123   
3124   (void)jenv;
3125   (void)jcls;
3126   (void)jarg1_;
3127   arg1 = *(Resource **)&jarg1; 
3128   result = (lmm_constraint *)(arg1)->getConstraint();
3129   *(lmm_constraint **)&jresult = result; 
3130   return jresult;
3131 }
3132
3133
3134 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1getProperties(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3135   jlong jresult = 0 ;
3136   Resource *arg1 = (Resource *) 0 ;
3137   s_xbt_dict *result = 0 ;
3138   
3139   (void)jenv;
3140   (void)jcls;
3141   (void)jarg1_;
3142   arg1 = *(Resource **)&jarg1; 
3143   result = (s_xbt_dict *)(arg1)->getProperties();
3144   *(s_xbt_dict **)&jresult = result; 
3145   return jresult;
3146 }
3147
3148
3149 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1updateState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jdouble jarg3, jdouble jarg4) {
3150   Resource *arg1 = (Resource *) 0 ;
3151   tmgr_trace_event *arg2 = (tmgr_trace_event *) 0 ;
3152   double arg3 ;
3153   double arg4 ;
3154   
3155   (void)jenv;
3156   (void)jcls;
3157   (void)jarg1_;
3158   (void)jarg2_;
3159   arg1 = *(Resource **)&jarg1; 
3160   arg2 = *(tmgr_trace_event **)&jarg2; 
3161   arg3 = (double)jarg3; 
3162   arg4 = (double)jarg4; 
3163   (arg1)->updateState(arg2,arg3,arg4);
3164 }
3165
3166
3167 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1Resource(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3168   Resource *arg1 = (Resource *) 0 ;
3169   
3170   (void)jenv;
3171   (void)jcls;
3172   arg1 = *(Resource **)&jarg1; 
3173   delete arg1;
3174 }
3175
3176
3177 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1Cpu_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jint jarg5, jdouble jarg6, jdouble jarg7) {
3178   jlong jresult = 0 ;
3179   Model *arg1 = (Model *) 0 ;
3180   char *arg2 = (char *) 0 ;
3181   s_xbt_dict *arg3 = (s_xbt_dict *) 0 ;
3182   lmm_constraint *arg4 = (lmm_constraint *) 0 ;
3183   int arg5 ;
3184   double arg6 ;
3185   double arg7 ;
3186   Cpu *result = 0 ;
3187   
3188   (void)jenv;
3189   (void)jcls;
3190   (void)jarg1_;
3191   (void)jarg3_;
3192   (void)jarg4_;
3193   arg1 = *(Model **)&jarg1; 
3194   arg2 = 0;
3195   if (jarg2) {
3196     arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
3197     if (!arg2) return 0;
3198   }
3199   arg3 = *(s_xbt_dict **)&jarg3; 
3200   arg4 = *(lmm_constraint **)&jarg4; 
3201   arg5 = (int)jarg5; 
3202   arg6 = (double)jarg6; 
3203   arg7 = (double)jarg7; 
3204   result = (Cpu *)new SwigDirector_Cpu(jenv,arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
3205   *(Cpu **)&jresult = result; 
3206   {
3207     
3208   }
3209   return jresult;
3210 }
3211
3212
3213 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1Cpu_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jint jarg4, jdouble jarg5, jdouble jarg6) {
3214   jlong jresult = 0 ;
3215   Model *arg1 = (Model *) 0 ;
3216   char *arg2 = (char *) 0 ;
3217   s_xbt_dict *arg3 = (s_xbt_dict *) 0 ;
3218   int arg4 ;
3219   double arg5 ;
3220   double arg6 ;
3221   Cpu *result = 0 ;
3222   
3223   (void)jenv;
3224   (void)jcls;
3225   (void)jarg1_;
3226   (void)jarg3_;
3227   arg1 = *(Model **)&jarg1; 
3228   arg2 = 0;
3229   if (jarg2) {
3230     arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
3231     if (!arg2) return 0;
3232   }
3233   arg3 = *(s_xbt_dict **)&jarg3; 
3234   arg4 = (int)jarg4; 
3235   arg5 = (double)jarg5; 
3236   arg6 = (double)jarg6; 
3237   result = (Cpu *)new SwigDirector_Cpu(jenv,arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
3238   *(Cpu **)&jresult = result; 
3239   {
3240     
3241   }
3242   return jresult;
3243 }
3244
3245
3246 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1Cpu(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3247   Cpu *arg1 = (Cpu *) 0 ;
3248   
3249   (void)jenv;
3250   (void)jcls;
3251   arg1 = *(Cpu **)&jarg1; 
3252   delete arg1;
3253 }
3254
3255
3256 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getCurrentPowerPeak(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3257   jdouble jresult = 0 ;
3258   Cpu *arg1 = (Cpu *) 0 ;
3259   double result;
3260   
3261   (void)jenv;
3262   (void)jcls;
3263   (void)jarg1_;
3264   arg1 = *(Cpu **)&jarg1; 
3265   result = (double)(arg1)->getCurrentPowerPeak();
3266   jresult = (jdouble)result; 
3267   return jresult;
3268 }
3269
3270
3271 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getCurrentPowerPeakSwigExplicitCpu(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3272   jdouble jresult = 0 ;
3273   Cpu *arg1 = (Cpu *) 0 ;
3274   double result;
3275   
3276   (void)jenv;
3277   (void)jcls;
3278   (void)jarg1_;
3279   arg1 = *(Cpu **)&jarg1; 
3280   result = (double)(arg1)->Cpu::getCurrentPowerPeak();
3281   jresult = (jdouble)result; 
3282   return jresult;
3283 }
3284
3285
3286 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1execute(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3287   jlong jresult = 0 ;
3288   Cpu *arg1 = (Cpu *) 0 ;
3289   double arg2 ;
3290   CpuAction *result = 0 ;
3291   
3292   (void)jenv;
3293   (void)jcls;
3294   (void)jarg1_;
3295   arg1 = *(Cpu **)&jarg1; 
3296   arg2 = (double)jarg2; 
3297   result = (CpuAction *)(arg1)->execute(arg2);
3298   *(CpuAction **)&jresult = result; 
3299   return jresult;
3300 }
3301
3302
3303 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1sleep(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3304   jlong jresult = 0 ;
3305   Cpu *arg1 = (Cpu *) 0 ;
3306   double arg2 ;
3307   CpuAction *result = 0 ;
3308   
3309   (void)jenv;
3310   (void)jcls;
3311   (void)jarg1_;
3312   arg1 = *(Cpu **)&jarg1; 
3313   arg2 = (double)jarg2; 
3314   result = (CpuAction *)(arg1)->sleep(arg2);
3315   *(CpuAction **)&jresult = result; 
3316   return jresult;
3317 }
3318
3319
3320 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getCore(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3321   jint jresult = 0 ;
3322   Cpu *arg1 = (Cpu *) 0 ;
3323   int result;
3324   
3325   (void)jenv;
3326   (void)jcls;
3327   (void)jarg1_;
3328   arg1 = *(Cpu **)&jarg1; 
3329   result = (int)(arg1)->getCore();
3330   jresult = (jint)result; 
3331   return jresult;
3332 }
3333
3334
3335 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getCoreSwigExplicitCpu(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3336   jint jresult = 0 ;
3337   Cpu *arg1 = (Cpu *) 0 ;
3338   int result;
3339   
3340   (void)jenv;
3341   (void)jcls;
3342   (void)jarg1_;
3343   arg1 = *(Cpu **)&jarg1; 
3344   result = (int)(arg1)->Cpu::getCore();
3345   jresult = (jint)result; 
3346   return jresult;
3347 }
3348
3349
3350 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getSpeed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3351   jdouble jresult = 0 ;
3352   Cpu *arg1 = (Cpu *) 0 ;
3353   double arg2 ;
3354   double result;
3355   
3356   (void)jenv;
3357   (void)jcls;
3358   (void)jarg1_;
3359   arg1 = *(Cpu **)&jarg1; 
3360   arg2 = (double)jarg2; 
3361   result = (double)(arg1)->getSpeed(arg2);
3362   jresult = (jdouble)result; 
3363   return jresult;
3364 }
3365
3366
3367 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getSpeedSwigExplicitCpu(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3368   jdouble jresult = 0 ;
3369   Cpu *arg1 = (Cpu *) 0 ;
3370   double arg2 ;
3371   double result;
3372   
3373   (void)jenv;
3374   (void)jcls;
3375   (void)jarg1_;
3376   arg1 = *(Cpu **)&jarg1; 
3377   arg2 = (double)jarg2; 
3378   result = (double)(arg1)->Cpu::getSpeed(arg2);
3379   jresult = (jdouble)result; 
3380   return jresult;
3381 }
3382
3383
3384 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getAvailableSpeed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3385   jdouble jresult = 0 ;
3386   Cpu *arg1 = (Cpu *) 0 ;
3387   double result;
3388   
3389   (void)jenv;
3390   (void)jcls;
3391   (void)jarg1_;
3392   arg1 = *(Cpu **)&jarg1; 
3393   result = (double)(arg1)->getAvailableSpeed();
3394   jresult = (jdouble)result; 
3395   return jresult;
3396 }
3397
3398
3399 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getAvailableSpeedSwigExplicitCpu(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3400   jdouble jresult = 0 ;
3401   Cpu *arg1 = (Cpu *) 0 ;
3402   double result;
3403   
3404   (void)jenv;
3405   (void)jcls;
3406   (void)jarg1_;
3407   arg1 = *(Cpu **)&jarg1; 
3408   result = (double)(arg1)->Cpu::getAvailableSpeed();
3409   jresult = (jdouble)result; 
3410   return jresult;
3411 }
3412
3413
3414 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getPowerPeakAt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3415   jdouble jresult = 0 ;
3416   Cpu *arg1 = (Cpu *) 0 ;
3417   int arg2 ;
3418   double result;
3419   
3420   (void)jenv;
3421   (void)jcls;
3422   (void)jarg1_;
3423   arg1 = *(Cpu **)&jarg1; 
3424   arg2 = (int)jarg2; 
3425   result = (double)(arg1)->getPowerPeakAt(arg2);
3426   jresult = (jdouble)result; 
3427   return jresult;
3428 }
3429
3430
3431 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getNbPstates(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3432   jint jresult = 0 ;
3433   Cpu *arg1 = (Cpu *) 0 ;
3434   int result;
3435   
3436   (void)jenv;
3437   (void)jcls;
3438   (void)jarg1_;
3439   arg1 = *(Cpu **)&jarg1; 
3440   result = (int)(arg1)->getNbPstates();
3441   jresult = (jint)result; 
3442   return jresult;
3443 }
3444
3445
3446 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1setPowerPeakAt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3447   Cpu *arg1 = (Cpu *) 0 ;
3448   int arg2 ;
3449   
3450   (void)jenv;
3451   (void)jcls;
3452   (void)jarg1_;
3453   arg1 = *(Cpu **)&jarg1; 
3454   arg2 = (int)jarg2; 
3455   (arg1)->setPowerPeakAt(arg2);
3456 }
3457
3458
3459 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1setState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3460   Cpu *arg1 = (Cpu *) 0 ;
3461   e_surf_resource_state_t arg2 ;
3462   
3463   (void)jenv;
3464   (void)jcls;
3465   (void)jarg1_;
3466   arg1 = *(Cpu **)&jarg1; 
3467   arg2 = (e_surf_resource_state_t)jarg2; 
3468   (arg1)->setState(arg2);
3469 }
3470
3471
3472 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
3473   Cpu *obj = *((Cpu **)&objarg);
3474   (void)jcls;
3475   SwigDirector_Cpu *director = dynamic_cast<SwigDirector_Cpu *>(obj);
3476   if (director) {
3477     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
3478   }
3479 }
3480
3481
3482 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
3483   Cpu *obj = *((Cpu **)&objarg);
3484   SwigDirector_Cpu *director = dynamic_cast<SwigDirector_Cpu *>(obj);
3485   (void)jcls;
3486   if (director) {
3487     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
3488   }
3489 }
3490
3491
3492 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1NetworkLink(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3493   NetworkLink *arg1 = (NetworkLink *) 0 ;
3494   
3495   (void)jenv;
3496   (void)jcls;
3497   arg1 = *(NetworkLink **)&jarg1; 
3498   delete arg1;
3499 }
3500
3501
3502 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1getBandwidth(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3503   jdouble jresult = 0 ;
3504   NetworkLink *arg1 = (NetworkLink *) 0 ;
3505   double result;
3506   
3507   (void)jenv;
3508   (void)jcls;
3509   (void)jarg1_;
3510   arg1 = *(NetworkLink **)&jarg1; 
3511   result = (double)(arg1)->getBandwidth();
3512   jresult = (jdouble)result; 
3513   return jresult;
3514 }
3515
3516
3517 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1updateBandwidth_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3) {
3518   NetworkLink *arg1 = (NetworkLink *) 0 ;
3519   double arg2 ;
3520   double arg3 ;
3521   
3522   (void)jenv;
3523   (void)jcls;
3524   (void)jarg1_;
3525   arg1 = *(NetworkLink **)&jarg1; 
3526   arg2 = (double)jarg2; 
3527   arg3 = (double)jarg3; 
3528   (arg1)->updateBandwidth(arg2,arg3);
3529 }
3530
3531
3532 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1updateBandwidth_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3533   NetworkLink *arg1 = (NetworkLink *) 0 ;
3534   double arg2 ;
3535   
3536   (void)jenv;
3537   (void)jcls;
3538   (void)jarg1_;
3539   arg1 = *(NetworkLink **)&jarg1; 
3540   arg2 = (double)jarg2; 
3541   (arg1)->updateBandwidth(arg2);
3542 }
3543
3544
3545 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1getLatency(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3546   jdouble jresult = 0 ;
3547   NetworkLink *arg1 = (NetworkLink *) 0 ;
3548   double result;
3549   
3550   (void)jenv;
3551   (void)jcls;
3552   (void)jarg1_;
3553   arg1 = *(NetworkLink **)&jarg1; 
3554   result = (double)(arg1)->getLatency();
3555   jresult = (jdouble)result; 
3556   return jresult;
3557 }
3558
3559
3560 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1updateLatency_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3) {
3561   NetworkLink *arg1 = (NetworkLink *) 0 ;
3562   double arg2 ;
3563   double arg3 ;
3564   
3565   (void)jenv;
3566   (void)jcls;
3567   (void)jarg1_;
3568   arg1 = *(NetworkLink **)&jarg1; 
3569   arg2 = (double)jarg2; 
3570   arg3 = (double)jarg3; 
3571   (arg1)->updateLatency(arg2,arg3);
3572 }
3573
3574
3575 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1updateLatency_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3576   NetworkLink *arg1 = (NetworkLink *) 0 ;
3577   double arg2 ;
3578   
3579   (void)jenv;
3580   (void)jcls;
3581   (void)jarg1_;
3582   arg1 = *(NetworkLink **)&jarg1; 
3583   arg2 = (double)jarg2; 
3584   (arg1)->updateLatency(arg2);
3585 }
3586
3587
3588 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1Action(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jboolean jarg3) {
3589   jlong jresult = 0 ;
3590   Model *arg1 = (Model *) 0 ;
3591   double arg2 ;
3592   bool arg3 ;
3593   Action *result = 0 ;
3594   
3595   (void)jenv;
3596   (void)jcls;
3597   (void)jarg1_;
3598   arg1 = *(Model **)&jarg1; 
3599   arg2 = (double)jarg2; 
3600   arg3 = jarg3 ? true : false; 
3601   result = (Action *)new Action(arg1,arg2,arg3);
3602   *(Action **)&jresult = result; 
3603   return jresult;
3604 }
3605
3606
3607 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1Action(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3608   Action *arg1 = (Action *) 0 ;
3609   
3610   (void)jenv;
3611   (void)jcls;
3612   arg1 = *(Action **)&jarg1; 
3613   delete arg1;
3614 }
3615
3616
3617 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Action_1getModel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3618   jlong jresult = 0 ;
3619   Action *arg1 = (Action *) 0 ;
3620   Model *result = 0 ;
3621   
3622   (void)jenv;
3623   (void)jcls;
3624   (void)jarg1_;
3625   arg1 = *(Action **)&jarg1; 
3626   result = (Model *)(arg1)->getModel();
3627   *(Model **)&jresult = result; 
3628   return jresult;
3629 }
3630
3631
3632 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Action_1getVariable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3633   jlong jresult = 0 ;
3634   Action *arg1 = (Action *) 0 ;
3635   lmm_variable *result = 0 ;
3636   
3637   (void)jenv;
3638   (void)jcls;
3639   (void)jarg1_;
3640   arg1 = *(Action **)&jarg1; 
3641   result = (lmm_variable *)(arg1)->getVariable();
3642   *(lmm_variable **)&jresult = result; 
3643   return jresult;
3644 }
3645
3646
3647 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_Action_1getState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3648   jint jresult = 0 ;
3649   Action *arg1 = (Action *) 0 ;
3650   e_surf_action_state_t result;
3651   
3652   (void)jenv;
3653   (void)jcls;
3654   (void)jarg1_;
3655   arg1 = *(Action **)&jarg1; 
3656   result = (e_surf_action_state_t)(arg1)->getState();
3657   jresult = (jint)result; 
3658   return jresult;
3659 }
3660
3661
3662 SWIGEXPORT jboolean JNICALL Java_org_simgrid_surf_SurfJNI_Action_1isSuspended(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3663   jboolean jresult = 0 ;
3664   Action *arg1 = (Action *) 0 ;
3665   bool result;
3666   
3667   (void)jenv;
3668   (void)jcls;
3669   (void)jarg1_;
3670   arg1 = *(Action **)&jarg1; 
3671   result = (bool)(arg1)->isSuspended();
3672   jresult = (jboolean)result; 
3673   return jresult;
3674 }
3675
3676
3677 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Action_1getBound(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3678   jdouble jresult = 0 ;
3679   Action *arg1 = (Action *) 0 ;
3680   double result;
3681   
3682   (void)jenv;
3683   (void)jcls;
3684   (void)jarg1_;
3685   arg1 = *(Action **)&jarg1; 
3686   result = (double)(arg1)->getBound();
3687   jresult = (jdouble)result; 
3688   return jresult;
3689 }
3690
3691
3692 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Action_1setBound(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3693   Action *arg1 = (Action *) 0 ;
3694   double arg2 ;
3695   
3696   (void)jenv;
3697   (void)jcls;
3698   (void)jarg1_;
3699   arg1 = *(Action **)&jarg1; 
3700   arg2 = (double)jarg2; 
3701   (arg1)->setBound(arg2);
3702 }
3703
3704
3705 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Action_1updateRemains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3706   Action *arg1 = (Action *) 0 ;
3707   double arg2 ;
3708   
3709   (void)jenv;
3710   (void)jcls;
3711   (void)jarg1_;
3712   arg1 = *(Action **)&jarg1; 
3713   arg2 = (double)jarg2; 
3714   (arg1)->updateRemains(arg2);
3715 }
3716
3717
3718 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Action_1getRemains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3719   jdouble jresult = 0 ;
3720   Action *arg1 = (Action *) 0 ;
3721   double result;
3722   
3723   (void)jenv;
3724   (void)jcls;
3725   (void)jarg1_;
3726   arg1 = *(Action **)&jarg1; 
3727   result = (double)(arg1)->getRemains();
3728   jresult = (jdouble)result; 
3729   return jresult;
3730 }
3731
3732
3733 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Action_1setPriority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3734   Action *arg1 = (Action *) 0 ;
3735   double arg2 ;
3736   
3737   (void)jenv;
3738   (void)jcls;
3739   (void)jarg1_;
3740   arg1 = *(Action **)&jarg1; 
3741   arg2 = (double)jarg2; 
3742   (arg1)->setPriority(arg2);
3743 }
3744
3745
3746 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Action_1setState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3747   Action *arg1 = (Action *) 0 ;
3748   e_surf_action_state_t arg2 ;
3749   
3750   (void)jenv;
3751   (void)jcls;
3752   (void)jarg1_;
3753   arg1 = *(Action **)&jarg1; 
3754   arg2 = (e_surf_action_state_t)jarg2; 
3755   (arg1)->setState(arg2);
3756 }
3757
3758
3759 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1CpuAction(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jboolean jarg3) {
3760   jlong jresult = 0 ;
3761   Model *arg1 = (Model *) 0 ;
3762   double arg2 ;
3763   bool arg3 ;
3764   CpuAction *result = 0 ;
3765   
3766   (void)jenv;
3767   (void)jcls;
3768   (void)jarg1_;
3769   arg1 = *(Model **)&jarg1; 
3770   arg2 = (double)jarg2; 
3771   arg3 = jarg3 ? true : false; 
3772   result = (CpuAction *)new SwigDirector_CpuAction(jenv,arg1,arg2,arg3);
3773   *(CpuAction **)&jresult = result; 
3774   return jresult;
3775 }
3776
3777
3778 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_CpuAction_1getCpu(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3779   jlong jresult = 0 ;
3780   CpuAction *arg1 = (CpuAction *) 0 ;
3781   Cpu *result = 0 ;
3782   
3783   (void)jenv;
3784   (void)jcls;
3785   (void)jarg1_;
3786   arg1 = *(CpuAction **)&jarg1; 
3787   result = (Cpu *)CpuAction_getCpu(arg1);
3788   *(Cpu **)&jresult = result; 
3789   return jresult;
3790 }
3791
3792
3793 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1CpuAction(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3794   CpuAction *arg1 = (CpuAction *) 0 ;
3795   
3796   (void)jenv;
3797   (void)jcls;
3798   arg1 = *(CpuAction **)&jarg1; 
3799   delete arg1;
3800 }
3801
3802
3803 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_CpuAction_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
3804   CpuAction *obj = *((CpuAction **)&objarg);
3805   (void)jcls;
3806   SwigDirector_CpuAction *director = dynamic_cast<SwigDirector_CpuAction *>(obj);
3807   if (director) {
3808     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
3809   }
3810 }
3811
3812
3813 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_CpuAction_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
3814   CpuAction *obj = *((CpuAction **)&objarg);
3815   SwigDirector_CpuAction *director = dynamic_cast<SwigDirector_CpuAction *>(obj);
3816   (void)jcls;
3817   if (director) {
3818     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
3819   }
3820 }
3821
3822
3823 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_NetworkAction_1getLatency(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3824   jdouble jresult = 0 ;
3825   NetworkAction *arg1 = (NetworkAction *) 0 ;
3826   double result;
3827   
3828   (void)jenv;
3829   (void)jcls;
3830   (void)jarg1_;
3831   arg1 = *(NetworkAction **)&jarg1; 
3832   result = (double)NetworkAction_getLatency(arg1);
3833   jresult = (jdouble)result; 
3834   return jresult;
3835 }
3836
3837
3838 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1NetworkAction(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3839   NetworkAction *arg1 = (NetworkAction *) 0 ;
3840   
3841   (void)jenv;
3842   (void)jcls;
3843   arg1 = *(NetworkAction **)&jarg1; 
3844   delete arg1;
3845 }
3846
3847
3848 SWIGEXPORT jstring JNICALL Java_org_simgrid_surf_SurfJNI_RoutingEdge_1getName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3849   jstring jresult = 0 ;
3850   RoutingEdge *arg1 = (RoutingEdge *) 0 ;
3851   char *result = 0 ;
3852   
3853   (void)jenv;
3854   (void)jcls;
3855   (void)jarg1_;
3856   arg1 = *(RoutingEdge **)&jarg1; 
3857   result = (char *)(arg1)->getName();
3858   if (result) jresult = jenv->NewStringUTF((const char *)result);
3859   return jresult;
3860 }
3861
3862
3863 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1RoutingEdge(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3864   RoutingEdge *arg1 = (RoutingEdge *) 0 ;
3865   
3866   (void)jenv;
3867   (void)jcls;
3868   arg1 = *(RoutingEdge **)&jarg1; 
3869   delete arg1;
3870 }
3871
3872
3873 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_LmmConstraint_1getUsage(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3874   jdouble jresult = 0 ;
3875   lmm_constraint *arg1 = (lmm_constraint *) 0 ;
3876   double result;
3877   
3878   (void)jenv;
3879   (void)jcls;
3880   (void)jarg1_;
3881   arg1 = *(lmm_constraint **)&jarg1; 
3882   result = (double)lmm_constraint_getUsage(arg1);
3883   jresult = (jdouble)result; 
3884   return jresult;
3885 }
3886
3887
3888 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1LmmConstraint(JNIEnv *jenv, jclass jcls) {
3889   jlong jresult = 0 ;
3890   lmm_constraint *result = 0 ;
3891   
3892   (void)jenv;
3893   (void)jcls;
3894   result = (lmm_constraint *)new lmm_constraint();
3895   *(lmm_constraint **)&jresult = result; 
3896   return jresult;
3897 }
3898
3899
3900 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1LmmConstraint(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3901   lmm_constraint *arg1 = (lmm_constraint *) 0 ;
3902   
3903   (void)jenv;
3904   (void)jcls;
3905   arg1 = *(lmm_constraint **)&jarg1; 
3906   delete arg1;
3907 }
3908
3909
3910 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_LmmVariable_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3911   jdouble jresult = 0 ;
3912   lmm_variable *arg1 = (lmm_variable *) 0 ;
3913   double result;
3914   
3915   (void)jenv;
3916   (void)jcls;
3917   (void)jarg1_;
3918   arg1 = *(lmm_variable **)&jarg1; 
3919   result = (double)lmm_variable_getValue(arg1);
3920   jresult = (jdouble)result; 
3921   return jresult;
3922 }
3923
3924
3925 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1LmmVariable(JNIEnv *jenv, jclass jcls) {
3926   jlong jresult = 0 ;
3927   lmm_variable *result = 0 ;
3928   
3929   (void)jenv;
3930   (void)jcls;
3931   result = (lmm_variable *)new lmm_variable();
3932   *(lmm_variable **)&jresult = result; 
3933   return jresult;
3934 }
3935
3936
3937 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1LmmVariable(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3938   lmm_variable *arg1 = (lmm_variable *) 0 ;
3939   
3940   (void)jenv;
3941   (void)jcls;
3942   arg1 = *(lmm_variable **)&jarg1; 
3943   delete arg1;
3944 }
3945
3946
3947 SWIGEXPORT jstring JNICALL Java_org_simgrid_surf_SurfJNI_XbtDict_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
3948   jstring jresult = 0 ;
3949   s_xbt_dict *arg1 = (s_xbt_dict *) 0 ;
3950   char *arg2 = (char *) 0 ;
3951   char *result = 0 ;
3952   
3953   (void)jenv;
3954   (void)jcls;
3955   (void)jarg1_;
3956   arg1 = *(s_xbt_dict **)&jarg1; 
3957   arg2 = 0;
3958   if (jarg2) {
3959     arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
3960     if (!arg2) return 0;
3961   }
3962   result = (char *)s_xbt_dict_getValue(arg1,arg2);
3963   if (result) jresult = jenv->NewStringUTF((const char *)result);
3964   if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
3965   return jresult;
3966 }
3967
3968
3969 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1XbtDict(JNIEnv *jenv, jclass jcls) {
3970   jlong jresult = 0 ;
3971   s_xbt_dict *result = 0 ;
3972   
3973   (void)jenv;
3974   (void)jcls;
3975   result = (s_xbt_dict *)new s_xbt_dict();
3976   *(s_xbt_dict **)&jresult = result; 
3977   return jresult;
3978 }
3979
3980
3981 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1XbtDict(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3982   s_xbt_dict *arg1 = (s_xbt_dict *) 0 ;
3983   
3984   (void)jenv;
3985   (void)jcls;
3986   arg1 = *(s_xbt_dict **)&jarg1; 
3987   delete arg1;
3988 }
3989
3990
3991 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_SURF_1ACTION_1READY_1get(JNIEnv *jenv, jclass jcls) {
3992   jint jresult = 0 ;
3993   e_surf_action_state_t result;
3994   
3995   (void)jenv;
3996   (void)jcls;
3997   result = (e_surf_action_state_t)SURF_ACTION_READY;
3998   jresult = (jint)result; 
3999   return jresult;
4000 }
4001
4002
4003 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_SURF_1RESOURCE_1ON_1get(JNIEnv *jenv, jclass jcls) {
4004   jint jresult = 0 ;
4005   e_surf_resource_state_t result;
4006   
4007   (void)jenv;
4008   (void)jcls;
4009   result = (e_surf_resource_state_t)SURF_RESOURCE_ON;
4010   jresult = (jint)result; 
4011   return jresult;
4012 }
4013
4014
4015 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_SURF_1RESOURCE_1OFF_1get(JNIEnv *jenv, jclass jcls) {
4016   jint jresult = 0 ;
4017   e_surf_resource_state_t result;
4018   
4019   (void)jenv;
4020   (void)jcls;
4021   result = (e_surf_resource_state_t)SURF_RESOURCE_OFF;
4022   jresult = (jint)result; 
4023   return jresult;
4024 }
4025
4026
4027 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_CpuModel_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
4028     jlong baseptr = 0;
4029     (void)jenv;
4030     (void)jcls;
4031     *(Model **)&baseptr = *(CpuModel **)&jarg1;
4032     return baseptr;
4033 }
4034
4035 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
4036     jlong baseptr = 0;
4037     (void)jenv;
4038     (void)jcls;
4039     *(Resource **)&baseptr = *(Cpu **)&jarg1;
4040     return baseptr;
4041 }
4042
4043 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
4044     jlong baseptr = 0;
4045     (void)jenv;
4046     (void)jcls;
4047     *(Resource **)&baseptr = *(NetworkLink **)&jarg1;
4048     return baseptr;
4049 }
4050
4051 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_CpuAction_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
4052     jlong baseptr = 0;
4053     (void)jenv;
4054     (void)jcls;
4055     *(Action **)&baseptr = *(CpuAction **)&jarg1;
4056     return baseptr;
4057 }
4058
4059 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_NetworkAction_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
4060     jlong baseptr = 0;
4061     (void)jenv;
4062     (void)jcls;
4063     *(Action **)&baseptr = *(NetworkAction **)&jarg1;
4064     return baseptr;
4065 }
4066
4067 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) {
4068   int i;
4069   
4070   static struct {
4071     const char *method;
4072     const char *signature;
4073   } methods[33] = {
4074     {
4075       "SwigDirector_Plugin_cpuCreatedCallback", "(Lorg/simgrid/surf/Plugin;J)V" 
4076     },
4077     {
4078       "SwigDirector_Plugin_cpuDestructedCallback", "(Lorg/simgrid/surf/Plugin;J)V" 
4079     },
4080     {
4081       "SwigDirector_Plugin_cpuStateChangedCallback", "(Lorg/simgrid/surf/Plugin;JII)V" 
4082     },
4083     {
4084       "SwigDirector_Plugin_cpuActionStateChangedCallback", "(Lorg/simgrid/surf/Plugin;JII)V" 
4085     },
4086     {
4087       "SwigDirector_Plugin_networkLinkCreatedCallback", "(Lorg/simgrid/surf/Plugin;J)V" 
4088     },
4089     {
4090       "SwigDirector_Plugin_networkLinkDestructedCallback", "(Lorg/simgrid/surf/Plugin;J)V" 
4091     },
4092     {
4093       "SwigDirector_Plugin_networkLinkStateChangedCallback", "(Lorg/simgrid/surf/Plugin;JII)V" 
4094     },
4095     {
4096       "SwigDirector_Plugin_networkActionStateChangedCallback", "(Lorg/simgrid/surf/Plugin;JII)V" 
4097     },
4098     {
4099       "SwigDirector_Plugin_networkCommunicateCallback", "(Lorg/simgrid/surf/Plugin;JJJDD)V" 
4100     },
4101     {
4102       "SwigDirector_CpuModel_shareResources", "(Lorg/simgrid/surf/CpuModel;D)D" 
4103     },
4104     {
4105       "SwigDirector_CpuModel_shareResourcesLazy", "(Lorg/simgrid/surf/CpuModel;D)D" 
4106     },
4107     {
4108       "SwigDirector_CpuModel_shareResourcesFull", "(Lorg/simgrid/surf/CpuModel;D)D" 
4109     },
4110     {
4111       "SwigDirector_CpuModel_updateActionsState", "(Lorg/simgrid/surf/CpuModel;DD)V" 
4112     },
4113     {
4114       "SwigDirector_CpuModel_updateActionsStateLazy", "(Lorg/simgrid/surf/CpuModel;DD)V" 
4115     },
4116     {
4117       "SwigDirector_CpuModel_updateActionsStateFull", "(Lorg/simgrid/surf/CpuModel;DD)V" 
4118     },
4119     {
4120       "SwigDirector_CpuModel_getRunningActionSet", "(Lorg/simgrid/surf/CpuModel;)J" 
4121     },
4122     {
4123       "SwigDirector_CpuModel_addTraces", "(Lorg/simgrid/surf/CpuModel;)V" 
4124     },
4125     {
4126       "SwigDirector_CpuModel_createCpu", "(Lorg/simgrid/surf/CpuModel;Ljava/lang/String;[DIDJIIJJ)J" 
4127     },
4128     {
4129       "SwigDirector_Cpu_isUsed", "(Lorg/simgrid/surf/Cpu;)Z" 
4130     },
4131     {
4132       "SwigDirector_Cpu_getState", "(Lorg/simgrid/surf/Cpu;)I" 
4133     },
4134     {
4135       "SwigDirector_Cpu_updateState", "(Lorg/simgrid/surf/Cpu;JDD)V" 
4136     },
4137     {
4138       "SwigDirector_Cpu_getCurrentPowerPeak", "(Lorg/simgrid/surf/Cpu;)D" 
4139     },
4140     {
4141       "SwigDirector_Cpu_execute", "(Lorg/simgrid/surf/Cpu;D)J" 
4142     },
4143     {
4144       "SwigDirector_Cpu_sleep", "(Lorg/simgrid/surf/Cpu;D)J" 
4145     },
4146     {
4147       "SwigDirector_Cpu_getCore", "(Lorg/simgrid/surf/Cpu;)I" 
4148     },
4149     {
4150       "SwigDirector_Cpu_getSpeed", "(Lorg/simgrid/surf/Cpu;D)D" 
4151     },
4152     {
4153       "SwigDirector_Cpu_getAvailableSpeed", "(Lorg/simgrid/surf/Cpu;)D" 
4154     },
4155     {
4156       "SwigDirector_Cpu_getPowerPeakAt", "(Lorg/simgrid/surf/Cpu;I)D" 
4157     },
4158     {
4159       "SwigDirector_Cpu_getNbPstates", "(Lorg/simgrid/surf/Cpu;)I" 
4160     },
4161     {
4162       "SwigDirector_Cpu_setPowerPeakAt", "(Lorg/simgrid/surf/Cpu;I)V" 
4163     },
4164     {
4165       "SwigDirector_CpuAction_getRemains", "(Lorg/simgrid/surf/CpuAction;)D" 
4166     },
4167     {
4168       "SwigDirector_CpuAction_setPriority", "(Lorg/simgrid/surf/CpuAction;D)V" 
4169     },
4170     {
4171       "SwigDirector_CpuAction_setState", "(Lorg/simgrid/surf/CpuAction;I)V" 
4172     }
4173   };
4174   Swig::jclass_SurfJNI = (jclass) jenv->NewGlobalRef(jcls);
4175   if (!Swig::jclass_SurfJNI) return;
4176   for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {
4177     Swig::director_methids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);
4178     if (!Swig::director_methids[i]) return;
4179   }
4180 }
4181
4182
4183 #ifdef __cplusplus
4184 }
4185 #endif
4186