JavaContext.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_JavaContext_hxx
#define __ccxx_JavaContext_hxx

#include <commonc++/Common.h++>
#include <commonc++/Exception.h++>
#include <commonc++/JavaException.h++>
#include <commonc++/String.h++>

#include <jni.h>
#include <cstdarg>

namespace ccxx {

class JavaVirtualMachine; // fwd decl

struct JavaNativeMethod
{
  String signature;

  void* function;
};

class COMMONCPPJVM_API JavaContext
{
  friend class JavaVirtualMachine;

 public:

  JavaContext(JNIEnv* env);

  ~JavaContext();

  static String encodeType(const String& type);

  static bool parseSignature(const String& signature, String& method,
                             String& descriptor, bool& isStatic);

  jclass findClass(const String& name);

  jclass defineClass(const String& name, const byte_t* buf, size_t length);

  jmethodID findMethod(jclass clazz, const String& signature);

  jobject createObject(jclass clazz, jmethodID constructor, ...);

  jobject createObjectVA(jclass clazz, jmethodID constructor, va_list args);

  void callVoidMethod(jobject object, jmethodID method, ...);

  jobject callObjectMethod(jobject object, jmethodID method, ...);

  String callStringMethod(jobject object, jmethodID method, ...);

  bool callBooleanMethod(jobject object, jmethodID method, ...);

  byte_t callByteMethod(jobject object, jmethodID method, ...);

  char16_t callCharMethod(jobject object, jmethodID method, ...);

  int16_t callShortMethod(jobject object, jmethodID method, ...);

  int32_t callIntMethod(jobject object, jmethodID method, ...);

  int64_t callLongMethod(jobject object, jmethodID method, ...);

  float callFloatMethod(jobject object, jmethodID method, ...);

  double callDoubleMethod(jobject object, jmethodID method, ...);

  void callNonvirtualVoidMethod(jobject object, jclass clazz, jmethodID method,
                                ...);

  jobject callNonvirtualObjectMethod(jobject object, jclass clazz,
                                     jmethodID method, ...);

  bool callNonvirtualBooleanMethod(jobject object, jclass clazz,
                                   jmethodID method, ...);

  byte_t callNonvirtualByteMethod(jobject object, jclass clazz,
                                  jmethodID method, ...);

  char16_t callNonvirtualCharMethod(jobject object, jclass clazz,
                                    jmethodID method, ...);

  int16_t callNonvirtualShortMethod(jobject object, jclass clazz,
                                    jmethodID method, ...);

  int32_t callNonvirtualIntMethod(jobject object, jclass clazz,
                                  jmethodID method, ...);

  int64_t callNonvirtualLongMethod(jobject object, jclass clazz,
                                   jmethodID method, ...);

  float callNonvirtualFloatMethod(jobject object, jclass clazz,
                                  jmethodID method, ...);

  double callNonvirtualDoubleMethod(jobject object, jclass clazz,
                                    jmethodID method, ...);

  void callStaticVoidMethod(jclass clazz, jmethodID method, ...);

  jobject callStaticObjectMethod(jclass clazz, jmethodID method, ...);

  String callStaticStringMethod(jclass clazz, jmethodID method, ...);

  bool callStaticBooleanMethod(jclass clazz, jmethodID method, ...);

  byte_t callStaticByteMethod(jclass clazz, jmethodID method, ...);

  char16_t callStaticCharMethod(jclass clazz, jmethodID method, ...);

  int16_t callStaticShortMethod(jclass clazz, jmethodID method, ...);

  int32_t callStaticIntMethod(jclass clazz, jmethodID method, ...);

  int64_t callStaticLongMethod(jclass clazz, jmethodID method, ...);

  float callStaticFloatMethod(jclass clazz, jmethodID method, ...);

  double callStaticDoubleMethod(jclass clazz, jmethodID method, ...);

  bool checkException(bool verbose = false);

  void clearException();

  jthrowable getException();

  bool throwException(jclass exception, const String& message);

  jfieldID findField(jclass clazz, const String& signature);

  jobject getObjectField(jobject object, jfieldID field);

  bool getBooleanField(jobject object, jfieldID field);

  byte_t getByteField(jobject object, jfieldID field);

  char16_t getCharField(jobject object, jfieldID field);

  int16_t getShortField(jobject object, jfieldID field);

  int32_t getIntField(jobject object, jfieldID field);

  int64_t getLongField(jobject object, jfieldID field);

  float getFloatField(jobject object, jfieldID field);

  double getDoubleField(jobject object, jfieldID field);

  String getStringField(jobject object, jfieldID field);

  jobject getStaticObjectField(jclass clazz, jfieldID field);

  bool getStaticBooleanField(jclass clazz, jfieldID field);

  byte_t getStaticByteField(jclass clazz, jfieldID field);

  char16_t getStaticCharField(jclass clazz, jfieldID field);

  int16_t getStaticShortField(jclass clazz, jfieldID field);

  int32_t getStaticIntField(jclass clazz, jfieldID field);

  int64_t getStaticLongField(jclass clazz, jfieldID field);

  float getStaticFloatField(jclass clazz, jfieldID field);

  double getStaticDoubleField(jclass clazz, jfieldID field);

  String getStaticStringField(jclass clazz, jfieldID field);

  void setObjectField(jobject object, jfieldID field, jobject value);

  void setBooleanField(jobject object, jfieldID field, bool value);

  void setByteField(jobject object, jfieldID field, byte_t value);

  void setCharField(jobject object, jfieldID field, char16_t value);

  void setShortField(jobject object, jfieldID field, int16_t value);

  void setIntField(jobject object, jfieldID field, int32_t value);

  void setLongField(jobject object, jfieldID field, int64_t value);

  void setFloatField(jobject object, jfieldID field, float value);

  void setDoubleField(jobject object, jfieldID field, double value);

  void setStringField(jobject object, jfieldID field, const String& value);

  void setStaticObjectField(jclass clazz, jfieldID field, jobject value);

  void setStaticBooleanField(jclass clazz, jfieldID field, bool value);

  void setStaticByteField(jclass clazz, jfieldID field, byte_t value);

  void setStaticCharField(jclass clazz, jfieldID field, char16_t value);

  void setStaticShortField(jclass clazz, jfieldID field, int16_t value);

  void setStaticIntField(jclass clazz, jfieldID field, int32_t value);

  void setStaticLongField(jclass clazz, jfieldID field, int64_t value);

  void setStaticFloatField(jclass clazz, jfieldID field, float value);

  void setStaticDoubleField(jclass clazz, jfieldID field, double value);

  jbyteArray createByteArray(uint_t length);

  void setObjectArrayElement(jobjectArray array, uint_t index, jobject value);

  jobject getObjectArrayElement(jobjectArray array, uint_t index);

  uint_t getArrayLength(jarray array);

  jobject createDirectByteBuffer(byte_t* buf, size_t size);

  void* getDirectBufferRegion(jobject buf, uint64_t& size);

  jobject createLocalRef(jobject object);

  void deleteLocalRef(jobject ref);

  void ensureLocalCapacity(uint_t capacity);

  jobject createGlobalRef(jobject object);

  void deleteGlobalRef(jobject ref);

  String decodeString(jstring str);

  jstring encodeString(const String& str);

  uint_t getStringLength(jstring str);

  void* getArrayData(jarray array, uint_t &length, bool* isCopy = NULL);

  void releaseArrayData(jarray array, void* data);

  jbyteArray createByteArray(const byte_t* data, size_t length);

  jarray createObjectArray(jclass type, uint_t length,
                           jobject initialValue = NULL);

  bool isSameObject(jobject object1, jobject object2);

  bool isInstanceOf(jobject object, jclass clazz);

  bool isAssignableFrom(jclass clazz1, jclass clazz2);

  jclass getClassForObject(jobject object);

  jclass getSuperclass(jclass clazz);

  void enterMonitor(jobject object);

  void exitMonitor(jobject object);

  void registerNativeMethods(jclass clazz, const JavaNativeMethod methods[]);

  void unregisterNativeMethods(jclass clazz);

  void pushLocalFrame(uint_t capacity = 8);

  void popLocalFrame();

  inline bool isVerbose() const
  { return(_verbose); }

 private:

  void attach(JavaVirtualMachine* jvm, JNIEnv* env, bool verbose);
  void detach();
  inline bool isAttached() const
  { return(_env != NULL); }

  inline JNIEnv* getEnv() const
  { return(_env); }

  JavaVirtualMachine* _jvm;
  JNIEnv* _env;
  bool _verbose;
};

} // namespace ccxx

#endif // __ccxx_JavaContext_hxx