BeatmupJavaObjectPool Class Reference

Handles all Java binding-related static data. More...

#include <objectpool.h>

Public Member Functions
template<class Object >
Object *	getObject (JNIEnv *jenv, jlong handle)
	Retrieves native object by its handle. More...
template<class Object >
Object *	getObject (JNIEnv *jenv, jobject obj)
	Retrieves native object from its Java prototype. More...
void	nullifyHandle (JNIEnv *jenv, jobject obj)
	Sets a handle of a java object to null. More...
void	addJavaReference (JNIEnv *jenv, jobject jobj, const Beatmup::Object *bobj)
	Creates new global reference on a Java object to avoid garbage collecting. More...
void	removeJavaReference (JNIEnv *jenv, const Beatmup::Object *bobj)
	Removes a Java reference. More...
void	removeAllJavaReferences (JNIEnv *jenv, const Beatmup::Object *bobj)
	Removes all Java references to depending objects. More...
jobject	getJavaReference (const Beatmup::Object *bobj) const
	Returns a reference to the Java object which a given object depends on. More...
	BeatmupJavaObjectPool ()

Static Public Member Functions
static void	throwToJava (JNIEnv *jenv, const char *exceptionClass, const char *message)
	Throws a specific exception. More...
static void	throwToJava (JNIEnv *jenv, const char *message)
	Throws a general exception. More...
static void	rethrowToJava (JNIEnv *jenv, std::exception &ex)
	Rethrows a core-caused exception. More...

Public Attributes
JavaFactory	factory
JNIEnv *	env
jfieldID	handleFieldId

Static Public Attributes
static const jlong	INVALID_HANDLE = std::numeric_limits<jlong>::min()

Private Member Functions
bool	queryJavaContext (JNIEnv *newEnv)
	Java context check. More...

Private Attributes
std::multimap< const Beatmup::Object *, jobject >	javaRefs
	Java global references representing dependencies of internal objects on external Java objects. More...
struct {
JNIEnv *   env
jfieldID   handleFieldId
}	javaContext
std::mutex	access
	structure access control More...

Detailed Description

Handles all Java binding-related static data.

Definition at line 34 of file objectpool.h.

Constructor & Destructor Documentation

BeatmupJavaObjectPool()

BeatmupJavaObjectPool::BeatmupJavaObjectPool ( )

inline

Definition at line 148 of file objectpool.h.

                            {
        javaContext.env = NULL;
    }

Member Function Documentation

queryJavaContext()

bool BeatmupJavaObjectPool::queryJavaContext ( JNIEnv *  newEnv )

inlineprivate

Java context check.

Definition at line 47 of file objectpool.h.

                                                 {
        if (javaContext.env == newEnv)
            return true;
        std::lock_guard<std::mutex> lock(access);
        javaContext.env = newEnv;
        jclass cls = newEnv->FindClass("Beatmup/Object");
        javaContext.handleFieldId = newEnv->GetFieldID(cls, "handle", "J");
        newEnv->DeleteLocalRef(cls);
        return false;
    }

getObject() [1/2]

template<class Object >

Object* BeatmupJavaObjectPool::getObject ( JNIEnv *  jenv, jlong  handle  )

inline

Retrieves native object by its handle.

Definition at line 68 of file objectpool.h.

                                                                                {
#ifdef DEBUG_LOGGING
        LOG_I("Hitting object #%lld", handle);
#endif
        if (handle == INVALID_HANDLE)
            return nullptr;
        return static_cast<Object*>( (void*)handle );
    }

getObject() [2/2]

template<class Object >

Object* BeatmupJavaObjectPool::getObject ( JNIEnv *  jenv, jobject  obj  )

inline

Retrieves native object from its Java prototype.

Definition at line 80 of file objectpool.h.

                                                                               {
        queryJavaContext(jenv);
        if (!obj)
            return nullptr;
        jlong ptr = jenv->GetLongField(obj, javaContext.handleFieldId);
#ifdef DEBUG_LOGGING
        LOG_I("Hitting object #%lld from Java", ptr);
#endif
        if (ptr == INVALID_HANDLE)
            return nullptr;
        return static_cast<Object*>( (void*)jenv->GetLongField(obj, javaContext.handleFieldId) );
    }

nullifyHandle()

void BeatmupJavaObjectPool::nullifyHandle ( JNIEnv *  jenv, jobject  obj  )

inline

Sets a handle of a java object to null.

Definition at line 97 of file objectpool.h.

                                                  {
        queryJavaContext(jenv);
        jenv->SetLongField(obj, javaContext.handleFieldId, INVALID_HANDLE);
    }

addJavaReference()

void BeatmupJavaObjectPool::addJavaReference ( JNIEnv *  jenv, jobject  jobj, const Beatmup::Object *  bobj  )

inline

Creates new global reference on a Java object to avoid garbage collecting.

Definition at line 105 of file objectpool.h.

                                                                                 {
        std::lock_guard<std::mutex> lock(access);
        javaRefs.insert(std::make_pair(bobj, jenv->NewGlobalRef(jobj)));
    }

removeJavaReference()

void BeatmupJavaObjectPool::removeJavaReference ( JNIEnv *  jenv, const Beatmup::Object *  bobj  )

inline

Removes a Java reference.

Definition at line 114 of file objectpool.h.

                                                                      {
        std::lock_guard<std::mutex> lock(access);
        auto ref = javaRefs.find(bobj);
        if (ref != javaRefs.end()) {
            jenv->DeleteGlobalRef(ref->second);
            javaRefs.erase(ref);
        }
    }

removeAllJavaReferences()

void BeatmupJavaObjectPool::removeAllJavaReferences ( JNIEnv *  jenv, const Beatmup::Object *  bobj  )

inline

Removes all Java references to depending objects.

Definition at line 127 of file objectpool.h.

                                                                          {
        std::lock_guard<std::mutex> lock(access);
        while (true) {
            auto ref = javaRefs.find(bobj);
            if (ref == javaRefs.end())
                break;
            jenv->DeleteGlobalRef(ref->second);
            javaRefs.erase(ref);
        }
    }

getJavaReference()

jobject BeatmupJavaObjectPool::getJavaReference ( const Beatmup::Object *  bobj ) const

inline

Returns a reference to the Java object which a given object depends on.

Definition at line 142 of file objectpool.h.

                                                              {
        return javaRefs.find(bobj)->second;
    }

throwToJava() [1/2]

static void BeatmupJavaObjectPool::throwToJava ( JNIEnv *  jenv, const char *  exceptionClass, const char *  message  )

inlinestatic

Throws a specific exception.

Definition at line 156 of file objectpool.h.

                                                                                           {
        jclass exClass = jenv->FindClass(exceptionClass);
        jmethodID constructor = jenv->GetMethodID(exClass, "<init>", "(Ljava/lang/String;)V");
        jobject exception = jenv->NewObject(exClass, constructor, jenv->NewStringUTF(message));
        jenv->Throw((jthrowable) exception);
        jenv->DeleteLocalRef(exClass);
    }

throwToJava() [2/2]

static void BeatmupJavaObjectPool::throwToJava ( JNIEnv *  jenv, const char *  message  )

inlinestatic

Throws a general exception.

Definition at line 168 of file objectpool.h.

                                                               {
        throwToJava(jenv, "Beatmup/Exceptions/CoreException", message);
    }

rethrowToJava()

static void BeatmupJavaObjectPool::rethrowToJava ( JNIEnv *  jenv, std::exception &  ex  )

inlinestatic

Rethrows a core-caused exception.

Definition at line 176 of file objectpool.h.

                                                              {
        throwToJava(jenv, ex.what());
    }

Member Data Documentation

javaRefs

std::multimap<const Beatmup::Object*, jobject> BeatmupJavaObjectPool::javaRefs

private

Java global references representing dependencies of internal objects on external Java objects.

Definition at line 36 of file objectpool.h.

env

JNIEnv* BeatmupJavaObjectPool::env

Definition at line 39 of file objectpool.h.

handleFieldId

jfieldID BeatmupJavaObjectPool::handleFieldId

Definition at line 40 of file objectpool.h.

struct { ... } BeatmupJavaObjectPool::javaContext

access

std::mutex BeatmupJavaObjectPool::access

private

structure access control

Definition at line 58 of file objectpool.h.

INVALID_HANDLE

return BeatmupJavaObjectPool::INVALID_HANDLE = std::numeric_limits<jlong>::min()

static

Definition at line 61 of file objectpool.h.

factory

JavaFactory BeatmupJavaObjectPool::factory

Definition at line 63 of file objectpool.h.

---

The documentation for this class was generated from the following files:

• jni/objectpool.h
• jni/wrapper_core.cpp
• jni/wrapper_nnets.cpp