src/bindings/java/surfJAVA_wrap.cxx

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 2.0.11
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #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 Action *Model_getRunningActionS(Model *self){
1058     return (Action*)(&(self->getRunningActionSet()->front()));
1059   }
1060 SWIGINTERN Cpu *CpuAction_getCpu(CpuAction *self){return getActionCpu(self);}
1061 SWIGINTERN double NetworkAction_getLatency(NetworkAction *self){return self->m_latency;}
1062 SWIGINTERN double lmm_constraint_getUsage(lmm_constraint *self){return lmm_constraint_get_usage(self);}
1063 SWIGINTERN double lmm_variable_getValue(lmm_variable *self){return lmm_variable_getvalue(self);}
1064 SWIGINTERN char *s_xbt_dict_getValue(s_xbt_dict *self,char *key){return (char*)xbt_dict_get_or_null(self, key);}
1065
1066
1067 /* ---------------------------------------------------
1068  * C++ director class methods
1069  * --------------------------------------------------- */
1070
1071 #include "surfJAVA_wrap.h"
1072
1073 SwigDirector_Plugin::SwigDirector_Plugin(JNIEnv *jenv) : Plugin(), Swig::Director(jenv) {
1074 }
1075
1076 SwigDirector_Plugin::~SwigDirector_Plugin() {
1077   swig_disconnect_director_self("swigDirectorDisconnect");
1078 }
1079
1080
1081 void SwigDirector_Plugin::cpuCreatedCallback(Cpu *cpu) {
1082   JNIEnvWrapper swigjnienv(this) ;
1083   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1084   jobject swigjobj = (jobject) NULL ;
1085   jlong jcpu = 0 ;
1086
1087   if (!swig_override[0]) {
1088     Plugin::cpuCreatedCallback(cpu);
1089     return;
1090   }
1091   swigjobj = swig_get_self(jenv);
1092   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1093     *((Cpu **)&jcpu) = (Cpu *) cpu;
1094     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[0], swigjobj, jcpu);
1095     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1096   } else {
1097     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1098   }
1099   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1100 }
1101
1102 void SwigDirector_Plugin::cpuDestructedCallback(Cpu *cpu) {
1103   JNIEnvWrapper swigjnienv(this) ;
1104   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1105   jobject swigjobj = (jobject) NULL ;
1106   jlong jcpu = 0 ;
1107
1108   if (!swig_override[1]) {
1109     Plugin::cpuDestructedCallback(cpu);
1110     return;
1111   }
1112   swigjobj = swig_get_self(jenv);
1113   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1114     *((Cpu **)&jcpu) = (Cpu *) cpu;
1115     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[1], swigjobj, jcpu);
1116     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1117   } else {
1118     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1119   }
1120   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1121 }
1122
1123 void SwigDirector_Plugin::cpuStateChangedCallback(Cpu *cpu, e_surf_resource_state_t arg1, e_surf_resource_state_t arg2) {
1124   JNIEnvWrapper swigjnienv(this) ;
1125   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1126   jobject swigjobj = (jobject) NULL ;
1127   jlong jcpu = 0 ;
1128   jint jarg1  ;
1129   jint jarg2  ;
1130
1131   if (!swig_override[2]) {
1132     Plugin::cpuStateChangedCallback(cpu,arg1,arg2);
1133     return;
1134   }
1135   swigjobj = swig_get_self(jenv);
1136   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1137     *((Cpu **)&jcpu) = (Cpu *) cpu;
1138     jarg1 = (jint) arg1;
1139     jarg2 = (jint) arg2;
1140     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[2], swigjobj, jcpu, jarg1, jarg2);
1141     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1142   } else {
1143     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1144   }
1145   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1146 }
1147
1148 void SwigDirector_Plugin::cpuActionStateChangedCallback(CpuAction *action, e_surf_action_state_t arg1, e_surf_action_state_t arg2) {
1149   JNIEnvWrapper swigjnienv(this) ;
1150   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1151   jobject swigjobj = (jobject) NULL ;
1152   jlong jaction = 0 ;
1153   jint jarg1  ;
1154   jint jarg2  ;
1155
1156   if (!swig_override[3]) {
1157     Plugin::cpuActionStateChangedCallback(action,arg1,arg2);
1158     return;
1159   }
1160   swigjobj = swig_get_self(jenv);
1161   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1162     *((CpuAction **)&jaction) = (CpuAction *) action;
1163     jarg1 = (jint) arg1;
1164     jarg2 = (jint) arg2;
1165     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[3], swigjobj, jaction, jarg1, jarg2);
1166     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1167   } else {
1168     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1169   }
1170   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1171 }
1172
1173 void SwigDirector_Plugin::networkLinkCreatedCallback(NetworkLink *link) {
1174   JNIEnvWrapper swigjnienv(this) ;
1175   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1176   jobject swigjobj = (jobject) NULL ;
1177   jlong jlink = 0 ;
1178
1179   if (!swig_override[4]) {
1180     Plugin::networkLinkCreatedCallback(link);
1181     return;
1182   }
1183   swigjobj = swig_get_self(jenv);
1184   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1185     *((NetworkLink **)&jlink) = (NetworkLink *) link;
1186     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[4], swigjobj, jlink);
1187     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1188   } else {
1189     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1190   }
1191   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1192 }
1193
1194 void SwigDirector_Plugin::networkLinkDestructedCallback(NetworkLink *link) {
1195   JNIEnvWrapper swigjnienv(this) ;
1196   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1197   jobject swigjobj = (jobject) NULL ;
1198   jlong jlink = 0 ;
1199
1200   if (!swig_override[5]) {
1201     Plugin::networkLinkDestructedCallback(link);
1202     return;
1203   }
1204   swigjobj = swig_get_self(jenv);
1205   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1206     *((NetworkLink **)&jlink) = (NetworkLink *) link;
1207     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[5], swigjobj, jlink);
1208     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1209   } else {
1210     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1211   }
1212   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1213 }
1214
1215 void SwigDirector_Plugin::networkLinkStateChangedCallback(NetworkLink *link, e_surf_resource_state_t arg1, e_surf_resource_state_t arg2) {
1216   JNIEnvWrapper swigjnienv(this) ;
1217   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1218   jobject swigjobj = (jobject) NULL ;
1219   jlong jlink = 0 ;
1220   jint jarg1  ;
1221   jint jarg2  ;
1222
1223   if (!swig_override[6]) {
1224     Plugin::networkLinkStateChangedCallback(link,arg1,arg2);
1225     return;
1226   }
1227   swigjobj = swig_get_self(jenv);
1228   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1229     *((NetworkLink **)&jlink) = (NetworkLink *) link;
1230     jarg1 = (jint) arg1;
1231     jarg2 = (jint) arg2;
1232     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[6], swigjobj, jlink, jarg1, jarg2);
1233     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1234   } else {
1235     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1236   }
1237   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1238 }
1239
1240 void SwigDirector_Plugin::networkActionStateChangedCallback(NetworkAction *action, e_surf_action_state_t old, e_surf_action_state_t cur) {
1241   JNIEnvWrapper swigjnienv(this) ;
1242   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1243   jobject swigjobj = (jobject) NULL ;
1244   jlong jaction = 0 ;
1245   jint jold  ;
1246   jint jcur  ;
1247
1248   if (!swig_override[7]) {
1249     Plugin::networkActionStateChangedCallback(action,old,cur);
1250     return;
1251   }
1252   swigjobj = swig_get_self(jenv);
1253   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1254     *((NetworkAction **)&jaction) = (NetworkAction *) action;
1255     jold = (jint) old;
1256     jcur = (jint) cur;
1257     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[7], swigjobj, jaction, jold, jcur);
1258     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1259   } else {
1260     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1261   }
1262   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1263 }
1264
1265 void SwigDirector_Plugin::networkCommunicateCallback(NetworkAction *action, RoutingEdge *src, RoutingEdge *dst, double size, double rate) {
1266   JNIEnvWrapper swigjnienv(this) ;
1267   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1268   jobject swigjobj = (jobject) NULL ;
1269   jlong jaction = 0 ;
1270   jlong jsrc = 0 ;
1271   jlong jdst = 0 ;
1272   jdouble jsize  ;
1273   jdouble jrate  ;
1274
1275   if (!swig_override[8]) {
1276     Plugin::networkCommunicateCallback(action,src,dst,size,rate);
1277     return;
1278   }
1279   swigjobj = swig_get_self(jenv);
1280   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1281     *((NetworkAction **)&jaction) = (NetworkAction *) action;
1282     *((RoutingEdge **)&jsrc) = (RoutingEdge *) src;
1283     *((RoutingEdge **)&jdst) = (RoutingEdge *) dst;
1284     jsize = (jdouble) size;
1285     jrate = (jdouble) rate;
1286     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[8], swigjobj, jaction, jsrc, jdst, jsize, jrate);
1287     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1288   } else {
1289     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1290   }
1291   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1292 }
1293
1294 void SwigDirector_Plugin::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
1295   static struct {
1296     const char *mname;
1297     const char *mdesc;
1298     jmethodID base_methid;
1299   } methods[] = {
1300     {
1301       "cpuCreatedCallback", "(Lorg/simgrid/surf/Cpu;)V", NULL
1302     },
1303     {
1304       "cpuDestructedCallback", "(Lorg/simgrid/surf/Cpu;)V", NULL
1305     },
1306     {
1307       "cpuStateChangedCallback", "(Lorg/simgrid/surf/Cpu;Lorg/simgrid/surf/ResourceState;Lorg/simgrid/surf/ResourceState;)V", NULL
1308     },
1309     {
1310       "cpuActionStateChangedCallback", "(Lorg/simgrid/surf/CpuAction;Lorg/simgrid/surf/ActionState;Lorg/simgrid/surf/ActionState;)V", NULL
1311     },
1312     {
1313       "networkLinkCreatedCallback", "(Lorg/simgrid/surf/NetworkLink;)V", NULL
1314     },
1315     {
1316       "networkLinkDestructedCallback", "(Lorg/simgrid/surf/NetworkLink;)V", NULL
1317     },
1318     {
1319       "networkLinkStateChangedCallback", "(Lorg/simgrid/surf/NetworkLink;Lorg/simgrid/surf/ResourceState;Lorg/simgrid/surf/ResourceState;)V", NULL
1320     },
1321     {
1322       "networkActionStateChangedCallback", "(Lorg/simgrid/surf/NetworkAction;Lorg/simgrid/surf/ActionState;Lorg/simgrid/surf/ActionState;)V", NULL
1323     },
1324     {
1325       "networkCommunicateCallback", "(Lorg/simgrid/surf/NetworkAction;Lorg/simgrid/surf/RoutingEdge;Lorg/simgrid/surf/RoutingEdge;DD)V", NULL
1326     }
1327   };
1328
1329   static jclass baseclass = 0 ;
1330
1331   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
1332     if (!baseclass) {
1333       baseclass = jenv->FindClass("org/simgrid/surf/Plugin");
1334       if (!baseclass) return;
1335       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
1336     }
1337     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
1338     for (int i = 0; i < 9; ++i) {
1339       if (!methods[i].base_methid) {
1340         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
1341         if (!methods[i].base_methid) return;
1342       }
1343       swig_override[i] = false;
1344       if (derived) {
1345         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
1346         swig_override[i] = (methid != methods[i].base_methid);
1347         jenv->ExceptionClear();
1348       }
1349     }
1350   }
1351 }
1352
1353
1354 SwigDirector_CpuModel::SwigDirector_CpuModel(JNIEnv *jenv, char const *name) : CpuModel(name), Swig::Director(jenv) {
1355 }
1356
1357 double SwigDirector_CpuModel::shareResources(double now) {
1358   double c_result = SwigValueInit< double >() ;
1359   jdouble jresult = 0 ;
1360   JNIEnvWrapper swigjnienv(this) ;
1361   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1362   jobject swigjobj = (jobject) NULL ;
1363   jdouble jnow  ;
1364
1365   if (!swig_override[0]) {
1366     return Model::shareResources(now);
1367   }
1368   swigjobj = swig_get_self(jenv);
1369   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1370     jnow = (jdouble) now;
1371     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[9], swigjobj, jnow);
1372     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1373     c_result = (double)jresult;
1374   } else {
1375     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1376   }
1377   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1378   return c_result;
1379 }
1380
1381 double SwigDirector_CpuModel::shareResourcesLazy(double now) {
1382   double c_result = SwigValueInit< double >() ;
1383   jdouble jresult = 0 ;
1384   JNIEnvWrapper swigjnienv(this) ;
1385   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1386   jobject swigjobj = (jobject) NULL ;
1387   jdouble jnow  ;
1388
1389   if (!swig_override[1]) {
1390     return Model::shareResourcesLazy(now);
1391   }
1392   swigjobj = swig_get_self(jenv);
1393   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1394     jnow = (jdouble) now;
1395     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[10], swigjobj, jnow);
1396     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1397     c_result = (double)jresult;
1398   } else {
1399     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1400   }
1401   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1402   return c_result;
1403 }
1404
1405 double SwigDirector_CpuModel::shareResourcesFull(double now) {
1406   double c_result = SwigValueInit< double >() ;
1407   jdouble jresult = 0 ;
1408   JNIEnvWrapper swigjnienv(this) ;
1409   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1410   jobject swigjobj = (jobject) NULL ;
1411   jdouble jnow  ;
1412
1413   if (!swig_override[2]) {
1414     return Model::shareResourcesFull(now);
1415   }
1416   swigjobj = swig_get_self(jenv);
1417   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1418     jnow = (jdouble) now;
1419     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[11], swigjobj, jnow);
1420     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1421     c_result = (double)jresult;
1422   } else {
1423     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1424   }
1425   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1426   return c_result;
1427 }
1428
1429 void SwigDirector_CpuModel::updateActionsState(double now, double delta) {
1430   JNIEnvWrapper swigjnienv(this) ;
1431   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1432   jobject swigjobj = (jobject) NULL ;
1433   jdouble jnow  ;
1434   jdouble jdelta  ;
1435
1436   if (!swig_override[3]) {
1437     Model::updateActionsState(now,delta);
1438     return;
1439   }
1440   swigjobj = swig_get_self(jenv);
1441   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1442     jnow = (jdouble) now;
1443     jdelta = (jdouble) delta;
1444     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[12], swigjobj, jnow, jdelta);
1445     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1446   } else {
1447     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1448   }
1449   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1450 }
1451
1452 void SwigDirector_CpuModel::updateActionsStateLazy(double now, double delta) {
1453   JNIEnvWrapper swigjnienv(this) ;
1454   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1455   jobject swigjobj = (jobject) NULL ;
1456   jdouble jnow  ;
1457   jdouble jdelta  ;
1458
1459   if (!swig_override[4]) {
1460     Model::updateActionsStateLazy(now,delta);
1461     return;
1462   }
1463   swigjobj = swig_get_self(jenv);
1464   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1465     jnow = (jdouble) now;
1466     jdelta = (jdouble) delta;
1467     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[13], swigjobj, jnow, jdelta);
1468     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1469   } else {
1470     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1471   }
1472   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1473 }
1474
1475 void SwigDirector_CpuModel::updateActionsStateFull(double now, double delta) {
1476   JNIEnvWrapper swigjnienv(this) ;
1477   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1478   jobject swigjobj = (jobject) NULL ;
1479   jdouble jnow  ;
1480   jdouble jdelta  ;
1481
1482   if (!swig_override[5]) {
1483     Model::updateActionsStateFull(now,delta);
1484     return;
1485   }
1486   swigjobj = swig_get_self(jenv);
1487   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1488     jnow = (jdouble) now;
1489     jdelta = (jdouble) delta;
1490     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[14], swigjobj, jnow, jdelta);
1491     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1492   } else {
1493     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1494   }
1495   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1496 }
1497
1498 ActionList *SwigDirector_CpuModel::getRunningActionSet() {
1499   ActionList *c_result = 0 ;
1500   jlong jresult = 0 ;
1501   JNIEnvWrapper swigjnienv(this) ;
1502   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1503   jobject swigjobj = (jobject) NULL ;
1504
1505   if (!swig_override[6]) {
1506     return Model::getRunningActionSet();
1507   }
1508   swigjobj = swig_get_self(jenv);
1509   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1510     jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_SurfJNI, Swig::director_methids[15], swigjobj);
1511     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1512     c_result = *(ActionList **)&jresult;
1513   } else {
1514     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1515   }
1516   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1517   return c_result;
1518 }
1519
1520 SwigDirector_CpuModel::~SwigDirector_CpuModel() {
1521   swig_disconnect_director_self("swigDirectorDisconnect");
1522 }
1523
1524
1525 Cpu *SwigDirector_CpuModel::createResource(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) {
1526   Cpu *c_result = 0 ;
1527   jlong jresult = 0 ;
1528   JNIEnvWrapper swigjnienv(this) ;
1529   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1530   jobject swigjobj = (jobject) NULL ;
1531   jstring jname = 0 ;
1532   jdoubleArray jpower_peak  ;
1533   jint jpstate  ;
1534   jdouble jpower_scale  ;
1535   jlong jpower_trace = 0 ;
1536   jint jcore  ;
1537   jint jstate_initial  ;
1538   jlong jstate_trace = 0 ;
1539   jlong jcpu_properties = 0 ;
1540
1541   if (!swig_override[7]) {
1542     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method CpuModel::createResource.");
1543     return c_result;
1544   }
1545   swigjobj = swig_get_self(jenv);
1546   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1547     jname = 0;
1548     if (name) {
1549       jname = jenv->NewStringUTF((const char *)name);
1550       if (!jname) return c_result;
1551     }
1552
1553     long l = xbt_dynar_length(power_peak);
1554     jpower_peak = jenv->NewDoubleArray(l);
1555     double *lout = (double *)xbt_dynar_to_array(power_peak);
1556     jenv->SetDoubleArrayRegion(jpower_peak, 0, l, (const jdouble*)lout);
1557     free(lout);
1558
1559     jpstate = (jint) pstate;
1560     jpower_scale = (jdouble) power_scale;
1561     *((tmgr_trace **)&jpower_trace) = (tmgr_trace *) power_trace;
1562     jcore = (jint) core;
1563     jstate_initial = (jint) state_initial;
1564     *((tmgr_trace **)&jstate_trace) = (tmgr_trace *) state_trace;
1565     *((s_xbt_dict **)&jcpu_properties) = (s_xbt_dict *) cpu_properties;
1566     jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_SurfJNI, Swig::director_methids[16], swigjobj, jname, jpower_peak, jpstate, jpower_scale, jpower_trace, jcore, jstate_initial, jstate_trace, jcpu_properties);
1567     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1568     c_result = *(Cpu **)&jresult;
1569   } else {
1570     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1571   }
1572   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1573   return c_result;
1574 }
1575
1576 void SwigDirector_CpuModel::addTraces() {
1577   JNIEnvWrapper swigjnienv(this) ;
1578   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1579   jobject swigjobj = (jobject) NULL ;
1580
1581   if (!swig_override[8]) {
1582     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method CpuModel::addTraces.");
1583     return;
1584   }
1585   swigjobj = swig_get_self(jenv);
1586   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1587     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[17], swigjobj);
1588     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1589   } else {
1590     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1591   }
1592   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1593 }
1594
1595 void SwigDirector_CpuModel::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
1596   static struct {
1597     const char *mname;
1598     const char *mdesc;
1599     jmethodID base_methid;
1600   } methods[] = {
1601     {
1602       "shareResources", "(D)D", NULL
1603     },
1604     {
1605       "shareResourcesLazy", "(D)D", NULL
1606     },
1607     {
1608       "shareResourcesFull", "(D)D", NULL
1609     },
1610     {
1611       "updateActionsState", "(DD)V", NULL
1612     },
1613     {
1614       "updateActionsStateLazy", "(DD)V", NULL
1615     },
1616     {
1617       "updateActionsStateFull", "(DD)V", NULL
1618     },
1619     {
1620       "getRunningActionSet", "()Lorg/simgrid/surf/ActionList;", NULL
1621     },
1622     {
1623       "createResource", "(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       "addTraces", "()V", NULL
1627     }
1628   };
1629
1630   static jclass baseclass = 0 ;
1631
1632   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
1633     if (!baseclass) {
1634       baseclass = jenv->FindClass("org/simgrid/surf/CpuModel");
1635       if (!baseclass) return;
1636       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
1637     }
1638     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
1639     for (int i = 0; i < 9; ++i) {
1640       if (!methods[i].base_methid) {
1641         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
1642         if (!methods[i].base_methid) return;
1643       }
1644       swig_override[i] = false;
1645       if (derived) {
1646         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
1647         swig_override[i] = (methid != methods[i].base_methid);
1648         jenv->ExceptionClear();
1649       }
1650     }
1651   }
1652 }
1653
1654
1655 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) {
1656 }
1657
1658 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) {
1659 }
1660
1661 bool SwigDirector_Cpu::isUsed() {
1662   bool c_result = SwigValueInit< bool >() ;
1663   jboolean jresult = 0 ;
1664   JNIEnvWrapper swigjnienv(this) ;
1665   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1666   jobject swigjobj = (jobject) NULL ;
1667
1668   if (!swig_override[0]) {
1669     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::isUsed.");
1670     return c_result;
1671   }
1672   swigjobj = swig_get_self(jenv);
1673   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1674     jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_SurfJNI, Swig::director_methids[18], swigjobj);
1675     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1676     c_result = jresult ? true : false;
1677   } else {
1678     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1679   }
1680   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1681   return c_result;
1682 }
1683
1684 e_surf_resource_state_t SwigDirector_Cpu::getState() {
1685   e_surf_resource_state_t c_result = SwigValueInit< e_surf_resource_state_t >() ;
1686   jint jresult = 0 ;
1687   JNIEnvWrapper swigjnienv(this) ;
1688   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1689   jobject swigjobj = (jobject) NULL ;
1690
1691   if (!swig_override[1]) {
1692     return Resource::getState();
1693   }
1694   swigjobj = swig_get_self(jenv);
1695   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1696     jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SurfJNI, Swig::director_methids[19], swigjobj);
1697     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1698     c_result = (e_surf_resource_state_t)jresult;
1699   } else {
1700     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1701   }
1702   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1703   return c_result;
1704 }
1705
1706 void SwigDirector_Cpu::updateState(tmgr_trace_event *event_type, double value, double date) {
1707   JNIEnvWrapper swigjnienv(this) ;
1708   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1709   jobject swigjobj = (jobject) NULL ;
1710   jlong jevent_type = 0 ;
1711   jdouble jvalue  ;
1712   jdouble jdate  ;
1713
1714   if (!swig_override[2]) {
1715     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::updateState.");
1716     return;
1717   }
1718   swigjobj = swig_get_self(jenv);
1719   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1720     *((tmgr_trace_event **)&jevent_type) = (tmgr_trace_event *) event_type;
1721     jvalue = (jdouble) value;
1722     jdate = (jdouble) date;
1723     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[20], swigjobj, jevent_type, jvalue, jdate);
1724     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1725   } else {
1726     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1727   }
1728   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1729 }
1730
1731 SwigDirector_Cpu::~SwigDirector_Cpu() {
1732   swig_disconnect_director_self("swigDirectorDisconnect");
1733 }
1734
1735
1736 double SwigDirector_Cpu::getCurrentPowerPeak() {
1737   double c_result = SwigValueInit< double >() ;
1738   jdouble jresult = 0 ;
1739   JNIEnvWrapper swigjnienv(this) ;
1740   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1741   jobject swigjobj = (jobject) NULL ;
1742
1743   if (!swig_override[3]) {
1744     return Cpu::getCurrentPowerPeak();
1745   }
1746   swigjobj = swig_get_self(jenv);
1747   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1748     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[21], swigjobj);
1749     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1750     c_result = (double)jresult;
1751   } else {
1752     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1753   }
1754   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1755   return c_result;
1756 }
1757
1758 CpuAction *SwigDirector_Cpu::execute(double size) {
1759   CpuAction *c_result = 0 ;
1760   jlong jresult = 0 ;
1761   JNIEnvWrapper swigjnienv(this) ;
1762   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1763   jobject swigjobj = (jobject) NULL ;
1764   jdouble jsize  ;
1765
1766   if (!swig_override[4]) {
1767     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::execute.");
1768     return c_result;
1769   }
1770   swigjobj = swig_get_self(jenv);
1771   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1772     jsize = (jdouble) size;
1773     jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_SurfJNI, Swig::director_methids[22], swigjobj, jsize);
1774     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1775     c_result = *(CpuAction **)&jresult;
1776   } else {
1777     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1778   }
1779   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1780   return c_result;
1781 }
1782
1783 CpuAction *SwigDirector_Cpu::sleep(double duration) {
1784   CpuAction *c_result = 0 ;
1785   jlong jresult = 0 ;
1786   JNIEnvWrapper swigjnienv(this) ;
1787   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1788   jobject swigjobj = (jobject) NULL ;
1789   jdouble jduration  ;
1790
1791   if (!swig_override[5]) {
1792     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::sleep.");
1793     return c_result;
1794   }
1795   swigjobj = swig_get_self(jenv);
1796   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1797     jduration = (jdouble) duration;
1798     jresult = (jlong) jenv->CallStaticLongMethod(Swig::jclass_SurfJNI, Swig::director_methids[23], swigjobj, jduration);
1799     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1800     c_result = *(CpuAction **)&jresult;
1801   } else {
1802     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1803   }
1804   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1805   return c_result;
1806 }
1807
1808 int SwigDirector_Cpu::getCore() {
1809   int c_result = SwigValueInit< int >() ;
1810   jint jresult = 0 ;
1811   JNIEnvWrapper swigjnienv(this) ;
1812   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1813   jobject swigjobj = (jobject) NULL ;
1814
1815   if (!swig_override[6]) {
1816     return Cpu::getCore();
1817   }
1818   swigjobj = swig_get_self(jenv);
1819   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1820     jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SurfJNI, Swig::director_methids[24], swigjobj);
1821     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1822     c_result = (int)jresult;
1823   } else {
1824     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1825   }
1826   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1827   return c_result;
1828 }
1829
1830 double SwigDirector_Cpu::getSpeed(double load) {
1831   double c_result = SwigValueInit< double >() ;
1832   jdouble jresult = 0 ;
1833   JNIEnvWrapper swigjnienv(this) ;
1834   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1835   jobject swigjobj = (jobject) NULL ;
1836   jdouble jload  ;
1837
1838   if (!swig_override[7]) {
1839     return Cpu::getSpeed(load);
1840   }
1841   swigjobj = swig_get_self(jenv);
1842   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1843     jload = (jdouble) load;
1844     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[25], swigjobj, jload);
1845     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1846     c_result = (double)jresult;
1847   } else {
1848     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1849   }
1850   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1851   return c_result;
1852 }
1853
1854 double SwigDirector_Cpu::getAvailableSpeed() {
1855   double c_result = SwigValueInit< double >() ;
1856   jdouble jresult = 0 ;
1857   JNIEnvWrapper swigjnienv(this) ;
1858   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1859   jobject swigjobj = (jobject) NULL ;
1860
1861   if (!swig_override[8]) {
1862     return Cpu::getAvailableSpeed();
1863   }
1864   swigjobj = swig_get_self(jenv);
1865   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1866     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[26], swigjobj);
1867     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1868     c_result = (double)jresult;
1869   } else {
1870     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1871   }
1872   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1873   return c_result;
1874 }
1875
1876 double SwigDirector_Cpu::getPowerPeakAt(int pstate_index) {
1877   double c_result = SwigValueInit< double >() ;
1878   jdouble jresult = 0 ;
1879   JNIEnvWrapper swigjnienv(this) ;
1880   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1881   jobject swigjobj = (jobject) NULL ;
1882   jint jpstate_index  ;
1883
1884   if (!swig_override[9]) {
1885     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::getPowerPeakAt.");
1886     return c_result;
1887   }
1888   swigjobj = swig_get_self(jenv);
1889   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1890     jpstate_index = (jint) pstate_index;
1891     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[27], swigjobj, jpstate_index);
1892     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1893     c_result = (double)jresult;
1894   } else {
1895     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1896   }
1897   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1898   return c_result;
1899 }
1900
1901 int SwigDirector_Cpu::getNbPstates() {
1902   int c_result = SwigValueInit< int >() ;
1903   jint jresult = 0 ;
1904   JNIEnvWrapper swigjnienv(this) ;
1905   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1906   jobject swigjobj = (jobject) NULL ;
1907
1908   if (!swig_override[10]) {
1909     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::getNbPstates.");
1910     return c_result;
1911   }
1912   swigjobj = swig_get_self(jenv);
1913   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1914     jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_SurfJNI, Swig::director_methids[28], swigjobj);
1915     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
1916     c_result = (int)jresult;
1917   } else {
1918     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1919   }
1920   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1921   return c_result;
1922 }
1923
1924 void SwigDirector_Cpu::setPowerPeakAt(int pstate_index) {
1925   JNIEnvWrapper swigjnienv(this) ;
1926   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
1927   jobject swigjobj = (jobject) NULL ;
1928   jint jpstate_index  ;
1929
1930   if (!swig_override[11]) {
1931     SWIG_JavaThrowException(JNIEnvWrapper(this).getJNIEnv(), SWIG_JavaDirectorPureVirtual, "Attempted to invoke pure virtual method Cpu::setPowerPeakAt.");
1932     return;
1933   }
1934   swigjobj = swig_get_self(jenv);
1935   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
1936     jpstate_index = (jint) pstate_index;
1937     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[29], swigjobj, jpstate_index);
1938     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
1939   } else {
1940     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
1941   }
1942   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
1943 }
1944
1945 void SwigDirector_Cpu::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
1946   static struct {
1947     const char *mname;
1948     const char *mdesc;
1949     jmethodID base_methid;
1950   } methods[] = {
1951     {
1952       "isUsed", "()Z", NULL
1953     },
1954     {
1955       "getState", "()Lorg/simgrid/surf/ResourceState;", NULL
1956     },
1957     {
1958       "updateState", "(Lorg/simgrid/surf/TmgrTraceEvent;DD)V", NULL
1959     },
1960     {
1961       "getCurrentPowerPeak", "()D", NULL
1962     },
1963     {
1964       "execute", "(D)Lorg/simgrid/surf/CpuAction;", NULL
1965     },
1966     {
1967       "sleep", "(D)Lorg/simgrid/surf/CpuAction;", NULL
1968     },
1969     {
1970       "getCore", "()I", NULL
1971     },
1972     {
1973       "getSpeed", "(D)D", NULL
1974     },
1975     {
1976       "getAvailableSpeed", "()D", NULL
1977     },
1978     {
1979       "getPowerPeakAt", "(I)D", NULL
1980     },
1981     {
1982       "getNbPstates", "()I", NULL
1983     },
1984     {
1985       "setPowerPeakAt", "(I)V", NULL
1986     }
1987   };
1988
1989   static jclass baseclass = 0 ;
1990
1991   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
1992     if (!baseclass) {
1993       baseclass = jenv->FindClass("org/simgrid/surf/Cpu");
1994       if (!baseclass) return;
1995       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
1996     }
1997     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
1998     for (int i = 0; i < 12; ++i) {
1999       if (!methods[i].base_methid) {
2000         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
2001         if (!methods[i].base_methid) return;
2002       }
2003       swig_override[i] = false;
2004       if (derived) {
2005         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
2006         swig_override[i] = (methid != methods[i].base_methid);
2007         jenv->ExceptionClear();
2008       }
2009     }
2010   }
2011 }
2012
2013
2014 SwigDirector_CpuAction::SwigDirector_CpuAction(JNIEnv *jenv, Model *model, double cost, bool failed) : CpuAction(model, cost, failed), Swig::Director(jenv) {
2015 }
2016
2017 SwigDirector_CpuAction::~SwigDirector_CpuAction() {
2018   swig_disconnect_director_self("swigDirectorDisconnect");
2019 }
2020
2021
2022 double SwigDirector_CpuAction::getRemains() {
2023   double c_result = SwigValueInit< double >() ;
2024   jdouble jresult = 0 ;
2025   JNIEnvWrapper swigjnienv(this) ;
2026   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
2027   jobject swigjobj = (jobject) NULL ;
2028
2029   if (!swig_override[0]) {
2030     return Action::getRemains();
2031   }
2032   swigjobj = swig_get_self(jenv);
2033   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
2034     jresult = (jdouble) jenv->CallStaticDoubleMethod(Swig::jclass_SurfJNI, Swig::director_methids[30], swigjobj);
2035     if (jenv->ExceptionCheck() == JNI_TRUE) return c_result;
2036     c_result = (double)jresult;
2037   } else {
2038     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
2039   }
2040   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
2041   return c_result;
2042 }
2043
2044 void SwigDirector_CpuAction::setPriority(double priority) {
2045   JNIEnvWrapper swigjnienv(this) ;
2046   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
2047   jobject swigjobj = (jobject) NULL ;
2048   jdouble jpriority  ;
2049
2050   if (!swig_override[1]) {
2051     Action::setPriority(priority);
2052     return;
2053   }
2054   swigjobj = swig_get_self(jenv);
2055   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
2056     jpriority = (jdouble) priority;
2057     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[31], swigjobj, jpriority);
2058     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
2059   } else {
2060     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
2061   }
2062   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
2063 }
2064
2065 void SwigDirector_CpuAction::setState(e_surf_action_state_t state) {
2066   JNIEnvWrapper swigjnienv(this) ;
2067   JNIEnv * jenv = swigjnienv.getJNIEnv() ;
2068   jobject swigjobj = (jobject) NULL ;
2069   jint jstate  ;
2070
2071   if (!swig_override[2]) {
2072     Action::setState(state);
2073     return;
2074   }
2075   swigjobj = swig_get_self(jenv);
2076   if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
2077     jstate = (jint) state;
2078     jenv->CallStaticVoidMethod(Swig::jclass_SurfJNI, Swig::director_methids[32], swigjobj, jstate);
2079     if (jenv->ExceptionCheck() == JNI_TRUE) return ;
2080   } else {
2081     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object");
2082   }
2083   if (swigjobj) jenv->DeleteLocalRef(swigjobj);
2084 }
2085
2086 void SwigDirector_CpuAction::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
2087   static struct {
2088     const char *mname;
2089     const char *mdesc;
2090     jmethodID base_methid;
2091   } methods[] = {
2092     {
2093       "getRemains", "()D", NULL
2094     },
2095     {
2096       "setPriority", "(D)V", NULL
2097     },
2098     {
2099       "setState", "(Lorg/simgrid/surf/ActionState;)V", NULL
2100     }
2101   };
2102
2103   static jclass baseclass = 0 ;
2104
2105   if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
2106     if (!baseclass) {
2107       baseclass = jenv->FindClass("org/simgrid/surf/CpuAction");
2108       if (!baseclass) return;
2109       baseclass = (jclass) jenv->NewGlobalRef(baseclass);
2110     }
2111     bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
2112     for (int i = 0; i < 3; ++i) {
2113       if (!methods[i].base_methid) {
2114         methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
2115         if (!methods[i].base_methid) return;
2116       }
2117       swig_override[i] = false;
2118       if (derived) {
2119         jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
2120         swig_override[i] = (methid != methods[i].base_methid);
2121         jenv->ExceptionClear();
2122       }
2123     }
2124   }
2125 }
2126
2127
2128
2129 #ifdef __cplusplus
2130 extern "C" {
2131 #endif
2132
2133
2134 #ifdef __cplusplus
2135 extern "C" {
2136 #endif
2137
2138 JNIEXPORT jobject JNICALL Java_org_simgrid_surf_SurfJNI_getAction(JNIEnv *env, jclass cls, jlong jarg1) {
2139   Action * action = (Action *)jarg1;
2140   jobject res;
2141   CpuAction *cpu_action = dynamic_cast<CpuAction*>(action);
2142   if (cpu_action) {
2143     SwigDirector_CpuAction *dir_cpu_action = dynamic_cast<SwigDirector_CpuAction*>(cpu_action);
2144     if (dir_cpu_action) {
2145       res = dir_cpu_action->swig_get_self(env);\
2146     } else {
2147       jclass clss = env->FindClass("org/simgrid/surf/CpuAction");\
2148       jmethodID constru = env->GetMethodID(clss, "<init>", "()V");\
2149       res = env->NewObject(clss, constru);\
2150       res = env->NewGlobalRef(res);\
2151     }
2152   } else {
2153     jclass clss = env->FindClass("org/simgrid/surf/Action");\
2154     jmethodID constru = env->GetMethodID(clss, "<init>", "()V");\
2155     res = env->NewObject(clss, constru);\
2156     res = env->NewGlobalRef(res);\
2157   }
2158   return res;
2159 }
2160
2161 #define GETDIRECTOR(NAME) \
2162 JNIEXPORT jobject JNICALL Java_org_simgrid_surf_SurfJNI_get## NAME ## Director(JNIEnv *env, jclass cls, jlong jarg1)\
2163 {\
2164   NAME * arg1 = (NAME*)jarg1;\
2165   SwigDirector_ ##NAME *director = dynamic_cast<SwigDirector_ ##NAME *>(arg1);\
2166   jobject res;\
2167   if (director) {\
2168     res = director->swig_get_self(env);\
2169   } else {\
2170     jclass clss = env->FindClass("org/simgrid/surf/NAME");\
2171     jmethodID constru = env->GetMethodID(clss, "<init>", "()V");\
2172     res = env->NewObject(clss, constru);\
2173     res = env->NewGlobalRef(res);\
2174   }\
2175   return res;\
2176 }
2177
2178 GETDIRECTOR(CpuModel)
2179 GETDIRECTOR(Cpu)
2180 GETDIRECTOR(CpuAction)
2181
2182 #ifdef __cplusplus
2183 }
2184 #endif
2185
2186
2187 SWIGEXPORT jlongArray JNICALL Java_org_simgrid_surf_SurfJNI_ActionList_1getArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2188   jlongArray jresult = 0 ;
2189   ActionList *arg1 = (ActionList *) 0 ;
2190   ActionArrayPtr result;
2191
2192   (void)jenv;
2193   (void)jcls;
2194   (void)jarg1_;
2195   arg1 = *(ActionList **)&jarg1;
2196   result = (ActionArrayPtr)ActionList_getArray(arg1);
2197   {
2198     long l = 0;
2199     for(ActionList::iterator it(result->begin()), itend(result->end()); it != itend ; ++it) {
2200       l++;
2201     }
2202     jresult = jenv->NewLongArray(l);
2203     jlong *elts = jenv->GetLongArrayElements(jresult, NULL);
2204     l = 0;
2205     for(ActionList::iterator it(result->begin()), itend(result->end()); it != itend ; ++it) {
2206       elts[l++] = (jlong)static_cast<ActionPtr>(&*it);
2207     }
2208     jenv->ReleaseLongArrayElements(jresult, elts, 0);
2209   }
2210   return jresult;
2211 }
2212
2213
2214 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1ActionList(JNIEnv *jenv, jclass jcls) {
2215   jlong jresult = 0 ;
2216   ActionList *result = 0 ;
2217
2218   (void)jenv;
2219   (void)jcls;
2220   result = (ActionList *)new ActionList();
2221   *(ActionList **)&jresult = result;
2222   return jresult;
2223 }
2224
2225
2226 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1ActionList(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2227   ActionList *arg1 = (ActionList *) 0 ;
2228
2229   (void)jenv;
2230   (void)jcls;
2231   arg1 = *(ActionList **)&jarg1;
2232   delete arg1;
2233 }
2234
2235
2236 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_getClock(JNIEnv *jenv, jclass jcls) {
2237   jdouble jresult = 0 ;
2238   double result;
2239
2240   (void)jenv;
2241   (void)jcls;
2242   result = (double)getClock();
2243   jresult = (jdouble)result;
2244   return jresult;
2245 }
2246
2247
2248 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_clean(JNIEnv *jenv, jclass jcls) {
2249   (void)jenv;
2250   (void)jcls;
2251   clean();
2252 }
2253
2254
2255 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_getCpuModel(JNIEnv *jenv, jclass jcls) {
2256   jlong jresult = 0 ;
2257   CpuModel *result = 0 ;
2258
2259   (void)jenv;
2260   (void)jcls;
2261   result = (CpuModel *)getCpuModel();
2262   *(CpuModel **)&jresult = result;
2263   return jresult;
2264 }
2265
2266
2267 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_setCpuModel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2268   CpuModel *arg1 = (CpuModel *) 0 ;
2269
2270   (void)jenv;
2271   (void)jcls;
2272   (void)jarg1_;
2273   arg1 = *(CpuModel **)&jarg1;
2274   setCpuModel(arg1);
2275 }
2276
2277
2278 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_setCpu(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
2279   char *arg1 = (char *) 0 ;
2280   Cpu *arg2 = (Cpu *) 0 ;
2281
2282   (void)jenv;
2283   (void)jcls;
2284   (void)jarg2_;
2285   arg1 = 0;
2286   if (jarg1) {
2287     arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
2288     if (!arg1) return ;
2289   }
2290   arg2 = *(Cpu **)&jarg2;
2291   setCpu(arg1,arg2);
2292   {
2293
2294   }
2295 }
2296
2297
2298 SWIGEXPORT jlongArray JNICALL Java_org_simgrid_surf_SurfJNI_getRoute(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
2299   jlongArray jresult = 0 ;
2300   char *arg1 = (char *) 0 ;
2301   char *arg2 = (char *) 0 ;
2302   NetworkLinkDynar result;
2303
2304   (void)jenv;
2305   (void)jcls;
2306   arg1 = 0;
2307   if (jarg1) {
2308     arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
2309     if (!arg1) return 0;
2310   }
2311   arg2 = 0;
2312   if (jarg2) {
2313     arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
2314     if (!arg2) return 0;
2315   }
2316   result = getRoute(arg1,arg2);
2317   {
2318     long l = xbt_dynar_length(result);
2319     jresult = jenv->NewLongArray(l);
2320     unsigned i;
2321     NetworkLink *link;
2322     jlong *elts = jenv->GetLongArrayElements(jresult, NULL);
2323     xbt_dynar_foreach(result, i, link) {
2324       elts[i] = (jlong)link;
2325     }
2326     jenv->ReleaseLongArrayElements(jresult, elts, 0);
2327     xbt_dynar_free(&result);
2328   }
2329   if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
2330   if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
2331   return jresult;
2332 }
2333
2334
2335 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1Plugin(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2336   Plugin *arg1 = (Plugin *) 0 ;
2337
2338   (void)jenv;
2339   (void)jcls;
2340   arg1 = *(Plugin **)&jarg1;
2341   delete arg1;
2342 }
2343
2344
2345 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateCpuCreatedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2346   Plugin *arg1 = (Plugin *) 0 ;
2347
2348   (void)jenv;
2349   (void)jcls;
2350   (void)jarg1_;
2351   arg1 = *(Plugin **)&jarg1;
2352   (arg1)->activateCpuCreatedCallback();
2353 }
2354
2355
2356 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuCreatedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2357   Plugin *arg1 = (Plugin *) 0 ;
2358   Cpu *arg2 = (Cpu *) 0 ;
2359
2360   (void)jenv;
2361   (void)jcls;
2362   (void)jarg1_;
2363   (void)jarg2_;
2364   arg1 = *(Plugin **)&jarg1;
2365   arg2 = *(Cpu **)&jarg2;
2366   (arg1)->cpuCreatedCallback(arg2);
2367 }
2368
2369
2370 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuCreatedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2371   Plugin *arg1 = (Plugin *) 0 ;
2372   Cpu *arg2 = (Cpu *) 0 ;
2373
2374   (void)jenv;
2375   (void)jcls;
2376   (void)jarg1_;
2377   (void)jarg2_;
2378   arg1 = *(Plugin **)&jarg1;
2379   arg2 = *(Cpu **)&jarg2;
2380   (arg1)->Plugin::cpuCreatedCallback(arg2);
2381 }
2382
2383
2384 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateCpuDestructedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2385   Plugin *arg1 = (Plugin *) 0 ;
2386
2387   (void)jenv;
2388   (void)jcls;
2389   (void)jarg1_;
2390   arg1 = *(Plugin **)&jarg1;
2391   (arg1)->activateCpuDestructedCallback();
2392 }
2393
2394
2395 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuDestructedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2396   Plugin *arg1 = (Plugin *) 0 ;
2397   Cpu *arg2 = (Cpu *) 0 ;
2398
2399   (void)jenv;
2400   (void)jcls;
2401   (void)jarg1_;
2402   (void)jarg2_;
2403   arg1 = *(Plugin **)&jarg1;
2404   arg2 = *(Cpu **)&jarg2;
2405   (arg1)->cpuDestructedCallback(arg2);
2406 }
2407
2408
2409 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1cpuDestructedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2410   Plugin *arg1 = (Plugin *) 0 ;
2411   Cpu *arg2 = (Cpu *) 0 ;
2412
2413   (void)jenv;
2414   (void)jcls;
2415   (void)jarg1_;
2416   (void)jarg2_;
2417   arg1 = *(Plugin **)&jarg1;
2418   arg2 = *(Cpu **)&jarg2;
2419   (arg1)->Plugin::cpuDestructedCallback(arg2);
2420 }
2421
2422
2423 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateCpuStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2424   Plugin *arg1 = (Plugin *) 0 ;
2425
2426   (void)jenv;
2427   (void)jcls;
2428   (void)jarg1_;
2429   arg1 = *(Plugin **)&jarg1;
2430   (arg1)->activateCpuStateChangedCallback();
2431 }
2432
2433
2434 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) {
2435   Plugin *arg1 = (Plugin *) 0 ;
2436   Cpu *arg2 = (Cpu *) 0 ;
2437   e_surf_resource_state_t arg3 ;
2438   e_surf_resource_state_t arg4 ;
2439
2440   (void)jenv;
2441   (void)jcls;
2442   (void)jarg1_;
2443   (void)jarg2_;
2444   arg1 = *(Plugin **)&jarg1;
2445   arg2 = *(Cpu **)&jarg2;
2446   arg3 = (e_surf_resource_state_t)jarg3;
2447   arg4 = (e_surf_resource_state_t)jarg4;
2448   (arg1)->cpuStateChangedCallback(arg2,arg3,arg4);
2449 }
2450
2451
2452 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) {
2453   Plugin *arg1 = (Plugin *) 0 ;
2454   Cpu *arg2 = (Cpu *) 0 ;
2455   e_surf_resource_state_t arg3 ;
2456   e_surf_resource_state_t arg4 ;
2457
2458   (void)jenv;
2459   (void)jcls;
2460   (void)jarg1_;
2461   (void)jarg2_;
2462   arg1 = *(Plugin **)&jarg1;
2463   arg2 = *(Cpu **)&jarg2;
2464   arg3 = (e_surf_resource_state_t)jarg3;
2465   arg4 = (e_surf_resource_state_t)jarg4;
2466   (arg1)->Plugin::cpuStateChangedCallback(arg2,arg3,arg4);
2467 }
2468
2469
2470 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateCpuActionStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2471   Plugin *arg1 = (Plugin *) 0 ;
2472
2473   (void)jenv;
2474   (void)jcls;
2475   (void)jarg1_;
2476   arg1 = *(Plugin **)&jarg1;
2477   (arg1)->activateCpuActionStateChangedCallback();
2478 }
2479
2480
2481 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) {
2482   Plugin *arg1 = (Plugin *) 0 ;
2483   CpuAction *arg2 = (CpuAction *) 0 ;
2484   e_surf_action_state_t arg3 ;
2485   e_surf_action_state_t arg4 ;
2486
2487   (void)jenv;
2488   (void)jcls;
2489   (void)jarg1_;
2490   (void)jarg2_;
2491   arg1 = *(Plugin **)&jarg1;
2492   arg2 = *(CpuAction **)&jarg2;
2493   arg3 = (e_surf_action_state_t)jarg3;
2494   arg4 = (e_surf_action_state_t)jarg4;
2495   (arg1)->cpuActionStateChangedCallback(arg2,arg3,arg4);
2496 }
2497
2498
2499 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) {
2500   Plugin *arg1 = (Plugin *) 0 ;
2501   CpuAction *arg2 = (CpuAction *) 0 ;
2502   e_surf_action_state_t arg3 ;
2503   e_surf_action_state_t arg4 ;
2504
2505   (void)jenv;
2506   (void)jcls;
2507   (void)jarg1_;
2508   (void)jarg2_;
2509   arg1 = *(Plugin **)&jarg1;
2510   arg2 = *(CpuAction **)&jarg2;
2511   arg3 = (e_surf_action_state_t)jarg3;
2512   arg4 = (e_surf_action_state_t)jarg4;
2513   (arg1)->Plugin::cpuActionStateChangedCallback(arg2,arg3,arg4);
2514 }
2515
2516
2517 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateNetworkLinkCreatedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2518   Plugin *arg1 = (Plugin *) 0 ;
2519
2520   (void)jenv;
2521   (void)jcls;
2522   (void)jarg1_;
2523   arg1 = *(Plugin **)&jarg1;
2524   (arg1)->activateNetworkLinkCreatedCallback();
2525 }
2526
2527
2528 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkLinkCreatedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2529   Plugin *arg1 = (Plugin *) 0 ;
2530   NetworkLink *arg2 = (NetworkLink *) 0 ;
2531
2532   (void)jenv;
2533   (void)jcls;
2534   (void)jarg1_;
2535   (void)jarg2_;
2536   arg1 = *(Plugin **)&jarg1;
2537   arg2 = *(NetworkLink **)&jarg2;
2538   (arg1)->networkLinkCreatedCallback(arg2);
2539 }
2540
2541
2542 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkLinkCreatedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2543   Plugin *arg1 = (Plugin *) 0 ;
2544   NetworkLink *arg2 = (NetworkLink *) 0 ;
2545
2546   (void)jenv;
2547   (void)jcls;
2548   (void)jarg1_;
2549   (void)jarg2_;
2550   arg1 = *(Plugin **)&jarg1;
2551   arg2 = *(NetworkLink **)&jarg2;
2552   (arg1)->Plugin::networkLinkCreatedCallback(arg2);
2553 }
2554
2555
2556 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateNetworkLinkDestructedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2557   Plugin *arg1 = (Plugin *) 0 ;
2558
2559   (void)jenv;
2560   (void)jcls;
2561   (void)jarg1_;
2562   arg1 = *(Plugin **)&jarg1;
2563   (arg1)->activateNetworkLinkDestructedCallback();
2564 }
2565
2566
2567 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkLinkDestructedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2568   Plugin *arg1 = (Plugin *) 0 ;
2569   NetworkLink *arg2 = (NetworkLink *) 0 ;
2570
2571   (void)jenv;
2572   (void)jcls;
2573   (void)jarg1_;
2574   (void)jarg2_;
2575   arg1 = *(Plugin **)&jarg1;
2576   arg2 = *(NetworkLink **)&jarg2;
2577   (arg1)->networkLinkDestructedCallback(arg2);
2578 }
2579
2580
2581 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1networkLinkDestructedCallbackSwigExplicitPlugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
2582   Plugin *arg1 = (Plugin *) 0 ;
2583   NetworkLink *arg2 = (NetworkLink *) 0 ;
2584
2585   (void)jenv;
2586   (void)jcls;
2587   (void)jarg1_;
2588   (void)jarg2_;
2589   arg1 = *(Plugin **)&jarg1;
2590   arg2 = *(NetworkLink **)&jarg2;
2591   (arg1)->Plugin::networkLinkDestructedCallback(arg2);
2592 }
2593
2594
2595 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateNetworkLinkStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2596   Plugin *arg1 = (Plugin *) 0 ;
2597
2598   (void)jenv;
2599   (void)jcls;
2600   (void)jarg1_;
2601   arg1 = *(Plugin **)&jarg1;
2602   (arg1)->activateNetworkLinkStateChangedCallback();
2603 }
2604
2605
2606 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) {
2607   Plugin *arg1 = (Plugin *) 0 ;
2608   NetworkLink *arg2 = (NetworkLink *) 0 ;
2609   e_surf_resource_state_t arg3 ;
2610   e_surf_resource_state_t arg4 ;
2611
2612   (void)jenv;
2613   (void)jcls;
2614   (void)jarg1_;
2615   (void)jarg2_;
2616   arg1 = *(Plugin **)&jarg1;
2617   arg2 = *(NetworkLink **)&jarg2;
2618   arg3 = (e_surf_resource_state_t)jarg3;
2619   arg4 = (e_surf_resource_state_t)jarg4;
2620   (arg1)->networkLinkStateChangedCallback(arg2,arg3,arg4);
2621 }
2622
2623
2624 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) {
2625   Plugin *arg1 = (Plugin *) 0 ;
2626   NetworkLink *arg2 = (NetworkLink *) 0 ;
2627   e_surf_resource_state_t arg3 ;
2628   e_surf_resource_state_t arg4 ;
2629
2630   (void)jenv;
2631   (void)jcls;
2632   (void)jarg1_;
2633   (void)jarg2_;
2634   arg1 = *(Plugin **)&jarg1;
2635   arg2 = *(NetworkLink **)&jarg2;
2636   arg3 = (e_surf_resource_state_t)jarg3;
2637   arg4 = (e_surf_resource_state_t)jarg4;
2638   (arg1)->Plugin::networkLinkStateChangedCallback(arg2,arg3,arg4);
2639 }
2640
2641
2642 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateNetworkActionStateChangedCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2643   Plugin *arg1 = (Plugin *) 0 ;
2644
2645   (void)jenv;
2646   (void)jcls;
2647   (void)jarg1_;
2648   arg1 = *(Plugin **)&jarg1;
2649   (arg1)->activateNetworkActionStateChangedCallback();
2650 }
2651
2652
2653 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) {
2654   Plugin *arg1 = (Plugin *) 0 ;
2655   NetworkAction *arg2 = (NetworkAction *) 0 ;
2656   e_surf_action_state_t arg3 ;
2657   e_surf_action_state_t arg4 ;
2658
2659   (void)jenv;
2660   (void)jcls;
2661   (void)jarg1_;
2662   (void)jarg2_;
2663   arg1 = *(Plugin **)&jarg1;
2664   arg2 = *(NetworkAction **)&jarg2;
2665   arg3 = (e_surf_action_state_t)jarg3;
2666   arg4 = (e_surf_action_state_t)jarg4;
2667   (arg1)->networkActionStateChangedCallback(arg2,arg3,arg4);
2668 }
2669
2670
2671 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) {
2672   Plugin *arg1 = (Plugin *) 0 ;
2673   NetworkAction *arg2 = (NetworkAction *) 0 ;
2674   e_surf_action_state_t arg3 ;
2675   e_surf_action_state_t arg4 ;
2676
2677   (void)jenv;
2678   (void)jcls;
2679   (void)jarg1_;
2680   (void)jarg2_;
2681   arg1 = *(Plugin **)&jarg1;
2682   arg2 = *(NetworkAction **)&jarg2;
2683   arg3 = (e_surf_action_state_t)jarg3;
2684   arg4 = (e_surf_action_state_t)jarg4;
2685   (arg1)->Plugin::networkActionStateChangedCallback(arg2,arg3,arg4);
2686 }
2687
2688
2689 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1activateNetworkCommunicateCallback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2690   Plugin *arg1 = (Plugin *) 0 ;
2691
2692   (void)jenv;
2693   (void)jcls;
2694   (void)jarg1_;
2695   arg1 = *(Plugin **)&jarg1;
2696   (arg1)->activateNetworkCommunicateCallback();
2697 }
2698
2699
2700 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) {
2701   Plugin *arg1 = (Plugin *) 0 ;
2702   NetworkAction *arg2 = (NetworkAction *) 0 ;
2703   RoutingEdge *arg3 = (RoutingEdge *) 0 ;
2704   RoutingEdge *arg4 = (RoutingEdge *) 0 ;
2705   double arg5 ;
2706   double arg6 ;
2707
2708   (void)jenv;
2709   (void)jcls;
2710   (void)jarg1_;
2711   (void)jarg2_;
2712   (void)jarg3_;
2713   (void)jarg4_;
2714   arg1 = *(Plugin **)&jarg1;
2715   arg2 = *(NetworkAction **)&jarg2;
2716   arg3 = *(RoutingEdge **)&jarg3;
2717   arg4 = *(RoutingEdge **)&jarg4;
2718   arg5 = (double)jarg5;
2719   arg6 = (double)jarg6;
2720   (arg1)->networkCommunicateCallback(arg2,arg3,arg4,arg5,arg6);
2721 }
2722
2723
2724 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) {
2725   Plugin *arg1 = (Plugin *) 0 ;
2726   NetworkAction *arg2 = (NetworkAction *) 0 ;
2727   RoutingEdge *arg3 = (RoutingEdge *) 0 ;
2728   RoutingEdge *arg4 = (RoutingEdge *) 0 ;
2729   double arg5 ;
2730   double arg6 ;
2731
2732   (void)jenv;
2733   (void)jcls;
2734   (void)jarg1_;
2735   (void)jarg2_;
2736   (void)jarg3_;
2737   (void)jarg4_;
2738   arg1 = *(Plugin **)&jarg1;
2739   arg2 = *(NetworkAction **)&jarg2;
2740   arg3 = *(RoutingEdge **)&jarg3;
2741   arg4 = *(RoutingEdge **)&jarg4;
2742   arg5 = (double)jarg5;
2743   arg6 = (double)jarg6;
2744   (arg1)->Plugin::networkCommunicateCallback(arg2,arg3,arg4,arg5,arg6);
2745 }
2746
2747
2748 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1Plugin(JNIEnv *jenv, jclass jcls) {
2749   jlong jresult = 0 ;
2750   Plugin *result = 0 ;
2751
2752   (void)jenv;
2753   (void)jcls;
2754   result = (Plugin *)new SwigDirector_Plugin(jenv);
2755   *(Plugin **)&jresult = result;
2756   return jresult;
2757 }
2758
2759
2760 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) {
2761   Plugin *obj = *((Plugin **)&objarg);
2762   (void)jcls;
2763   SwigDirector_Plugin *director = dynamic_cast<SwigDirector_Plugin *>(obj);
2764   if (director) {
2765     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
2766   }
2767 }
2768
2769
2770 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Plugin_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
2771   Plugin *obj = *((Plugin **)&objarg);
2772   SwigDirector_Plugin *director = dynamic_cast<SwigDirector_Plugin *>(obj);
2773   (void)jcls;
2774   if (director) {
2775     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
2776   }
2777 }
2778
2779
2780 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1TmgrTrace(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2781   tmgr_trace *arg1 = (tmgr_trace *) 0 ;
2782
2783   (void)jenv;
2784   (void)jcls;
2785   arg1 = *(tmgr_trace **)&jarg1;
2786   delete arg1;
2787 }
2788
2789
2790 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_TmgrTraceEvent_1getIdx(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2791   jlong jresult = 0 ;
2792   tmgr_trace_event *arg1 = (tmgr_trace_event *) 0 ;
2793   unsigned int result;
2794
2795   (void)jenv;
2796   (void)jcls;
2797   (void)jarg1_;
2798   arg1 = *(tmgr_trace_event **)&jarg1;
2799   result = (unsigned int)tmgr_trace_event_getIdx(arg1);
2800   jresult = (jlong)result;
2801   return jresult;
2802 }
2803
2804
2805 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1TmgrTraceEvent(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2806   tmgr_trace_event *arg1 = (tmgr_trace_event *) 0 ;
2807
2808   (void)jenv;
2809   (void)jcls;
2810   arg1 = *(tmgr_trace_event **)&jarg1;
2811   delete arg1;
2812 }
2813
2814
2815 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1Model(JNIEnv *jenv, jclass jcls, jstring jarg1) {
2816   jlong jresult = 0 ;
2817   char *arg1 = (char *) 0 ;
2818   Model *result = 0 ;
2819
2820   (void)jenv;
2821   (void)jcls;
2822   arg1 = 0;
2823   if (jarg1) {
2824     arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
2825     if (!arg1) return 0;
2826   }
2827   result = (Model *)new Model((char const *)arg1);
2828   *(Model **)&jresult = result;
2829   {
2830
2831   }
2832   return jresult;
2833 }
2834
2835
2836 SWIGEXPORT jstring JNICALL Java_org_simgrid_surf_SurfJNI_Model_1getName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2837   jstring jresult = 0 ;
2838   Model *arg1 = (Model *) 0 ;
2839   char *result = 0 ;
2840
2841   (void)jenv;
2842   (void)jcls;
2843   (void)jarg1_;
2844   arg1 = *(Model **)&jarg1;
2845   result = (char *)(arg1)->getName();
2846   if (result) jresult = jenv->NewStringUTF((const char *)result);
2847   return jresult;
2848 }
2849
2850
2851 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Model_1shareResources(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2852   jdouble jresult = 0 ;
2853   Model *arg1 = (Model *) 0 ;
2854   double arg2 ;
2855   double result;
2856
2857   (void)jenv;
2858   (void)jcls;
2859   (void)jarg1_;
2860   arg1 = *(Model **)&jarg1;
2861   arg2 = (double)jarg2;
2862   result = (double)(arg1)->shareResources(arg2);
2863   jresult = (jdouble)result;
2864   return jresult;
2865 }
2866
2867
2868 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Model_1shareResourcesLazy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2869   jdouble jresult = 0 ;
2870   Model *arg1 = (Model *) 0 ;
2871   double arg2 ;
2872   double result;
2873
2874   (void)jenv;
2875   (void)jcls;
2876   (void)jarg1_;
2877   arg1 = *(Model **)&jarg1;
2878   arg2 = (double)jarg2;
2879   result = (double)(arg1)->shareResourcesLazy(arg2);
2880   jresult = (jdouble)result;
2881   return jresult;
2882 }
2883
2884
2885 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Model_1shareResourcesFull(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
2886   jdouble jresult = 0 ;
2887   Model *arg1 = (Model *) 0 ;
2888   double arg2 ;
2889   double result;
2890
2891   (void)jenv;
2892   (void)jcls;
2893   (void)jarg1_;
2894   arg1 = *(Model **)&jarg1;
2895   arg2 = (double)jarg2;
2896   result = (double)(arg1)->shareResourcesFull(arg2);
2897   jresult = (jdouble)result;
2898   return jresult;
2899 }
2900
2901
2902 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Model_1updateActionsState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3) {
2903   Model *arg1 = (Model *) 0 ;
2904   double arg2 ;
2905   double arg3 ;
2906
2907   (void)jenv;
2908   (void)jcls;
2909   (void)jarg1_;
2910   arg1 = *(Model **)&jarg1;
2911   arg2 = (double)jarg2;
2912   arg3 = (double)jarg3;
2913   (arg1)->updateActionsState(arg2,arg3);
2914 }
2915
2916
2917 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Model_1updateActionsStateLazy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3) {
2918   Model *arg1 = (Model *) 0 ;
2919   double arg2 ;
2920   double arg3 ;
2921
2922   (void)jenv;
2923   (void)jcls;
2924   (void)jarg1_;
2925   arg1 = *(Model **)&jarg1;
2926   arg2 = (double)jarg2;
2927   arg3 = (double)jarg3;
2928   (arg1)->updateActionsStateLazy(arg2,arg3);
2929 }
2930
2931
2932 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Model_1updateActionsStateFull(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3) {
2933   Model *arg1 = (Model *) 0 ;
2934   double arg2 ;
2935   double arg3 ;
2936
2937   (void)jenv;
2938   (void)jcls;
2939   (void)jarg1_;
2940   arg1 = *(Model **)&jarg1;
2941   arg2 = (double)jarg2;
2942   arg3 = (double)jarg3;
2943   (arg1)->updateActionsStateFull(arg2,arg3);
2944 }
2945
2946
2947 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Model_1getRunningActionSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2948   jlong jresult = 0 ;
2949   Model *arg1 = (Model *) 0 ;
2950   ActionList *result = 0 ;
2951
2952   (void)jenv;
2953   (void)jcls;
2954   (void)jarg1_;
2955   arg1 = *(Model **)&jarg1;
2956   result = (ActionList *)(arg1)->getRunningActionSet();
2957   *(ActionList **)&jresult = result;
2958   return jresult;
2959 }
2960
2961
2962 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Model_1getRunningActionS(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
2963   jlong jresult = 0 ;
2964   Model *arg1 = (Model *) 0 ;
2965   Action *result = 0 ;
2966
2967   (void)jenv;
2968   (void)jcls;
2969   (void)jarg1_;
2970   arg1 = *(Model **)&jarg1;
2971   result = (Action *)Model_getRunningActionS(arg1);
2972   *(Action **)&jresult = result;
2973   return jresult;
2974 }
2975
2976
2977 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1Model(JNIEnv *jenv, jclass jcls, jlong jarg1) {
2978   Model *arg1 = (Model *) 0 ;
2979
2980   (void)jenv;
2981   (void)jcls;
2982   arg1 = *(Model **)&jarg1;
2983   delete arg1;
2984 }
2985
2986
2987 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1CpuModel(JNIEnv *jenv, jclass jcls, jstring jarg1) {
2988   jlong jresult = 0 ;
2989   char *arg1 = (char *) 0 ;
2990   CpuModel *result = 0 ;
2991
2992   (void)jenv;
2993   (void)jcls;
2994   arg1 = 0;
2995   if (jarg1) {
2996     arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
2997     if (!arg1) return 0;
2998   }
2999   result = (CpuModel *)new SwigDirector_CpuModel(jenv,(char const *)arg1);
3000   *(CpuModel **)&jresult = result;
3001   {
3002
3003   }
3004   return jresult;
3005 }
3006
3007
3008 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1CpuModel(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3009   CpuModel *arg1 = (CpuModel *) 0 ;
3010
3011   (void)jenv;
3012   (void)jcls;
3013   arg1 = *(CpuModel **)&jarg1;
3014   delete arg1;
3015 }
3016
3017
3018 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_CpuModel_1createResource(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_) {
3019   jlong jresult = 0 ;
3020   CpuModel *arg1 = (CpuModel *) 0 ;
3021   char *arg2 = (char *) 0 ;
3022   DoubleDynar arg3 ;
3023   int arg4 ;
3024   double arg5 ;
3025   tmgr_trace *arg6 = (tmgr_trace *) 0 ;
3026   int arg7 ;
3027   e_surf_resource_state_t arg8 ;
3028   tmgr_trace *arg9 = (tmgr_trace *) 0 ;
3029   s_xbt_dict *arg10 = (s_xbt_dict *) 0 ;
3030   DoubleDynar *argp3 ;
3031   Cpu *result = 0 ;
3032
3033   (void)jenv;
3034   (void)jcls;
3035   (void)jarg1_;
3036   (void)jarg6_;
3037   (void)jarg9_;
3038   (void)jarg10_;
3039   arg1 = *(CpuModel **)&jarg1;
3040   arg2 = 0;
3041   if (jarg2) {
3042     arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
3043     if (!arg2) return 0;
3044   }
3045   argp3 = *(DoubleDynar **)&jarg3;
3046   if (!argp3) {
3047     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null DoubleDynar");
3048     return 0;
3049   }
3050   arg3 = *argp3;
3051   arg4 = (int)jarg4;
3052   arg5 = (double)jarg5;
3053   arg6 = *(tmgr_trace **)&jarg6;
3054   arg7 = (int)jarg7;
3055   arg8 = (e_surf_resource_state_t)jarg8;
3056   arg9 = *(tmgr_trace **)&jarg9;
3057   arg10 = *(s_xbt_dict **)&jarg10;
3058   result = (Cpu *)(arg1)->createResource((char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
3059   *(Cpu **)&jresult = result;
3060   {
3061
3062   }
3063   return jresult;
3064 }
3065
3066
3067 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_CpuModel_1addTraces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3068   CpuModel *arg1 = (CpuModel *) 0 ;
3069
3070   (void)jenv;
3071   (void)jcls;
3072   (void)jarg1_;
3073   arg1 = *(CpuModel **)&jarg1;
3074   (arg1)->addTraces();
3075 }
3076
3077
3078 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) {
3079   CpuModel *obj = *((CpuModel **)&objarg);
3080   (void)jcls;
3081   SwigDirector_CpuModel *director = dynamic_cast<SwigDirector_CpuModel *>(obj);
3082   if (director) {
3083     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
3084   }
3085 }
3086
3087
3088 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_CpuModel_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
3089   CpuModel *obj = *((CpuModel **)&objarg);
3090   SwigDirector_CpuModel *director = dynamic_cast<SwigDirector_CpuModel *>(obj);
3091   (void)jcls;
3092   if (director) {
3093     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
3094   }
3095 }
3096
3097
3098 SWIGEXPORT jstring JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1getName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3099   jstring jresult = 0 ;
3100   Resource *arg1 = (Resource *) 0 ;
3101   char *result = 0 ;
3102
3103   (void)jenv;
3104   (void)jcls;
3105   (void)jarg1_;
3106   arg1 = *(Resource **)&jarg1;
3107   result = (char *)(arg1)->getName();
3108   if (result) jresult = jenv->NewStringUTF((const char *)result);
3109   return jresult;
3110 }
3111
3112
3113 SWIGEXPORT jboolean JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1isUsed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3114   jboolean jresult = 0 ;
3115   Resource *arg1 = (Resource *) 0 ;
3116   bool result;
3117
3118   (void)jenv;
3119   (void)jcls;
3120   (void)jarg1_;
3121   arg1 = *(Resource **)&jarg1;
3122   result = (bool)(arg1)->isUsed();
3123   jresult = (jboolean)result;
3124   return jresult;
3125 }
3126
3127
3128 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1getModel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3129   jlong jresult = 0 ;
3130   Resource *arg1 = (Resource *) 0 ;
3131   Model *result = 0 ;
3132
3133   (void)jenv;
3134   (void)jcls;
3135   (void)jarg1_;
3136   arg1 = *(Resource **)&jarg1;
3137   result = (Model *)(arg1)->getModel();
3138   *(Model **)&jresult = result;
3139   return jresult;
3140 }
3141
3142
3143 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1getState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3144   jint jresult = 0 ;
3145   Resource *arg1 = (Resource *) 0 ;
3146   e_surf_resource_state_t result;
3147
3148   (void)jenv;
3149   (void)jcls;
3150   (void)jarg1_;
3151   arg1 = *(Resource **)&jarg1;
3152   result = (e_surf_resource_state_t)(arg1)->getState();
3153   jresult = (jint)result;
3154   return jresult;
3155 }
3156
3157
3158 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1getConstraint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3159   jlong jresult = 0 ;
3160   Resource *arg1 = (Resource *) 0 ;
3161   lmm_constraint *result = 0 ;
3162
3163   (void)jenv;
3164   (void)jcls;
3165   (void)jarg1_;
3166   arg1 = *(Resource **)&jarg1;
3167   result = (lmm_constraint *)(arg1)->getConstraint();
3168   *(lmm_constraint **)&jresult = result;
3169   return jresult;
3170 }
3171
3172
3173 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Resource_1getProperties(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3174   jlong jresult = 0 ;
3175   Resource *arg1 = (Resource *) 0 ;
3176   s_xbt_dict *result = 0 ;
3177
3178   (void)jenv;
3179   (void)jcls;
3180   (void)jarg1_;
3181   arg1 = *(Resource **)&jarg1;
3182   result = (s_xbt_dict *)(arg1)->getProperties();
3183   *(s_xbt_dict **)&jresult = result;
3184   return jresult;
3185 }
3186
3187
3188 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) {
3189   Resource *arg1 = (Resource *) 0 ;
3190   tmgr_trace_event *arg2 = (tmgr_trace_event *) 0 ;
3191   double arg3 ;
3192   double arg4 ;
3193
3194   (void)jenv;
3195   (void)jcls;
3196   (void)jarg1_;
3197   (void)jarg2_;
3198   arg1 = *(Resource **)&jarg1;
3199   arg2 = *(tmgr_trace_event **)&jarg2;
3200   arg3 = (double)jarg3;
3201   arg4 = (double)jarg4;
3202   (arg1)->updateState(arg2,arg3,arg4);
3203 }
3204
3205
3206 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1Resource(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3207   Resource *arg1 = (Resource *) 0 ;
3208
3209   (void)jenv;
3210   (void)jcls;
3211   arg1 = *(Resource **)&jarg1;
3212   delete arg1;
3213 }
3214
3215
3216 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) {
3217   jlong jresult = 0 ;
3218   Model *arg1 = (Model *) 0 ;
3219   char *arg2 = (char *) 0 ;
3220   s_xbt_dict *arg3 = (s_xbt_dict *) 0 ;
3221   lmm_constraint *arg4 = (lmm_constraint *) 0 ;
3222   int arg5 ;
3223   double arg6 ;
3224   double arg7 ;
3225   Cpu *result = 0 ;
3226
3227   (void)jenv;
3228   (void)jcls;
3229   (void)jarg1_;
3230   (void)jarg3_;
3231   (void)jarg4_;
3232   arg1 = *(Model **)&jarg1;
3233   arg2 = 0;
3234   if (jarg2) {
3235     arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
3236     if (!arg2) return 0;
3237   }
3238   arg3 = *(s_xbt_dict **)&jarg3;
3239   arg4 = *(lmm_constraint **)&jarg4;
3240   arg5 = (int)jarg5;
3241   arg6 = (double)jarg6;
3242   arg7 = (double)jarg7;
3243   result = (Cpu *)new SwigDirector_Cpu(jenv,arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
3244   *(Cpu **)&jresult = result;
3245   {
3246
3247   }
3248   return jresult;
3249 }
3250
3251
3252 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) {
3253   jlong jresult = 0 ;
3254   Model *arg1 = (Model *) 0 ;
3255   char *arg2 = (char *) 0 ;
3256   s_xbt_dict *arg3 = (s_xbt_dict *) 0 ;
3257   int arg4 ;
3258   double arg5 ;
3259   double arg6 ;
3260   Cpu *result = 0 ;
3261
3262   (void)jenv;
3263   (void)jcls;
3264   (void)jarg1_;
3265   (void)jarg3_;
3266   arg1 = *(Model **)&jarg1;
3267   arg2 = 0;
3268   if (jarg2) {
3269     arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
3270     if (!arg2) return 0;
3271   }
3272   arg3 = *(s_xbt_dict **)&jarg3;
3273   arg4 = (int)jarg4;
3274   arg5 = (double)jarg5;
3275   arg6 = (double)jarg6;
3276   result = (Cpu *)new SwigDirector_Cpu(jenv,arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
3277   *(Cpu **)&jresult = result;
3278   {
3279
3280   }
3281   return jresult;
3282 }
3283
3284
3285 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1Cpu(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3286   Cpu *arg1 = (Cpu *) 0 ;
3287
3288   (void)jenv;
3289   (void)jcls;
3290   arg1 = *(Cpu **)&jarg1;
3291   delete arg1;
3292 }
3293
3294
3295 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getCurrentPowerPeak(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3296   jdouble jresult = 0 ;
3297   Cpu *arg1 = (Cpu *) 0 ;
3298   double result;
3299
3300   (void)jenv;
3301   (void)jcls;
3302   (void)jarg1_;
3303   arg1 = *(Cpu **)&jarg1;
3304   result = (double)(arg1)->getCurrentPowerPeak();
3305   jresult = (jdouble)result;
3306   return jresult;
3307 }
3308
3309
3310 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getCurrentPowerPeakSwigExplicitCpu(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3311   jdouble jresult = 0 ;
3312   Cpu *arg1 = (Cpu *) 0 ;
3313   double result;
3314
3315   (void)jenv;
3316   (void)jcls;
3317   (void)jarg1_;
3318   arg1 = *(Cpu **)&jarg1;
3319   result = (double)(arg1)->Cpu::getCurrentPowerPeak();
3320   jresult = (jdouble)result;
3321   return jresult;
3322 }
3323
3324
3325 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1execute(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3326   jlong jresult = 0 ;
3327   Cpu *arg1 = (Cpu *) 0 ;
3328   double arg2 ;
3329   CpuAction *result = 0 ;
3330
3331   (void)jenv;
3332   (void)jcls;
3333   (void)jarg1_;
3334   arg1 = *(Cpu **)&jarg1;
3335   arg2 = (double)jarg2;
3336   result = (CpuAction *)(arg1)->execute(arg2);
3337   *(CpuAction **)&jresult = result;
3338   return jresult;
3339 }
3340
3341
3342 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1sleep(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3343   jlong jresult = 0 ;
3344   Cpu *arg1 = (Cpu *) 0 ;
3345   double arg2 ;
3346   CpuAction *result = 0 ;
3347
3348   (void)jenv;
3349   (void)jcls;
3350   (void)jarg1_;
3351   arg1 = *(Cpu **)&jarg1;
3352   arg2 = (double)jarg2;
3353   result = (CpuAction *)(arg1)->sleep(arg2);
3354   *(CpuAction **)&jresult = result;
3355   return jresult;
3356 }
3357
3358
3359 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getCore(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3360   jint jresult = 0 ;
3361   Cpu *arg1 = (Cpu *) 0 ;
3362   int result;
3363
3364   (void)jenv;
3365   (void)jcls;
3366   (void)jarg1_;
3367   arg1 = *(Cpu **)&jarg1;
3368   result = (int)(arg1)->getCore();
3369   jresult = (jint)result;
3370   return jresult;
3371 }
3372
3373
3374 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getCoreSwigExplicitCpu(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3375   jint jresult = 0 ;
3376   Cpu *arg1 = (Cpu *) 0 ;
3377   int result;
3378
3379   (void)jenv;
3380   (void)jcls;
3381   (void)jarg1_;
3382   arg1 = *(Cpu **)&jarg1;
3383   result = (int)(arg1)->Cpu::getCore();
3384   jresult = (jint)result;
3385   return jresult;
3386 }
3387
3388
3389 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getSpeed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3390   jdouble jresult = 0 ;
3391   Cpu *arg1 = (Cpu *) 0 ;
3392   double arg2 ;
3393   double result;
3394
3395   (void)jenv;
3396   (void)jcls;
3397   (void)jarg1_;
3398   arg1 = *(Cpu **)&jarg1;
3399   arg2 = (double)jarg2;
3400   result = (double)(arg1)->getSpeed(arg2);
3401   jresult = (jdouble)result;
3402   return jresult;
3403 }
3404
3405
3406 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getSpeedSwigExplicitCpu(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3407   jdouble jresult = 0 ;
3408   Cpu *arg1 = (Cpu *) 0 ;
3409   double arg2 ;
3410   double result;
3411
3412   (void)jenv;
3413   (void)jcls;
3414   (void)jarg1_;
3415   arg1 = *(Cpu **)&jarg1;
3416   arg2 = (double)jarg2;
3417   result = (double)(arg1)->Cpu::getSpeed(arg2);
3418   jresult = (jdouble)result;
3419   return jresult;
3420 }
3421
3422
3423 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getAvailableSpeed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3424   jdouble jresult = 0 ;
3425   Cpu *arg1 = (Cpu *) 0 ;
3426   double result;
3427
3428   (void)jenv;
3429   (void)jcls;
3430   (void)jarg1_;
3431   arg1 = *(Cpu **)&jarg1;
3432   result = (double)(arg1)->getAvailableSpeed();
3433   jresult = (jdouble)result;
3434   return jresult;
3435 }
3436
3437
3438 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getAvailableSpeedSwigExplicitCpu(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3439   jdouble jresult = 0 ;
3440   Cpu *arg1 = (Cpu *) 0 ;
3441   double result;
3442
3443   (void)jenv;
3444   (void)jcls;
3445   (void)jarg1_;
3446   arg1 = *(Cpu **)&jarg1;
3447   result = (double)(arg1)->Cpu::getAvailableSpeed();
3448   jresult = (jdouble)result;
3449   return jresult;
3450 }
3451
3452
3453 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getPowerPeakAt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3454   jdouble jresult = 0 ;
3455   Cpu *arg1 = (Cpu *) 0 ;
3456   int arg2 ;
3457   double result;
3458
3459   (void)jenv;
3460   (void)jcls;
3461   (void)jarg1_;
3462   arg1 = *(Cpu **)&jarg1;
3463   arg2 = (int)jarg2;
3464   result = (double)(arg1)->getPowerPeakAt(arg2);
3465   jresult = (jdouble)result;
3466   return jresult;
3467 }
3468
3469
3470 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1getNbPstates(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3471   jint jresult = 0 ;
3472   Cpu *arg1 = (Cpu *) 0 ;
3473   int result;
3474
3475   (void)jenv;
3476   (void)jcls;
3477   (void)jarg1_;
3478   arg1 = *(Cpu **)&jarg1;
3479   result = (int)(arg1)->getNbPstates();
3480   jresult = (jint)result;
3481   return jresult;
3482 }
3483
3484
3485 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1setPowerPeakAt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3486   Cpu *arg1 = (Cpu *) 0 ;
3487   int arg2 ;
3488
3489   (void)jenv;
3490   (void)jcls;
3491   (void)jarg1_;
3492   arg1 = *(Cpu **)&jarg1;
3493   arg2 = (int)jarg2;
3494   (arg1)->setPowerPeakAt(arg2);
3495 }
3496
3497
3498 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1setState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3499   Cpu *arg1 = (Cpu *) 0 ;
3500   e_surf_resource_state_t arg2 ;
3501
3502   (void)jenv;
3503   (void)jcls;
3504   (void)jarg1_;
3505   arg1 = *(Cpu **)&jarg1;
3506   arg2 = (e_surf_resource_state_t)jarg2;
3507   (arg1)->setState(arg2);
3508 }
3509
3510
3511 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) {
3512   Cpu *obj = *((Cpu **)&objarg);
3513   (void)jcls;
3514   SwigDirector_Cpu *director = dynamic_cast<SwigDirector_Cpu *>(obj);
3515   if (director) {
3516     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
3517   }
3518 }
3519
3520
3521 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
3522   Cpu *obj = *((Cpu **)&objarg);
3523   SwigDirector_Cpu *director = dynamic_cast<SwigDirector_Cpu *>(obj);
3524   (void)jcls;
3525   if (director) {
3526     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
3527   }
3528 }
3529
3530
3531 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1NetworkLink(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3532   NetworkLink *arg1 = (NetworkLink *) 0 ;
3533
3534   (void)jenv;
3535   (void)jcls;
3536   arg1 = *(NetworkLink **)&jarg1;
3537   delete arg1;
3538 }
3539
3540
3541 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1getBandwidth(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3542   jdouble jresult = 0 ;
3543   NetworkLink *arg1 = (NetworkLink *) 0 ;
3544   double result;
3545
3546   (void)jenv;
3547   (void)jcls;
3548   (void)jarg1_;
3549   arg1 = *(NetworkLink **)&jarg1;
3550   result = (double)(arg1)->getBandwidth();
3551   jresult = (jdouble)result;
3552   return jresult;
3553 }
3554
3555
3556 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) {
3557   NetworkLink *arg1 = (NetworkLink *) 0 ;
3558   double arg2 ;
3559   double arg3 ;
3560
3561   (void)jenv;
3562   (void)jcls;
3563   (void)jarg1_;
3564   arg1 = *(NetworkLink **)&jarg1;
3565   arg2 = (double)jarg2;
3566   arg3 = (double)jarg3;
3567   (arg1)->updateBandwidth(arg2,arg3);
3568 }
3569
3570
3571 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1updateBandwidth_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3572   NetworkLink *arg1 = (NetworkLink *) 0 ;
3573   double arg2 ;
3574
3575   (void)jenv;
3576   (void)jcls;
3577   (void)jarg1_;
3578   arg1 = *(NetworkLink **)&jarg1;
3579   arg2 = (double)jarg2;
3580   (arg1)->updateBandwidth(arg2);
3581 }
3582
3583
3584 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1getLatency(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3585   jdouble jresult = 0 ;
3586   NetworkLink *arg1 = (NetworkLink *) 0 ;
3587   double result;
3588
3589   (void)jenv;
3590   (void)jcls;
3591   (void)jarg1_;
3592   arg1 = *(NetworkLink **)&jarg1;
3593   result = (double)(arg1)->getLatency();
3594   jresult = (jdouble)result;
3595   return jresult;
3596 }
3597
3598
3599 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) {
3600   NetworkLink *arg1 = (NetworkLink *) 0 ;
3601   double arg2 ;
3602   double arg3 ;
3603
3604   (void)jenv;
3605   (void)jcls;
3606   (void)jarg1_;
3607   arg1 = *(NetworkLink **)&jarg1;
3608   arg2 = (double)jarg2;
3609   arg3 = (double)jarg3;
3610   (arg1)->updateLatency(arg2,arg3);
3611 }
3612
3613
3614 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1updateLatency_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3615   NetworkLink *arg1 = (NetworkLink *) 0 ;
3616   double arg2 ;
3617
3618   (void)jenv;
3619   (void)jcls;
3620   (void)jarg1_;
3621   arg1 = *(NetworkLink **)&jarg1;
3622   arg2 = (double)jarg2;
3623   (arg1)->updateLatency(arg2);
3624 }
3625
3626
3627 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1Action(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jboolean jarg3) {
3628   jlong jresult = 0 ;
3629   Model *arg1 = (Model *) 0 ;
3630   double arg2 ;
3631   bool arg3 ;
3632   Action *result = 0 ;
3633
3634   (void)jenv;
3635   (void)jcls;
3636   (void)jarg1_;
3637   arg1 = *(Model **)&jarg1;
3638   arg2 = (double)jarg2;
3639   arg3 = jarg3 ? true : false;
3640   result = (Action *)new Action(arg1,arg2,arg3);
3641   *(Action **)&jresult = result;
3642   return jresult;
3643 }
3644
3645
3646 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1Action(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3647   Action *arg1 = (Action *) 0 ;
3648
3649   (void)jenv;
3650   (void)jcls;
3651   arg1 = *(Action **)&jarg1;
3652   delete arg1;
3653 }
3654
3655
3656 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Action_1getModel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3657   jlong jresult = 0 ;
3658   Action *arg1 = (Action *) 0 ;
3659   Model *result = 0 ;
3660
3661   (void)jenv;
3662   (void)jcls;
3663   (void)jarg1_;
3664   arg1 = *(Action **)&jarg1;
3665   result = (Model *)(arg1)->getModel();
3666   *(Model **)&jresult = result;
3667   return jresult;
3668 }
3669
3670
3671 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Action_1getVariable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3672   jlong jresult = 0 ;
3673   Action *arg1 = (Action *) 0 ;
3674   lmm_variable *result = 0 ;
3675
3676   (void)jenv;
3677   (void)jcls;
3678   (void)jarg1_;
3679   arg1 = *(Action **)&jarg1;
3680   result = (lmm_variable *)(arg1)->getVariable();
3681   *(lmm_variable **)&jresult = result;
3682   return jresult;
3683 }
3684
3685
3686 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_Action_1getState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3687   jint jresult = 0 ;
3688   Action *arg1 = (Action *) 0 ;
3689   e_surf_action_state_t result;
3690
3691   (void)jenv;
3692   (void)jcls;
3693   (void)jarg1_;
3694   arg1 = *(Action **)&jarg1;
3695   result = (e_surf_action_state_t)(arg1)->getState();
3696   jresult = (jint)result;
3697   return jresult;
3698 }
3699
3700
3701 SWIGEXPORT jboolean JNICALL Java_org_simgrid_surf_SurfJNI_Action_1isSuspended(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3702   jboolean jresult = 0 ;
3703   Action *arg1 = (Action *) 0 ;
3704   bool result;
3705
3706   (void)jenv;
3707   (void)jcls;
3708   (void)jarg1_;
3709   arg1 = *(Action **)&jarg1;
3710   result = (bool)(arg1)->isSuspended();
3711   jresult = (jboolean)result;
3712   return jresult;
3713 }
3714
3715
3716 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Action_1getBound(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3717   jdouble jresult = 0 ;
3718   Action *arg1 = (Action *) 0 ;
3719   double result;
3720
3721   (void)jenv;
3722   (void)jcls;
3723   (void)jarg1_;
3724   arg1 = *(Action **)&jarg1;
3725   result = (double)(arg1)->getBound();
3726   jresult = (jdouble)result;
3727   return jresult;
3728 }
3729
3730
3731 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Action_1setBound(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3732   Action *arg1 = (Action *) 0 ;
3733   double arg2 ;
3734
3735   (void)jenv;
3736   (void)jcls;
3737   (void)jarg1_;
3738   arg1 = *(Action **)&jarg1;
3739   arg2 = (double)jarg2;
3740   (arg1)->setBound(arg2);
3741 }
3742
3743
3744 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Action_1updateRemains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3745   Action *arg1 = (Action *) 0 ;
3746   double arg2 ;
3747
3748   (void)jenv;
3749   (void)jcls;
3750   (void)jarg1_;
3751   arg1 = *(Action **)&jarg1;
3752   arg2 = (double)jarg2;
3753   (arg1)->updateRemains(arg2);
3754 }
3755
3756
3757 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_Action_1getRemains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3758   jdouble jresult = 0 ;
3759   Action *arg1 = (Action *) 0 ;
3760   double result;
3761
3762   (void)jenv;
3763   (void)jcls;
3764   (void)jarg1_;
3765   arg1 = *(Action **)&jarg1;
3766   result = (double)(arg1)->getRemains();
3767   jresult = (jdouble)result;
3768   return jresult;
3769 }
3770
3771
3772 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Action_1setPriority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
3773   Action *arg1 = (Action *) 0 ;
3774   double arg2 ;
3775
3776   (void)jenv;
3777   (void)jcls;
3778   (void)jarg1_;
3779   arg1 = *(Action **)&jarg1;
3780   arg2 = (double)jarg2;
3781   (arg1)->setPriority(arg2);
3782 }
3783
3784
3785 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_Action_1setState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
3786   Action *arg1 = (Action *) 0 ;
3787   e_surf_action_state_t arg2 ;
3788
3789   (void)jenv;
3790   (void)jcls;
3791   (void)jarg1_;
3792   arg1 = *(Action **)&jarg1;
3793   arg2 = (e_surf_action_state_t)jarg2;
3794   (arg1)->setState(arg2);
3795 }
3796
3797
3798 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1CpuAction(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jboolean jarg3) {
3799   jlong jresult = 0 ;
3800   Model *arg1 = (Model *) 0 ;
3801   double arg2 ;
3802   bool arg3 ;
3803   CpuAction *result = 0 ;
3804
3805   (void)jenv;
3806   (void)jcls;
3807   (void)jarg1_;
3808   arg1 = *(Model **)&jarg1;
3809   arg2 = (double)jarg2;
3810   arg3 = jarg3 ? true : false;
3811   result = (CpuAction *)new SwigDirector_CpuAction(jenv,arg1,arg2,arg3);
3812   *(CpuAction **)&jresult = result;
3813   return jresult;
3814 }
3815
3816
3817 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_CpuAction_1getCpu(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3818   jlong jresult = 0 ;
3819   CpuAction *arg1 = (CpuAction *) 0 ;
3820   Cpu *result = 0 ;
3821
3822   (void)jenv;
3823   (void)jcls;
3824   (void)jarg1_;
3825   arg1 = *(CpuAction **)&jarg1;
3826   result = (Cpu *)CpuAction_getCpu(arg1);
3827   *(Cpu **)&jresult = result;
3828   return jresult;
3829 }
3830
3831
3832 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1CpuAction(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3833   CpuAction *arg1 = (CpuAction *) 0 ;
3834
3835   (void)jenv;
3836   (void)jcls;
3837   arg1 = *(CpuAction **)&jarg1;
3838   delete arg1;
3839 }
3840
3841
3842 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) {
3843   CpuAction *obj = *((CpuAction **)&objarg);
3844   (void)jcls;
3845   SwigDirector_CpuAction *director = dynamic_cast<SwigDirector_CpuAction *>(obj);
3846   if (director) {
3847     director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
3848   }
3849 }
3850
3851
3852 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_CpuAction_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
3853   CpuAction *obj = *((CpuAction **)&objarg);
3854   SwigDirector_CpuAction *director = dynamic_cast<SwigDirector_CpuAction *>(obj);
3855   (void)jcls;
3856   if (director) {
3857     director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
3858   }
3859 }
3860
3861
3862 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_NetworkAction_1getLatency(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3863   jdouble jresult = 0 ;
3864   NetworkAction *arg1 = (NetworkAction *) 0 ;
3865   double result;
3866
3867   (void)jenv;
3868   (void)jcls;
3869   (void)jarg1_;
3870   arg1 = *(NetworkAction **)&jarg1;
3871   result = (double)NetworkAction_getLatency(arg1);
3872   jresult = (jdouble)result;
3873   return jresult;
3874 }
3875
3876
3877 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1NetworkAction(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3878   NetworkAction *arg1 = (NetworkAction *) 0 ;
3879
3880   (void)jenv;
3881   (void)jcls;
3882   arg1 = *(NetworkAction **)&jarg1;
3883   delete arg1;
3884 }
3885
3886
3887 SWIGEXPORT jstring JNICALL Java_org_simgrid_surf_SurfJNI_RoutingEdge_1getName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3888   jstring jresult = 0 ;
3889   RoutingEdge *arg1 = (RoutingEdge *) 0 ;
3890   char *result = 0 ;
3891
3892   (void)jenv;
3893   (void)jcls;
3894   (void)jarg1_;
3895   arg1 = *(RoutingEdge **)&jarg1;
3896   result = (char *)(arg1)->getName();
3897   if (result) jresult = jenv->NewStringUTF((const char *)result);
3898   return jresult;
3899 }
3900
3901
3902 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1RoutingEdge(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3903   RoutingEdge *arg1 = (RoutingEdge *) 0 ;
3904
3905   (void)jenv;
3906   (void)jcls;
3907   arg1 = *(RoutingEdge **)&jarg1;
3908   delete arg1;
3909 }
3910
3911
3912 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_LmmConstraint_1getUsage(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3913   jdouble jresult = 0 ;
3914   lmm_constraint *arg1 = (lmm_constraint *) 0 ;
3915   double result;
3916
3917   (void)jenv;
3918   (void)jcls;
3919   (void)jarg1_;
3920   arg1 = *(lmm_constraint **)&jarg1;
3921   result = (double)lmm_constraint_getUsage(arg1);
3922   jresult = (jdouble)result;
3923   return jresult;
3924 }
3925
3926
3927 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1LmmConstraint(JNIEnv *jenv, jclass jcls) {
3928   jlong jresult = 0 ;
3929   lmm_constraint *result = 0 ;
3930
3931   (void)jenv;
3932   (void)jcls;
3933   result = (lmm_constraint *)new lmm_constraint();
3934   *(lmm_constraint **)&jresult = result;
3935   return jresult;
3936 }
3937
3938
3939 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1LmmConstraint(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3940   lmm_constraint *arg1 = (lmm_constraint *) 0 ;
3941
3942   (void)jenv;
3943   (void)jcls;
3944   arg1 = *(lmm_constraint **)&jarg1;
3945   delete arg1;
3946 }
3947
3948
3949 SWIGEXPORT jdouble JNICALL Java_org_simgrid_surf_SurfJNI_LmmVariable_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
3950   jdouble jresult = 0 ;
3951   lmm_variable *arg1 = (lmm_variable *) 0 ;
3952   double result;
3953
3954   (void)jenv;
3955   (void)jcls;
3956   (void)jarg1_;
3957   arg1 = *(lmm_variable **)&jarg1;
3958   result = (double)lmm_variable_getValue(arg1);
3959   jresult = (jdouble)result;
3960   return jresult;
3961 }
3962
3963
3964 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1LmmVariable(JNIEnv *jenv, jclass jcls) {
3965   jlong jresult = 0 ;
3966   lmm_variable *result = 0 ;
3967
3968   (void)jenv;
3969   (void)jcls;
3970   result = (lmm_variable *)new lmm_variable();
3971   *(lmm_variable **)&jresult = result;
3972   return jresult;
3973 }
3974
3975
3976 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1LmmVariable(JNIEnv *jenv, jclass jcls, jlong jarg1) {
3977   lmm_variable *arg1 = (lmm_variable *) 0 ;
3978
3979   (void)jenv;
3980   (void)jcls;
3981   arg1 = *(lmm_variable **)&jarg1;
3982   delete arg1;
3983 }
3984
3985
3986 SWIGEXPORT jstring JNICALL Java_org_simgrid_surf_SurfJNI_XbtDict_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
3987   jstring jresult = 0 ;
3988   s_xbt_dict *arg1 = (s_xbt_dict *) 0 ;
3989   char *arg2 = (char *) 0 ;
3990   char *result = 0 ;
3991
3992   (void)jenv;
3993   (void)jcls;
3994   (void)jarg1_;
3995   arg1 = *(s_xbt_dict **)&jarg1;
3996   arg2 = 0;
3997   if (jarg2) {
3998     arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
3999     if (!arg2) return 0;
4000   }
4001   result = (char *)s_xbt_dict_getValue(arg1,arg2);
4002   if (result) jresult = jenv->NewStringUTF((const char *)result);
4003   if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
4004   return jresult;
4005 }
4006
4007
4008 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_new_1XbtDict(JNIEnv *jenv, jclass jcls) {
4009   jlong jresult = 0 ;
4010   s_xbt_dict *result = 0 ;
4011
4012   (void)jenv;
4013   (void)jcls;
4014   result = (s_xbt_dict *)new s_xbt_dict();
4015   *(s_xbt_dict **)&jresult = result;
4016   return jresult;
4017 }
4018
4019
4020 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_delete_1XbtDict(JNIEnv *jenv, jclass jcls, jlong jarg1) {
4021   s_xbt_dict *arg1 = (s_xbt_dict *) 0 ;
4022
4023   (void)jenv;
4024   (void)jcls;
4025   arg1 = *(s_xbt_dict **)&jarg1;
4026   delete arg1;
4027 }
4028
4029
4030 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_SURF_1ACTION_1READY_1get(JNIEnv *jenv, jclass jcls) {
4031   jint jresult = 0 ;
4032   e_surf_action_state_t result;
4033
4034   (void)jenv;
4035   (void)jcls;
4036   result = (e_surf_action_state_t)SURF_ACTION_READY;
4037   jresult = (jint)result;
4038   return jresult;
4039 }
4040
4041
4042 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_SURF_1RESOURCE_1ON_1get(JNIEnv *jenv, jclass jcls) {
4043   jint jresult = 0 ;
4044   e_surf_resource_state_t result;
4045
4046   (void)jenv;
4047   (void)jcls;
4048   result = (e_surf_resource_state_t)SURF_RESOURCE_ON;
4049   jresult = (jint)result;
4050   return jresult;
4051 }
4052
4053
4054 SWIGEXPORT jint JNICALL Java_org_simgrid_surf_SurfJNI_SURF_1RESOURCE_1OFF_1get(JNIEnv *jenv, jclass jcls) {
4055   jint jresult = 0 ;
4056   e_surf_resource_state_t result;
4057
4058   (void)jenv;
4059   (void)jcls;
4060   result = (e_surf_resource_state_t)SURF_RESOURCE_OFF;
4061   jresult = (jint)result;
4062   return jresult;
4063 }
4064
4065
4066 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_CpuModel_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
4067     jlong baseptr = 0;
4068     (void)jenv;
4069     (void)jcls;
4070     *(Model **)&baseptr = *(CpuModel **)&jarg1;
4071     return baseptr;
4072 }
4073
4074 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_Cpu_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
4075     jlong baseptr = 0;
4076     (void)jenv;
4077     (void)jcls;
4078     *(Resource **)&baseptr = *(Cpu **)&jarg1;
4079     return baseptr;
4080 }
4081
4082 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_NetworkLink_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
4083     jlong baseptr = 0;
4084     (void)jenv;
4085     (void)jcls;
4086     *(Resource **)&baseptr = *(NetworkLink **)&jarg1;
4087     return baseptr;
4088 }
4089
4090 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_CpuAction_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
4091     jlong baseptr = 0;
4092     (void)jenv;
4093     (void)jcls;
4094     *(Action **)&baseptr = *(CpuAction **)&jarg1;
4095     return baseptr;
4096 }
4097
4098 SWIGEXPORT jlong JNICALL Java_org_simgrid_surf_SurfJNI_NetworkAction_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
4099     jlong baseptr = 0;
4100     (void)jenv;
4101     (void)jcls;
4102     *(Action **)&baseptr = *(NetworkAction **)&jarg1;
4103     return baseptr;
4104 }
4105
4106 SWIGEXPORT void JNICALL Java_org_simgrid_surf_SurfJNI_swig_1module_1init(JNIEnv *jenv, jclass jcls) {
4107   int i;
4108
4109   static struct {
4110     const char *method;
4111     const char *signature;
4112   } methods[33] = {
4113     {
4114       "SwigDirector_Plugin_cpuCreatedCallback", "(Lorg/simgrid/surf/Plugin;J)V"
4115     },
4116     {
4117       "SwigDirector_Plugin_cpuDestructedCallback", "(Lorg/simgrid/surf/Plugin;J)V"
4118     },
4119     {
4120       "SwigDirector_Plugin_cpuStateChangedCallback", "(Lorg/simgrid/surf/Plugin;JII)V"
4121     },
4122     {
4123       "SwigDirector_Plugin_cpuActionStateChangedCallback", "(Lorg/simgrid/surf/Plugin;JII)V"
4124     },
4125     {
4126       "SwigDirector_Plugin_networkLinkCreatedCallback", "(Lorg/simgrid/surf/Plugin;J)V"
4127     },
4128     {
4129       "SwigDirector_Plugin_networkLinkDestructedCallback", "(Lorg/simgrid/surf/Plugin;J)V"
4130     },
4131     {
4132       "SwigDirector_Plugin_networkLinkStateChangedCallback", "(Lorg/simgrid/surf/Plugin;JII)V"
4133     },
4134     {
4135       "SwigDirector_Plugin_networkActionStateChangedCallback", "(Lorg/simgrid/surf/Plugin;JII)V"
4136     },
4137     {
4138       "SwigDirector_Plugin_networkCommunicateCallback", "(Lorg/simgrid/surf/Plugin;JJJDD)V"
4139     },
4140     {
4141       "SwigDirector_CpuModel_shareResources", "(Lorg/simgrid/surf/CpuModel;D)D"
4142     },
4143     {
4144       "SwigDirector_CpuModel_shareResourcesLazy", "(Lorg/simgrid/surf/CpuModel;D)D"
4145     },
4146     {
4147       "SwigDirector_CpuModel_shareResourcesFull", "(Lorg/simgrid/surf/CpuModel;D)D"
4148     },
4149     {
4150       "SwigDirector_CpuModel_updateActionsState", "(Lorg/simgrid/surf/CpuModel;DD)V"
4151     },
4152     {
4153       "SwigDirector_CpuModel_updateActionsStateLazy", "(Lorg/simgrid/surf/CpuModel;DD)V"
4154     },
4155     {
4156       "SwigDirector_CpuModel_updateActionsStateFull", "(Lorg/simgrid/surf/CpuModel;DD)V"
4157     },
4158     {
4159       "SwigDirector_CpuModel_getRunningActionSet", "(Lorg/simgrid/surf/CpuModel;)J"
4160     },
4161     {
4162       "SwigDirector_CpuModel_createResource", "(Lorg/simgrid/surf/CpuModel;Ljava/lang/String;[DIDJIIJJ)J"
4163     },
4164     {
4165       "SwigDirector_CpuModel_addTraces", "(Lorg/simgrid/surf/CpuModel;)V"
4166     },
4167     {
4168       "SwigDirector_Cpu_isUsed", "(Lorg/simgrid/surf/Cpu;)Z"
4169     },
4170     {
4171       "SwigDirector_Cpu_getState", "(Lorg/simgrid/surf/Cpu;)I"
4172     },
4173     {
4174       "SwigDirector_Cpu_updateState", "(Lorg/simgrid/surf/Cpu;JDD)V"
4175     },
4176     {
4177       "SwigDirector_Cpu_getCurrentPowerPeak", "(Lorg/simgrid/surf/Cpu;)D"
4178     },
4179     {
4180       "SwigDirector_Cpu_execute", "(Lorg/simgrid/surf/Cpu;D)J"
4181     },
4182     {
4183       "SwigDirector_Cpu_sleep", "(Lorg/simgrid/surf/Cpu;D)J"
4184     },
4185     {
4186       "SwigDirector_Cpu_getCore", "(Lorg/simgrid/surf/Cpu;)I"
4187     },
4188     {
4189       "SwigDirector_Cpu_getSpeed", "(Lorg/simgrid/surf/Cpu;D)D"
4190     },
4191     {
4192       "SwigDirector_Cpu_getAvailableSpeed", "(Lorg/simgrid/surf/Cpu;)D"
4193     },
4194     {
4195       "SwigDirector_Cpu_getPowerPeakAt", "(Lorg/simgrid/surf/Cpu;I)D"
4196     },
4197     {
4198       "SwigDirector_Cpu_getNbPstates", "(Lorg/simgrid/surf/Cpu;)I"
4199     },
4200     {
4201       "SwigDirector_Cpu_setPowerPeakAt", "(Lorg/simgrid/surf/Cpu;I)V"
4202     },
4203     {
4204       "SwigDirector_CpuAction_getRemains", "(Lorg/simgrid/surf/CpuAction;)D"
4205     },
4206     {
4207       "SwigDirector_CpuAction_setPriority", "(Lorg/simgrid/surf/CpuAction;D)V"
4208     },
4209     {
4210       "SwigDirector_CpuAction_setState", "(Lorg/simgrid/surf/CpuAction;I)V"
4211     }
4212   };
4213   Swig::jclass_SurfJNI = (jclass) jenv->NewGlobalRef(jcls);
4214   if (!Swig::jclass_SurfJNI) return;
4215   for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {
4216     Swig::director_methids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);
4217     if (!Swig::director_methids[i]) return;
4218   }
4219 }
4220
4221
4222 #ifdef __cplusplus
4223 }
4224 #endif
4225