/*****************************************************************************
   Copyright 2004-2008 Steve Menard
   
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
   
*****************************************************************************/   

// This code has been automatically generated ... No not edit



    /** GetStaticByteField */
    jbyte GetStaticByteField(jclass clazz, jfieldID fid); 
    
    /** GetByteField */
    jbyte GetByteField(jobject clazz, jfieldID fid); 
    
    /** SetStaticByteField */
    void SetStaticByteField(jclass clazz, jfieldID fid, jbyte val); 
    
    /** SetByteField */
    void SetByteField(jobject clazz, jfieldID fid, jbyte val); 
    
    /** CallStaticByteMethodA */
    jbyte CallStaticByteMethodA(jclass clazz, jmethodID mid, jvalue* val); 
    
    /** CallStaticByteMethod */
    jbyte CallStaticByteMethod(jclass clazz, jmethodID mid); 
    
    /** CallByteMethodA */
    jbyte CallByteMethodA(jobject obj, jmethodID mid, jvalue* val); 
    
    /** CallByteMethod */
    jbyte CallByteMethod(jobject obj, jmethodID mid);

    /** CallByteMethodA */
    jbyte CallNonvirtualByteMethodA(jobject obj, jclass claz, jmethodID mid, jvalue* val); 
    
    /** CallByteMethod */
    jbyte CallNonvirtualByteMethod(jobject obj, jclass claz, jmethodID mid);

    /** GetStaticShortField */
    jshort GetStaticShortField(jclass clazz, jfieldID fid); 
    
    /** GetShortField */
    jshort GetShortField(jobject clazz, jfieldID fid); 
    
    /** SetStaticShortField */
    void SetStaticShortField(jclass clazz, jfieldID fid, jshort val); 
    
    /** SetShortField */
    void SetShortField(jobject clazz, jfieldID fid, jshort val); 
    
    /** CallStaticShortMethodA */
    jshort CallStaticShortMethodA(jclass clazz, jmethodID mid, jvalue* val); 
    
    /** CallStaticShortMethod */
    jshort CallStaticShortMethod(jclass clazz, jmethodID mid); 
    
    /** CallShortMethodA */
    jshort CallShortMethodA(jobject obj, jmethodID mid, jvalue* val); 
    
    /** CallShortMethod */
    jshort CallShortMethod(jobject obj, jmethodID mid);

    /** CallShortMethodA */
    jshort CallNonvirtualShortMethodA(jobject obj, jclass claz, jmethodID mid, jvalue* val); 
    
    /** CallShortMethod */
    jshort CallNonvirtualShortMethod(jobject obj, jclass claz, jmethodID mid);

    /** GetStaticIntField */
    jint GetStaticIntField(jclass clazz, jfieldID fid); 
    
    /** GetIntField */
    jint GetIntField(jobject clazz, jfieldID fid); 
    
    /** SetStaticIntField */
    void SetStaticIntField(jclass clazz, jfieldID fid, jint val); 
    
    /** SetIntField */
    void SetIntField(jobject clazz, jfieldID fid, jint val); 
    
    /** CallStaticIntMethodA */
    jint CallStaticIntMethodA(jclass clazz, jmethodID mid, jvalue* val); 
    
    /** CallStaticIntMethod */
    jint CallStaticIntMethod(jclass clazz, jmethodID mid); 
    
    /** CallIntMethodA */
    jint CallIntMethodA(jobject obj, jmethodID mid, jvalue* val); 
    
    /** CallIntMethod */
    jint CallIntMethod(jobject obj, jmethodID mid);

    /** CallIntMethodA */
    jint CallNonvirtualIntMethodA(jobject obj, jclass claz, jmethodID mid, jvalue* val); 
    
    /** CallIntMethod */
    jint CallNonvirtualIntMethod(jobject obj, jclass claz, jmethodID mid);

    /** GetStaticLongField */
    jlong GetStaticLongField(jclass clazz, jfieldID fid); 
    
    /** GetLongField */
    jlong GetLongField(jobject clazz, jfieldID fid); 
    
    /** SetStaticLongField */
    void SetStaticLongField(jclass clazz, jfieldID fid, jlong val); 
    
    /** SetLongField */
    void SetLongField(jobject clazz, jfieldID fid, jlong val); 
    
    /** CallStaticLongMethodA */
    jlong CallStaticLongMethodA(jclass clazz, jmethodID mid, jvalue* val); 
    
    /** CallStaticLongMethod */
    jlong CallStaticLongMethod(jclass clazz, jmethodID mid); 
    
    /** CallLongMethodA */
    jlong CallLongMethodA(jobject obj, jmethodID mid, jvalue* val); 
    
    /** CallLongMethod */
    jlong CallLongMethod(jobject obj, jmethodID mid);

    /** CallLongMethodA */
    jlong CallNonvirtualLongMethodA(jobject obj, jclass claz, jmethodID mid, jvalue* val); 
    
    /** CallLongMethod */
    jlong CallNonvirtualLongMethod(jobject obj, jclass claz, jmethodID mid);

    /** GetStaticFloatField */
    jfloat GetStaticFloatField(jclass clazz, jfieldID fid); 
    
    /** GetFloatField */
    jfloat GetFloatField(jobject clazz, jfieldID fid); 
    
    /** SetStaticFloatField */
    void SetStaticFloatField(jclass clazz, jfieldID fid, jfloat val); 
    
    /** SetFloatField */
    void SetFloatField(jobject clazz, jfieldID fid, jfloat val); 
    
    /** CallStaticFloatMethodA */
    jfloat CallStaticFloatMethodA(jclass clazz, jmethodID mid, jvalue* val); 
    
    /** CallStaticFloatMethod */
    jfloat CallStaticFloatMethod(jclass clazz, jmethodID mid); 
    
    /** CallFloatMethodA */
    jfloat CallFloatMethodA(jobject obj, jmethodID mid, jvalue* val); 
    
    /** CallFloatMethod */
    jfloat CallFloatMethod(jobject obj, jmethodID mid);

    /** CallFloatMethodA */
    jfloat CallNonvirtualFloatMethodA(jobject obj, jclass claz, jmethodID mid, jvalue* val); 
    
    /** CallFloatMethod */
    jfloat CallNonvirtualFloatMethod(jobject obj, jclass claz, jmethodID mid);

    /** GetStaticDoubleField */
    jdouble GetStaticDoubleField(jclass clazz, jfieldID fid); 
    
    /** GetDoubleField */
    jdouble GetDoubleField(jobject clazz, jfieldID fid); 
    
    /** SetStaticDoubleField */
    void SetStaticDoubleField(jclass clazz, jfieldID fid, jdouble val); 
    
    /** SetDoubleField */
    void SetDoubleField(jobject clazz, jfieldID fid, jdouble val); 
    
    /** CallStaticDoubleMethodA */
    jdouble CallStaticDoubleMethodA(jclass clazz, jmethodID mid, jvalue* val); 
    
    /** CallStaticDoubleMethod */
    jdouble CallStaticDoubleMethod(jclass clazz, jmethodID mid); 
    
    /** CallDoubleMethodA */
    jdouble CallDoubleMethodA(jobject obj, jmethodID mid, jvalue* val); 
    
    /** CallDoubleMethod */
    jdouble CallDoubleMethod(jobject obj, jmethodID mid);

    /** CallDoubleMethodA */
    jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass claz, jmethodID mid, jvalue* val); 
    
    /** CallDoubleMethod */
    jdouble CallNonvirtualDoubleMethod(jobject obj, jclass claz, jmethodID mid);

    /** GetStaticCharField */
    jchar GetStaticCharField(jclass clazz, jfieldID fid); 
    
    /** GetCharField */
    jchar GetCharField(jobject clazz, jfieldID fid); 
    
    /** SetStaticCharField */
    void SetStaticCharField(jclass clazz, jfieldID fid, jchar val); 
    
    /** SetCharField */
    void SetCharField(jobject clazz, jfieldID fid, jchar val); 
    
    /** CallStaticCharMethodA */
    jchar CallStaticCharMethodA(jclass clazz, jmethodID mid, jvalue* val); 
    
    /** CallStaticCharMethod */
    jchar CallStaticCharMethod(jclass clazz, jmethodID mid); 
    
    /** CallCharMethodA */
    jchar CallCharMethodA(jobject obj, jmethodID mid, jvalue* val); 
    
    /** CallCharMethod */
    jchar CallCharMethod(jobject obj, jmethodID mid);

    /** CallCharMethodA */
    jchar CallNonvirtualCharMethodA(jobject obj, jclass claz, jmethodID mid, jvalue* val); 
    
    /** CallCharMethod */
    jchar CallNonvirtualCharMethod(jobject obj, jclass claz, jmethodID mid);

    /** GetStaticBooleanField */
    jboolean GetStaticBooleanField(jclass clazz, jfieldID fid); 
    
    /** GetBooleanField */
    jboolean GetBooleanField(jobject clazz, jfieldID fid); 
    
    /** SetStaticBooleanField */
    void SetStaticBooleanField(jclass clazz, jfieldID fid, jboolean val); 
    
    /** SetBooleanField */
    void SetBooleanField(jobject clazz, jfieldID fid, jboolean val); 
    
    /** CallStaticBooleanMethodA */
    jboolean CallStaticBooleanMethodA(jclass clazz, jmethodID mid, jvalue* val); 
    
    /** CallStaticBooleanMethod */
    jboolean CallStaticBooleanMethod(jclass clazz, jmethodID mid); 
    
    /** CallBooleanMethodA */
    jboolean CallBooleanMethodA(jobject obj, jmethodID mid, jvalue* val); 
    
    /** CallBooleanMethod */
    jboolean CallBooleanMethod(jobject obj, jmethodID mid);

    /** CallBooleanMethodA */
    jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass claz, jmethodID mid, jvalue* val); 
    
    /** CallBooleanMethod */
    jboolean CallNonvirtualBooleanMethod(jobject obj, jclass claz, jmethodID mid);

    /** GetStaticObjectField */
    jobject GetStaticObjectField(jclass clazz, jfieldID fid); 
    
    /** GetObjectField */
    jobject GetObjectField(jobject clazz, jfieldID fid); 
    
    /** SetStaticObjectField */
    void SetStaticObjectField(jclass clazz, jfieldID fid, jobject val); 
    
    /** SetObjectField */
    void SetObjectField(jobject clazz, jfieldID fid, jobject val); 
    
    /** CallStaticObjectMethodA */
    jobject CallStaticObjectMethodA(jclass clazz, jmethodID mid, jvalue* val); 
    
    /** CallStaticObjectMethod */
    jobject CallStaticObjectMethod(jclass clazz, jmethodID mid); 
    
    /** CallObjectMethodA */
    jobject CallObjectMethodA(jobject obj, jmethodID mid, jvalue* val); 
    
    /** CallObjectMethod */
    jobject CallObjectMethod(jobject obj, jmethodID mid);

    /** CallObjectMethodA */
    jobject CallNonvirtualObjectMethodA(jobject obj, jclass claz, jmethodID mid, jvalue* val); 
    
    /** CallObjectMethod */
    jobject CallNonvirtualObjectMethod(jobject obj, jclass claz, jmethodID mid);

    /** NewByteArray */
    jbyteArray NewByteArray(jint len); 
    
    /** SetByteArrayRegion */
    void SetByteArrayRegion(jbyteArray array, int start, int len, jbyte* vals); 

    /** GetByteArrayRegion */
    void GetByteArrayRegion(jbyteArray array, int start, int len, jbyte* vals); 

    /** GetByteArrayElements */
    jbyte* GetByteArrayElements(jbyteArray array, jboolean* isCopy);

    /** ReleaseByteArrayElements */
    void ReleaseByteArrayElements(jbyteArray, jbyte* v, jint mode);

    /** NewShortArray */
    jshortArray NewShortArray(jint len); 
    
    /** SetShortArrayRegion */
    void SetShortArrayRegion(jshortArray array, int start, int len, jshort* vals); 

    /** GetShortArrayRegion */
    void GetShortArrayRegion(jshortArray array, int start, int len, jshort* vals); 

    /** GetShortArrayElements */
    jshort* GetShortArrayElements(jshortArray array, jboolean* isCopy);

    /** ReleaseShortArrayElements */
    void ReleaseShortArrayElements(jshortArray, jshort* v, jint mode);

    /** NewIntArray */
    jintArray NewIntArray(jint len); 
    
    /** SetIntArrayRegion */
    void SetIntArrayRegion(jintArray array, int start, int len, jint* vals); 

    /** GetIntArrayRegion */
    void GetIntArrayRegion(jintArray array, int start, int len, jint* vals); 

    /** GetIntArrayElements */
    jint* GetIntArrayElements(jintArray array, jboolean* isCopy);

    /** ReleaseIntArrayElements */
    void ReleaseIntArrayElements(jintArray, jint* v, jint mode);

    /** NewLongArray */
    jlongArray NewLongArray(jint len); 
    
    /** SetLongArrayRegion */
    void SetLongArrayRegion(jlongArray array, int start, int len, jlong* vals); 

    /** GetLongArrayRegion */
    void GetLongArrayRegion(jlongArray array, int start, int len, jlong* vals); 

    /** GetLongArrayElements */
    jlong* GetLongArrayElements(jlongArray array, jboolean* isCopy);

    /** ReleaseLongArrayElements */
    void ReleaseLongArrayElements(jlongArray, jlong* v, jint mode);

    /** NewFloatArray */
    jfloatArray NewFloatArray(jint len); 
    
    /** SetFloatArrayRegion */
    void SetFloatArrayRegion(jfloatArray array, int start, int len, jfloat* vals); 

    /** GetFloatArrayRegion */
    void GetFloatArrayRegion(jfloatArray array, int start, int len, jfloat* vals); 

    /** GetFloatArrayElements */
    jfloat* GetFloatArrayElements(jfloatArray array, jboolean* isCopy);

    /** ReleaseFloatArrayElements */
    void ReleaseFloatArrayElements(jfloatArray, jfloat* v, jint mode);

    /** NewDoubleArray */
    jdoubleArray NewDoubleArray(jint len); 
    
    /** SetDoubleArrayRegion */
    void SetDoubleArrayRegion(jdoubleArray array, int start, int len, jdouble* vals); 

    /** GetDoubleArrayRegion */
    void GetDoubleArrayRegion(jdoubleArray array, int start, int len, jdouble* vals); 

    /** GetDoubleArrayElements */
    jdouble* GetDoubleArrayElements(jdoubleArray array, jboolean* isCopy);

    /** ReleaseDoubleArrayElements */
    void ReleaseDoubleArrayElements(jdoubleArray, jdouble* v, jint mode);

    /** NewCharArray */
    jcharArray NewCharArray(jint len); 
    
    /** SetCharArrayRegion */
    void SetCharArrayRegion(jcharArray array, int start, int len, jchar* vals); 

    /** GetCharArrayRegion */
    void GetCharArrayRegion(jcharArray array, int start, int len, jchar* vals); 

    /** GetCharArrayElements */
    jchar* GetCharArrayElements(jcharArray array, jboolean* isCopy);

    /** ReleaseCharArrayElements */
    void ReleaseCharArrayElements(jcharArray, jchar* v, jint mode);

    /** NewBooleanArray */
    jbooleanArray NewBooleanArray(jint len); 
    
    /** SetBooleanArrayRegion */
    void SetBooleanArrayRegion(jbooleanArray array, int start, int len, jboolean* vals); 

    /** GetBooleanArrayRegion */
    void GetBooleanArrayRegion(jbooleanArray array, int start, int len, jboolean* vals); 

    /** GetBooleanArrayElements */
    jboolean* GetBooleanArrayElements(jbooleanArray array, jboolean* isCopy);

    /** ReleaseBooleanArrayElements */
    void ReleaseBooleanArrayElements(jbooleanArray, jboolean* v, jint mode);

/** MonitorEnter */
int MonitorEnter(jobject a0);
/** MonitorExit */
int MonitorExit(jobject a0);
/** FromReflectedMethod */
jmethodID FromReflectedMethod(jobject a0);
/** FromReflectedField */
jfieldID FromReflectedField(jobject a0);
/** FindClass */
jclass FindClass(const char* a0);
/** IsInstanceOf */
jboolean IsInstanceOf(jobject a0, jclass a1);
/** NewObjectArray */
jobjectArray NewObjectArray(int a0, jclass a1, jobject a2);
/** SetObjectArrayElement */
void SetObjectArrayElement(jobjectArray a0, int a1, jobject a2);
/** CallStaticVoidMethodA */
void CallStaticVoidMethodA(jclass a0, jmethodID a1, jvalue* a2);
/** CallVoidMethodA */
void CallVoidMethodA(jobject a0, jmethodID a1, jvalue* a2);
/** CallVoidMethod */
void CallVoidMethod(jobject a0, jmethodID a1);
/** IsAssignableFrom */
jboolean IsAssignableFrom(jclass a0, jclass a1);
/** NewString */
jstring NewString(const jchar* a0, int a1);
/** GetSuperclass */
jclass GetSuperclass(jclass a0);
/** GetStringUTFChars */
const char* GetStringUTFChars(jstring a0, jboolean* a1);
/** ReleaseStringUTFChars */
void ReleaseStringUTFChars(jstring a0, const char* a1);
/** GetArrayLength */
jsize GetArrayLength(jarray a0);
/** GetObjectArrayElement */
jobject GetObjectArrayElement(jobjectArray a0, int a1);
/** GetObjectClass */
jclass GetObjectClass(jobject a0);
/** GetMethodID */
jmethodID GetMethodID(jclass a0, const char* a1, const char* a2);
/** GetStaticMethodID */
jmethodID GetStaticMethodID(jclass a0, const char* a1, const char* a2);
/** GetFieldID */
jfieldID GetFieldID(jclass a0, const char* a1, const char* a2);
/** GetStaticFieldID */
jfieldID GetStaticFieldID(jclass a0, const char* a1, const char* a2);
/** GetStringChars */
const jchar* GetStringChars(jstring a0, jboolean* a1);
/** ReleaseStringChars */
void ReleaseStringChars(jstring a0, const jchar* a1);
/** GetStringLength */
jsize GetStringLength(jstring a0);
/** DefineClass */
jclass DefineClass(const char* a0, jobject a1, const jbyte* a2, jsize a3);
/** RegisterNatives */
jint RegisterNatives(jclass a0, const JNINativeMethod* a1, jint a2);