LocalRef<jobject> JniEnum::create(JNIEnv * env, jint value) const {
LocalRef<jobject> values(env, env->CallStaticObjectMethod(m_clazz.get(), m_staticmethValues));
jniExceptionCheck(env);
DJINNI_ASSERT(values, env);
LocalRef<jobject> result(env,
env->GetObjectArrayElement(static_cast<jobjectArray>(values.get()),
value));
jniExceptionCheck(env);
return result;
}
LocalRef<jobject> JniFlags::create(JNIEnv * env, unsigned flags, int bits) const {
auto j = LocalRef<jobject>(env, env->CallStaticObjectMethod(m_clazz.get(), m_methNoneOf, enumClass()));
jniExceptionCheck(env);
unsigned mask = 1;
for(int i = 0; i < bits; ++i, mask <<= 1) {
if((flags & mask) != 0) {
auto jf = create(env, static_cast<jint>(i));
jniExceptionCheck(env);
env->CallBooleanMethod(j, m_methAdd, jf.get());
jniExceptionCheck(env);
}
}
return j;
}
unsigned JniFlags::flags(JNIEnv * env, jobject obj) const {
DJINNI_ASSERT(obj && env->IsInstanceOf(obj, m_clazz.get()), env);
auto size = env->CallIntMethod(obj, m_methSize);
jniExceptionCheck(env);
unsigned flags = 0;
auto it = LocalRef<jobject>(env, env->CallObjectMethod(obj, m_methIterator));
jniExceptionCheck(env);
for(jint i = 0; i < size; ++i) {
auto jf = LocalRef<jobject>(env, env->CallObjectMethod(it, m_iterator.methNext));
jniExceptionCheck(env);
flags |= (1u << static_cast<unsigned>(ordinal(env, jf)));
}
return flags;
}
size_t JavaIdentityHash::operator() (jobject obj) const {
JNIEnv * const env = jniGetThreadEnv();
const SystemClassInfo & sys = JniClass<SystemClassInfo>::get();
jint res = env->CallStaticIntMethod(sys.clazz.get(), sys.staticmethIdentityHashCode, obj);
jniExceptionCheck(env);
return res;
}
static jobject toJava(JNIEnv* jniEnv, CppType c) {
const auto & data = JniClass<Self>::get();
UnboxedJniType jni = Primitive::Unboxed::toJava(jniEnv, c);
jobject j = jniEnv->CallStaticObjectMethod(data.clazz.get(), data.method_box, jni);
jniExceptionCheck(jniEnv);
return j;
}
static LocalRef<jobject> fromCpp(JNIEnv* jniEnv, CppType c)
{
const auto& data = JniClass<DurationJniInfo>::get();
jlong nanos = std::chrono::duration_cast<std::chrono::duration<jlong, std::nano>>(c).count();
auto j = LocalRef<JniType>{jniEnv->CallStaticObjectMethod(data.clazz.get(), data.method_ofNanos, nanos)};
jniExceptionCheck(jniEnv);
return j;
}
GlobalRef<jclass> jniFindClass(const char * name) {
JNIEnv * env = jniGetThreadEnv();
GlobalRef<jclass> guard(env, env->FindClass(name));
jniExceptionCheck(env);
if (!guard) {
jniThrowAssertionError(env, __FILE__, __LINE__, "FindClass returned null");
}
return guard;
}
jfieldID jniGetFieldID(jclass clazz, const char * name, const char * sig) {
JNIEnv * env = jniGetThreadEnv();
jfieldID id = env->GetFieldID(clazz, name, sig);
jniExceptionCheck(env);
if (!id) {
jniThrowAssertionError(env, __FILE__, __LINE__, "GetFieldID returned null");
}
return id;
}
static CppType toCpp(JNIEnv* jniEnv, JniType j)
{
assert(j != nullptr);
const auto& data = JniClass<DurationJniInfo>::get();
assert(jniEnv->IsInstanceOf(j, data.clazz.get()));
jlong nanos = jniEnv->CallLongMethod(j, data.method_toNanos);
jniExceptionCheck(jniEnv);
return std::chrono::duration_cast<CppType>(std::chrono::duration<jlong, std::nano>{nanos});
}
jmethodID jniGetMethodID(jclass clazz, const char * name, const char * sig) {
JNIEnv * env = jniGetThreadEnv();
DJINNI_ASSERT(clazz, env);
DJINNI_ASSERT(name, env);
DJINNI_ASSERT(sig, env);
jmethodID id = env->GetMethodID(clazz, name, sig);
jniExceptionCheck(env);
if (!id) {
jniThrowAssertionError(env, __FILE__, __LINE__, "GetMethodID returned null");
}
return id;
}
bool JavaIdentityEquals::operator() (jobject obj1, jobject obj2) const {
JNIEnv * const env = jniGetThreadEnv();
const bool res = env->IsSameObject(obj1, obj2);
jniExceptionCheck(env);
return res;
}
inline
jint jniUnboxMethodCall<jint>(JNIEnv* jniEnv, jmethodID method, jobject thiz) {
jint ret = jniEnv->CallIntMethod(thiz, method);
jniExceptionCheck(jniEnv);
return ret;
}
inline
jbyte jniUnboxMethodCall<jbyte>(JNIEnv* jniEnv, jmethodID method, jobject thiz) {
jbyte ret = jniEnv->CallByteMethod(thiz, method);
jniExceptionCheck(jniEnv);
return ret;
}
inline
jboolean jniUnboxMethodCall<jboolean>(JNIEnv* jniEnv, jmethodID method, jobject thiz) {
jboolean ret = jniEnv->CallBooleanMethod(thiz, method);
jniExceptionCheck(jniEnv);
return ret;
}
inline
jlong jniUnboxMethodCall<jlong>(JNIEnv* jniEnv, jmethodID method, jobject thiz) {
jlong ret = jniEnv->CallLongMethod(thiz, method);
jniExceptionCheck(jniEnv);
return ret;
}
jint JniEnum::ordinal(JNIEnv * env, jobject obj) const {
const jint res = env->CallIntMethod(obj, m_methOrdinal);
jniExceptionCheck(env);
return res;
}
inline
jdouble jniUnboxMethodCall<jdouble>(JNIEnv* jniEnv, jmethodID method, jobject thiz) {
jdouble ret = jniEnv->CallDoubleMethod(thiz, method);
jniExceptionCheck(jniEnv);
return ret;
}
