Google Git
Sign in
apache / nifi-minifi-cpp / 18f2a7b59bd0845d97d1432f8f4f7b24b27edf05 / . / thirdparty / rocksdb / java / rocksjni / portal.h
blob: ed671ce6e95eeaf5dc7923364978146de898bf6c [file] [log] [blame]
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
// This source code is licensed under both the GPLv2 (found in the
// COPYING file in the root directory) and Apache 2.0 License
// (found in the LICENSE.Apache file in the root directory).
// This file is designed for caching those frequently used IDs and provide
// efficient portal (i.e, a set of static functions) to access java code
// from c++.
#ifndef JAVA_ROCKSJNI_PORTAL_H_
#define JAVA_ROCKSJNI_PORTAL_H_
#include <jni.h>
#include <functional>
#include <iostream>
#include <limits>
#include <string>
#include <vector>
#include "rocksdb/db.h"
#include "rocksdb/filter_policy.h"
#include "rocksdb/status.h"
#include "rocksdb/utilities/backupable_db.h"
#include "rocksdb/utilities/write_batch_with_index.h"
#include "rocksjni/comparatorjnicallback.h"
#include "rocksjni/loggerjnicallback.h"
#include "rocksjni/writebatchhandlerjnicallback.h"
// Remove macro on windows
#ifdef DELETE
#undef DELETE
#endif
namespace rocksdb {
// Detect if jlong overflows size_t
inline Status check_if_jlong_fits_size_t(const jlong& jvalue) {
Status s = Status::OK();
if (static_cast<uint64_t>(jvalue) > std::numeric_limits<size_t>::max()) {
s = Status::InvalidArgument(Slice("jlong overflows 32 bit value."));
}
return s;
}
class JavaClass {
public:
/**
* Gets and initializes a Java Class
*
* @param env A pointer to the Java environment
* @param jclazz_name The fully qualified JNI name of the Java Class
* e.g. "java/lang/String"
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env, const char* jclazz_name) {
jclass jclazz = env->FindClass(jclazz_name);
assert(jclazz != nullptr);
return jclazz;
}
};
// Native class template
template<class PTR, class DERIVED> class RocksDBNativeClass : public JavaClass {
};
// Native class template for sub-classes of RocksMutableObject
template<class PTR, class DERIVED> class NativeRocksMutableObject
: public RocksDBNativeClass<PTR, DERIVED> {
public:
/**
* Gets the Java Method ID for the
* RocksMutableObject#setNativeHandle(long, boolean) method
*
* @param env A pointer to the Java environment
* @return The Java Method ID or nullptr the RocksMutableObject class cannot
* be accessed, or if one of the NoSuchMethodError,
* ExceptionInInitializerError or OutOfMemoryError exceptions is thrown
*/
static jmethodID getSetNativeHandleMethod(JNIEnv* env) {
static jclass jclazz = DERIVED::getJClass(env);
if(jclazz == nullptr) {
return nullptr;
}
static jmethodID mid = env->GetMethodID(
jclazz, "setNativeHandle", "(JZ)V");
assert(mid != nullptr);
return mid;
}
/**
* Sets the C++ object pointer handle in the Java object
*
* @param env A pointer to the Java environment
* @param jobj The Java object on which to set the pointer handle
* @param ptr The C++ object pointer
* @param java_owns_handle JNI_TRUE if ownership of the C++ object is
* managed by the Java object
*
* @return true if a Java exception is pending, false otherwise
*/
static bool setHandle(JNIEnv* env, jobject jobj, PTR ptr,
jboolean java_owns_handle) {
assert(jobj != nullptr);
static jmethodID mid = getSetNativeHandleMethod(env);
if(mid == nullptr) {
return true; // signal exception
}
env->CallVoidMethod(jobj, mid, reinterpret_cast<jlong>(ptr), java_owns_handle);
if(env->ExceptionCheck()) {
return true; // signal exception
}
return false;
}
};
// Java Exception template
template<class DERIVED> class JavaException : public JavaClass {
public:
/**
* Create and throw a java exception with the provided message
*
* @param env A pointer to the Java environment
* @param msg The message for the exception
*
* @return true if an exception was thrown, false otherwise
*/
static bool ThrowNew(JNIEnv* env, const std::string& msg) {
jclass jclazz = DERIVED::getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
std::cerr << "JavaException::ThrowNew - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
const jint rs = env->ThrowNew(jclazz, msg.c_str());
if(rs != JNI_OK) {
// exception could not be thrown
std::cerr << "JavaException::ThrowNew - Fatal: could not throw exception!" << std::endl;
return env->ExceptionCheck();
}
return true;
}
};
// The portal class for org.rocksdb.RocksDB
class RocksDBJni : public RocksDBNativeClass<rocksdb::DB*, RocksDBJni> {
public:
/**
* Get the Java Class org.rocksdb.RocksDB
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/RocksDB");
}
};
// The portal class for org.rocksdb.Status
class StatusJni : public RocksDBNativeClass<rocksdb::Status*, StatusJni> {
public:
/**
* Get the Java Class org.rocksdb.Status
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/Status");
}
/**
* Create a new Java org.rocksdb.Status object with the same properties as
* the provided C++ rocksdb::Status object
*
* @param env A pointer to the Java environment
* @param status The rocksdb::Status object
*
* @return A reference to a Java org.rocksdb.Status object, or nullptr
* if an an exception occurs
*/
static jobject construct(JNIEnv* env, const Status& status) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid =
env->GetMethodID(jclazz, "<init>", "(BBLjava/lang/String;)V");
if(mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
// convert the Status state for Java
jstring jstate = nullptr;
if (status.getState() != nullptr) {
const char* const state = status.getState();
jstate = env->NewStringUTF(state);
if(env->ExceptionCheck()) {
if(jstate != nullptr) {
env->DeleteLocalRef(jstate);
}
return nullptr;
}
}
jobject jstatus =
env->NewObject(jclazz, mid, toJavaStatusCode(status.code()),
toJavaStatusSubCode(status.subcode()), jstate);
if(env->ExceptionCheck()) {
// exception occurred
if(jstate != nullptr) {
env->DeleteLocalRef(jstate);
}
return nullptr;
}
if(jstate != nullptr) {
env->DeleteLocalRef(jstate);
}
return jstatus;
}
// Returns the equivalent org.rocksdb.Status.Code for the provided
// C++ rocksdb::Status::Code enum
static jbyte toJavaStatusCode(const rocksdb::Status::Code& code) {
switch (code) {
case rocksdb::Status::Code::kOk:
return 0x0;
case rocksdb::Status::Code::kNotFound:
return 0x1;
case rocksdb::Status::Code::kCorruption:
return 0x2;
case rocksdb::Status::Code::kNotSupported:
return 0x3;
case rocksdb::Status::Code::kInvalidArgument:
return 0x4;
case rocksdb::Status::Code::kIOError:
return 0x5;
case rocksdb::Status::Code::kMergeInProgress:
return 0x6;
case rocksdb::Status::Code::kIncomplete:
return 0x7;
case rocksdb::Status::Code::kShutdownInProgress:
return 0x8;
case rocksdb::Status::Code::kTimedOut:
return 0x9;
case rocksdb::Status::Code::kAborted:
return 0xA;
case rocksdb::Status::Code::kBusy:
return 0xB;
case rocksdb::Status::Code::kExpired:
return 0xC;
case rocksdb::Status::Code::kTryAgain:
return 0xD;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent org.rocksdb.Status.SubCode for the provided
// C++ rocksdb::Status::SubCode enum
static jbyte toJavaStatusSubCode(const rocksdb::Status::SubCode& subCode) {
switch (subCode) {
case rocksdb::Status::SubCode::kNone:
return 0x0;
case rocksdb::Status::SubCode::kMutexTimeout:
return 0x1;
case rocksdb::Status::SubCode::kLockTimeout:
return 0x2;
case rocksdb::Status::SubCode::kLockLimit:
return 0x3;
case rocksdb::Status::SubCode::kMaxSubCode:
return 0x7E;
default:
return 0x7F; // undefined
}
}
};
// The portal class for org.rocksdb.RocksDBException
class RocksDBExceptionJni :
public JavaException<RocksDBExceptionJni> {
public:
/**
* Get the Java Class org.rocksdb.RocksDBException
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaException::getJClass(env, "org/rocksdb/RocksDBException");
}
/**
* Create and throw a Java RocksDBException with the provided message
*
* @param env A pointer to the Java environment
* @param msg The message for the exception
*
* @return true if an exception was thrown, false otherwise
*/
static bool ThrowNew(JNIEnv* env, const std::string& msg) {
return JavaException::ThrowNew(env, msg);
}
/**
* Create and throw a Java RocksDBException with the provided status
*
* If s.ok() == true, then this function will not throw any exception.
*
* @param env A pointer to the Java environment
* @param s The status for the exception
*
* @return true if an exception was thrown, false otherwise
*/
static bool ThrowNew(JNIEnv* env, const Status& s) {
assert(!s.ok());
if (s.ok()) {
return false;
}
// get the RocksDBException class
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
std::cerr << "RocksDBExceptionJni::ThrowNew/class - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
// get the constructor of org.rocksdb.RocksDBException
jmethodID mid =
env->GetMethodID(jclazz, "<init>", "(Lorg/rocksdb/Status;)V");
if(mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
std::cerr << "RocksDBExceptionJni::ThrowNew/cstr - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
// get the Java status object
jobject jstatus = StatusJni::construct(env, s);
if(jstatus == nullptr) {
// exception occcurred
std::cerr << "RocksDBExceptionJni::ThrowNew/StatusJni - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
// construct the RocksDBException
jthrowable rocksdb_exception = reinterpret_cast<jthrowable>(env->NewObject(jclazz, mid, jstatus));
if(env->ExceptionCheck()) {
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
std::cerr << "RocksDBExceptionJni::ThrowNew/NewObject - Error: unexpected exception!" << std::endl;
return true;
}
// throw the RocksDBException
const jint rs = env->Throw(rocksdb_exception);
if(rs != JNI_OK) {
// exception could not be thrown
std::cerr << "RocksDBExceptionJni::ThrowNew - Fatal: could not throw exception!" << std::endl;
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
return env->ExceptionCheck();
}
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
return true;
}
/**
* Create and throw a Java RocksDBException with the provided message
* and status
*
* If s.ok() == true, then this function will not throw any exception.
*
* @param env A pointer to the Java environment
* @param msg The message for the exception
* @param s The status for the exception
*
* @return true if an exception was thrown, false otherwise
*/
static bool ThrowNew(JNIEnv* env, const std::string& msg, const Status& s) {
assert(!s.ok());
if (s.ok()) {
return false;
}
// get the RocksDBException class
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
std::cerr << "RocksDBExceptionJni::ThrowNew/class - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
// get the constructor of org.rocksdb.RocksDBException
jmethodID mid =
env->GetMethodID(jclazz, "<init>", "(Ljava/lang/String;Lorg/rocksdb/Status;)V");
if(mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
std::cerr << "RocksDBExceptionJni::ThrowNew/cstr - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
jstring jmsg = env->NewStringUTF(msg.c_str());
if(jmsg == nullptr) {
// exception thrown: OutOfMemoryError
std::cerr << "RocksDBExceptionJni::ThrowNew/msg - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
// get the Java status object
jobject jstatus = StatusJni::construct(env, s);
if(jstatus == nullptr) {
// exception occcurred
std::cerr << "RocksDBExceptionJni::ThrowNew/StatusJni - Error: unexpected exception!" << std::endl;
if(jmsg != nullptr) {
env->DeleteLocalRef(jmsg);
}
return env->ExceptionCheck();
}
// construct the RocksDBException
jthrowable rocksdb_exception = reinterpret_cast<jthrowable>(env->NewObject(jclazz, mid, jmsg, jstatus));
if(env->ExceptionCheck()) {
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(jmsg != nullptr) {
env->DeleteLocalRef(jmsg);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
std::cerr << "RocksDBExceptionJni::ThrowNew/NewObject - Error: unexpected exception!" << std::endl;
return true;
}
// throw the RocksDBException
const jint rs = env->Throw(rocksdb_exception);
if(rs != JNI_OK) {
// exception could not be thrown
std::cerr << "RocksDBExceptionJni::ThrowNew - Fatal: could not throw exception!" << std::endl;
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(jmsg != nullptr) {
env->DeleteLocalRef(jmsg);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
return env->ExceptionCheck();
}
if(jstatus != nullptr) {
env->DeleteLocalRef(jstatus);
}
if(jmsg != nullptr) {
env->DeleteLocalRef(jmsg);
}
if(rocksdb_exception != nullptr) {
env->DeleteLocalRef(rocksdb_exception);
}
return true;
}
};
// The portal class for java.lang.IllegalArgumentException
class IllegalArgumentExceptionJni :
public JavaException<IllegalArgumentExceptionJni> {
public:
/**
* Get the Java Class java.lang.IllegalArgumentException
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaException::getJClass(env, "java/lang/IllegalArgumentException");
}
/**
* Create and throw a Java IllegalArgumentException with the provided status
*
* If s.ok() == true, then this function will not throw any exception.
*
* @param env A pointer to the Java environment
* @param s The status for the exception
*
* @return true if an exception was thrown, false otherwise
*/
static bool ThrowNew(JNIEnv* env, const Status& s) {
assert(!s.ok());
if (s.ok()) {
return false;
}
// get the IllegalArgumentException class
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
std::cerr << "IllegalArgumentExceptionJni::ThrowNew/class - Error: unexpected exception!" << std::endl;
return env->ExceptionCheck();
}
return JavaException::ThrowNew(env, s.ToString());
}
};
// The portal class for org.rocksdb.Options
class OptionsJni : public RocksDBNativeClass<
rocksdb::Options*, OptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.Options
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/Options");
}
};
// The portal class for org.rocksdb.DBOptions
class DBOptionsJni : public RocksDBNativeClass<
rocksdb::DBOptions*, DBOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.DBOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/DBOptions");
}
};
class ColumnFamilyDescriptorJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.ColumnFamilyDescriptor
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/ColumnFamilyDescriptor");
}
/**
* Get the Java Method: ColumnFamilyDescriptor#columnFamilyName
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getColumnFamilyNameMethod(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "columnFamilyName", "()[B");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: ColumnFamilyDescriptor#columnFamilyOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getColumnFamilyOptionsMethod(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "columnFamilyOptions",
"()Lorg/rocksdb/ColumnFamilyOptions;");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.ColumnFamilyOptions
class ColumnFamilyOptionsJni : public RocksDBNativeClass<
rocksdb::ColumnFamilyOptions*, ColumnFamilyOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.ColumnFamilyOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/ColumnFamilyOptions");
}
};
// The portal class for org.rocksdb.WriteOptions
class WriteOptionsJni : public RocksDBNativeClass<
rocksdb::WriteOptions*, WriteOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.WriteOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/WriteOptions");
}
};
// The portal class for org.rocksdb.ReadOptions
class ReadOptionsJni : public RocksDBNativeClass<
rocksdb::ReadOptions*, ReadOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.ReadOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/ReadOptions");
}
};
// The portal class for org.rocksdb.WriteBatch
class WriteBatchJni : public RocksDBNativeClass<
rocksdb::WriteBatch*, WriteBatchJni> {
public:
/**
* Get the Java Class org.rocksdb.WriteBatch
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/WriteBatch");
}
};
// The portal class for org.rocksdb.WriteBatch.Handler
class WriteBatchHandlerJni : public RocksDBNativeClass<
const rocksdb::WriteBatchHandlerJniCallback*,
WriteBatchHandlerJni> {
public:
/**
* Get the Java Class org.rocksdb.WriteBatch.Handler
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/WriteBatch$Handler");
}
/**
* Get the Java Method: WriteBatch.Handler#put
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getPutMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "put", "([B[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#merge
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getMergeMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "merge", "([B[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#delete
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getDeleteMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "delete", "([B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#deleteRange
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getDeleteRangeMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if (jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "deleteRange", "([B[B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#logData
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getLogDataMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "logData", "([B)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: WriteBatch.Handler#shouldContinue
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getContinueMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "shouldContinue", "()Z");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.WriteBatchWithIndex
class WriteBatchWithIndexJni : public RocksDBNativeClass<
rocksdb::WriteBatchWithIndex*, WriteBatchWithIndexJni> {
public:
/**
* Get the Java Class org.rocksdb.WriteBatchWithIndex
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/WriteBatchWithIndex");
}
};
// The portal class for org.rocksdb.HistogramData
class HistogramDataJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.HistogramData
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/HistogramData");
}
/**
* Get the Java Method: HistogramData constructor
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getConstructorMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "<init>", "(DDDDD)V");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.BackupableDBOptions
class BackupableDBOptionsJni : public RocksDBNativeClass<
rocksdb::BackupableDBOptions*, BackupableDBOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.BackupableDBOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/BackupableDBOptions");
}
};
// The portal class for org.rocksdb.BackupEngine
class BackupEngineJni : public RocksDBNativeClass<
rocksdb::BackupEngine*, BackupEngineJni> {
public:
/**
* Get the Java Class org.rocksdb.BackupableEngine
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/BackupEngine");
}
};
// The portal class for org.rocksdb.RocksIterator
class IteratorJni : public RocksDBNativeClass<
rocksdb::Iterator*, IteratorJni> {
public:
/**
* Get the Java Class org.rocksdb.RocksIterator
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/RocksIterator");
}
};
// The portal class for org.rocksdb.Filter
class FilterJni : public RocksDBNativeClass<
std::shared_ptr<rocksdb::FilterPolicy>*, FilterJni> {
public:
/**
* Get the Java Class org.rocksdb.Filter
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/Filter");
}
};
// The portal class for org.rocksdb.ColumnFamilyHandle
class ColumnFamilyHandleJni : public RocksDBNativeClass<
rocksdb::ColumnFamilyHandle*, ColumnFamilyHandleJni> {
public:
/**
* Get the Java Class org.rocksdb.ColumnFamilyHandle
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/ColumnFamilyHandle");
}
};
// The portal class for org.rocksdb.FlushOptions
class FlushOptionsJni : public RocksDBNativeClass<
rocksdb::FlushOptions*, FlushOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.FlushOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/FlushOptions");
}
};
// The portal class for org.rocksdb.ComparatorOptions
class ComparatorOptionsJni : public RocksDBNativeClass<
rocksdb::ComparatorJniCallbackOptions*, ComparatorOptionsJni> {
public:
/**
* Get the Java Class org.rocksdb.ComparatorOptions
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/ComparatorOptions");
}
};
// The portal class for org.rocksdb.AbstractComparator
class AbstractComparatorJni : public RocksDBNativeClass<
const rocksdb::BaseComparatorJniCallback*,
AbstractComparatorJni> {
public:
/**
* Get the Java Class org.rocksdb.AbstractComparator
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env,
"org/rocksdb/AbstractComparator");
}
/**
* Get the Java Method: Comparator#name
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getNameMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "name", "()Ljava/lang/String;");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: Comparator#compare
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getCompareMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "compare",
"(Lorg/rocksdb/AbstractSlice;Lorg/rocksdb/AbstractSlice;)I");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: Comparator#findShortestSeparator
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getFindShortestSeparatorMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "findShortestSeparator",
"(Ljava/lang/String;Lorg/rocksdb/AbstractSlice;)Ljava/lang/String;");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: Comparator#findShortSuccessor
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getFindShortSuccessorMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "findShortSuccessor",
"(Ljava/lang/String;)Ljava/lang/String;");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.AbstractSlice
class AbstractSliceJni : public NativeRocksMutableObject<
const rocksdb::Slice*, AbstractSliceJni> {
public:
/**
* Get the Java Class org.rocksdb.AbstractSlice
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/AbstractSlice");
}
};
// The portal class for org.rocksdb.Slice
class SliceJni : public NativeRocksMutableObject<
const rocksdb::Slice*, AbstractSliceJni> {
public:
/**
* Get the Java Class org.rocksdb.Slice
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/Slice");
}
/**
* Constructs a Slice object
*
* @param env A pointer to the Java environment
*
* @return A reference to a Java Slice object, or a nullptr if an
* exception occurs
*/
static jobject construct0(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "<init>", "()V");
if(mid == nullptr) {
// exception occurred accessing method
return nullptr;
}
jobject jslice = env->NewObject(jclazz, mid);
if(env->ExceptionCheck()) {
return nullptr;
}
return jslice;
}
};
// The portal class for org.rocksdb.DirectSlice
class DirectSliceJni : public NativeRocksMutableObject<
const rocksdb::Slice*, AbstractSliceJni> {
public:
/**
* Get the Java Class org.rocksdb.DirectSlice
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/DirectSlice");
}
/**
* Constructs a DirectSlice object
*
* @param env A pointer to the Java environment
*
* @return A reference to a Java DirectSlice object, or a nullptr if an
* exception occurs
*/
static jobject construct0(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "<init>", "()V");
if(mid == nullptr) {
// exception occurred accessing method
return nullptr;
}
jobject jdirect_slice = env->NewObject(jclazz, mid);
if(env->ExceptionCheck()) {
return nullptr;
}
return jdirect_slice;
}
};
// The portal class for java.util.List
class ListJni : public JavaClass {
public:
/**
* Get the Java Class java.util.List
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getListClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/util/List");
}
/**
* Get the Java Class java.util.ArrayList
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getArrayListClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/util/ArrayList");
}
/**
* Get the Java Class java.util.Iterator
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getIteratorClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/util/Iterator");
}
/**
* Get the Java Method: List#iterator
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getIteratorMethod(JNIEnv* env) {
jclass jlist_clazz = getListClass(env);
if(jlist_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jlist_clazz, "iterator", "()Ljava/util/Iterator;");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: Iterator#hasNext
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getHasNextMethod(JNIEnv* env) {
jclass jiterator_clazz = getIteratorClass(env);
if(jiterator_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jiterator_clazz, "hasNext", "()Z");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: Iterator#next
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getNextMethod(JNIEnv* env) {
jclass jiterator_clazz = getIteratorClass(env);
if(jiterator_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jiterator_clazz, "next", "()Ljava/lang/Object;");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: ArrayList constructor
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getArrayListConstructorMethodId(JNIEnv* env) {
jclass jarray_list_clazz = getArrayListClass(env);
if(jarray_list_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jarray_list_clazz, "<init>", "(I)V");
assert(mid != nullptr);
return mid;
}
/**
* Get the Java Method: List#add
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getListAddMethodId(JNIEnv* env) {
jclass jlist_clazz = getListClass(env);
if(jlist_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jlist_clazz, "add", "(Ljava/lang/Object;)Z");
assert(mid != nullptr);
return mid;
}
};
// The portal class for java.lang.Byte
class ByteJni : public JavaClass {
public:
/**
* Get the Java Class java.lang.Byte
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/lang/Byte");
}
/**
* Get the Java Class byte[]
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getArrayJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "[B");
}
/**
* Creates a new 2-dimensional Java Byte Array byte[][]
*
* @param env A pointer to the Java environment
* @param len The size of the first dimension
*
* @return A reference to the Java byte[][] or nullptr if an exception occurs
*/
static jobjectArray new2dByteArray(JNIEnv* env, const jsize len) {
jclass clazz = getArrayJClass(env);
if(clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
return env->NewObjectArray(len, clazz, nullptr);
}
/**
* Get the Java Method: Byte#byteValue
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getByteValueMethod(JNIEnv* env) {
jclass clazz = getJClass(env);
if(clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(clazz, "byteValue", "()B");
assert(mid != nullptr);
return mid;
}
};
// The portal class for java.lang.StringBuilder
class StringBuilderJni : public JavaClass {
public:
/**
* Get the Java Class java.lang.StringBuilder
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "java/lang/StringBuilder");
}
/**
* Get the Java Method: StringBuilder#append
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getListAddMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "append",
"(Ljava/lang/String;)Ljava/lang/StringBuilder;");
assert(mid != nullptr);
return mid;
}
/**
* Appends a C-style string to a StringBuilder
*
* @param env A pointer to the Java environment
* @param jstring_builder Reference to a java.lang.StringBuilder
* @param c_str A C-style string to append to the StringBuilder
*
* @return A reference to the updated StringBuilder, or a nullptr if
* an exception occurs
*/
static jobject append(JNIEnv* env, jobject jstring_builder,
const char* c_str) {
jmethodID mid = getListAddMethodId(env);
if(mid == nullptr) {
// exception occurred accessing class or method
return nullptr;
}
jstring new_value_str = env->NewStringUTF(c_str);
if(new_value_str == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
jobject jresult_string_builder =
env->CallObjectMethod(jstring_builder, mid, new_value_str);
if(env->ExceptionCheck()) {
// exception occurred
env->DeleteLocalRef(new_value_str);
return nullptr;
}
return jresult_string_builder;
}
};
// The portal class for org.rocksdb.BackupInfo
class BackupInfoJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.BackupInfo
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/BackupInfo");
}
/**
* Constructs a BackupInfo object
*
* @param env A pointer to the Java environment
* @param backup_id id of the backup
* @param timestamp timestamp of the backup
* @param size size of the backup
* @param number_files number of files related to the backup
*
* @return A reference to a Java BackupInfo object, or a nullptr if an
* exception occurs
*/
static jobject construct0(JNIEnv* env, uint32_t backup_id, int64_t timestamp,
uint64_t size, uint32_t number_files) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid = env->GetMethodID(jclazz, "<init>", "(IJJI)V");
if(mid == nullptr) {
// exception occurred accessing method
return nullptr;
}
jobject jbackup_info =
env->NewObject(jclazz, mid, backup_id, timestamp, size, number_files);
if(env->ExceptionCheck()) {
return nullptr;
}
return jbackup_info;
}
};
class BackupInfoListJni {
public:
/**
* Converts a C++ std::vector<BackupInfo> object to
* a Java ArrayList<org.rocksdb.BackupInfo> object
*
* @param env A pointer to the Java environment
* @param backup_infos A vector of BackupInfo
*
* @return Either a reference to a Java ArrayList object, or a nullptr
* if an exception occurs
*/
static jobject getBackupInfo(JNIEnv* env,
std::vector<BackupInfo> backup_infos) {
jclass jarray_list_clazz = rocksdb::ListJni::getArrayListClass(env);
if(jarray_list_clazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID cstr_mid = rocksdb::ListJni::getArrayListConstructorMethodId(env);
if(cstr_mid == nullptr) {
// exception occurred accessing method
return nullptr;
}
jmethodID add_mid = rocksdb::ListJni::getListAddMethodId(env);
if(add_mid == nullptr) {
// exception occurred accessing method
return nullptr;
}
// create java list
jobject jbackup_info_handle_list =
env->NewObject(jarray_list_clazz, cstr_mid, backup_infos.size());
if(env->ExceptionCheck()) {
// exception occurred constructing object
return nullptr;
}
// insert in java list
auto end = backup_infos.end();
for (auto it = backup_infos.begin(); it != end; ++it) {
auto backup_info = *it;
jobject obj = rocksdb::BackupInfoJni::construct0(env,
backup_info.backup_id,
backup_info.timestamp,
backup_info.size,
backup_info.number_files);
if(env->ExceptionCheck()) {
// exception occurred constructing object
if(obj != nullptr) {
env->DeleteLocalRef(obj);
}
if(jbackup_info_handle_list != nullptr) {
env->DeleteLocalRef(jbackup_info_handle_list);
}
return nullptr;
}
jboolean rs =
env->CallBooleanMethod(jbackup_info_handle_list, add_mid, obj);
if(env->ExceptionCheck() || rs == JNI_FALSE) {
// exception occurred calling method, or could not add
if(obj != nullptr) {
env->DeleteLocalRef(obj);
}
if(jbackup_info_handle_list != nullptr) {
env->DeleteLocalRef(jbackup_info_handle_list);
}
return nullptr;
}
}
return jbackup_info_handle_list;
}
};
// The portal class for org.rocksdb.WBWIRocksIterator
class WBWIRocksIteratorJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.WBWIRocksIterator
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/WBWIRocksIterator");
}
/**
* Get the Java Field: WBWIRocksIterator#entry
*
* @param env A pointer to the Java environment
*
* @return The Java Field ID or nullptr if the class or field id could not
* be retieved
*/
static jfieldID getWriteEntryField(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jfieldID fid =
env->GetFieldID(jclazz, "entry",
"Lorg/rocksdb/WBWIRocksIterator$WriteEntry;");
assert(fid != nullptr);
return fid;
}
/**
* Gets the value of the WBWIRocksIterator#entry
*
* @param env A pointer to the Java environment
* @param jwbwi_rocks_iterator A reference to a WBWIIterator
*
* @return A reference to a Java WBWIRocksIterator.WriteEntry object, or
* a nullptr if an exception occurs
*/
static jobject getWriteEntry(JNIEnv* env, jobject jwbwi_rocks_iterator) {
assert(jwbwi_rocks_iterator != nullptr);
jfieldID jwrite_entry_field = getWriteEntryField(env);
if(jwrite_entry_field == nullptr) {
// exception occurred accessing the field
return nullptr;
}
jobject jwe = env->GetObjectField(jwbwi_rocks_iterator, jwrite_entry_field);
assert(jwe != nullptr);
return jwe;
}
};
// The portal class for org.rocksdb.WBWIRocksIterator.WriteType
class WriteTypeJni : public JavaClass {
public:
/**
* Get the PUT enum field value of WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject PUT(JNIEnv* env) {
return getEnum(env, "PUT");
}
/**
* Get the MERGE enum field value of WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject MERGE(JNIEnv* env) {
return getEnum(env, "MERGE");
}
/**
* Get the DELETE enum field value of WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject DELETE(JNIEnv* env) {
return getEnum(env, "DELETE");
}
/**
* Get the LOG enum field value of WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject LOG(JNIEnv* env) {
return getEnum(env, "LOG");
}
private:
/**
* Get the Java Class org.rocksdb.WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/WBWIRocksIterator$WriteType");
}
/**
* Get an enum field of org.rocksdb.WBWIRocksIterator.WriteType
*
* @param env A pointer to the Java environment
* @param name The name of the enum field
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject getEnum(JNIEnv* env, const char name[]) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jfieldID jfid =
env->GetStaticFieldID(jclazz, name,
"Lorg/rocksdb/WBWIRocksIterator$WriteType;");
if(env->ExceptionCheck()) {
// exception occurred while getting field
return nullptr;
} else if(jfid == nullptr) {
return nullptr;
}
jobject jwrite_type = env->GetStaticObjectField(jclazz, jfid);
assert(jwrite_type != nullptr);
return jwrite_type;
}
};
// The portal class for org.rocksdb.WBWIRocksIterator.WriteEntry
class WriteEntryJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.WBWIRocksIterator.WriteEntry
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/WBWIRocksIterator$WriteEntry");
}
};
// The portal class for org.rocksdb.InfoLogLevel
class InfoLogLevelJni : public JavaClass {
public:
/**
* Get the DEBUG_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject DEBUG_LEVEL(JNIEnv* env) {
return getEnum(env, "DEBUG_LEVEL");
}
/**
* Get the INFO_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject INFO_LEVEL(JNIEnv* env) {
return getEnum(env, "INFO_LEVEL");
}
/**
* Get the WARN_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject WARN_LEVEL(JNIEnv* env) {
return getEnum(env, "WARN_LEVEL");
}
/**
* Get the ERROR_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject ERROR_LEVEL(JNIEnv* env) {
return getEnum(env, "ERROR_LEVEL");
}
/**
* Get the FATAL_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject FATAL_LEVEL(JNIEnv* env) {
return getEnum(env, "FATAL_LEVEL");
}
/**
* Get the HEADER_LEVEL enum field value of InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject HEADER_LEVEL(JNIEnv* env) {
return getEnum(env, "HEADER_LEVEL");
}
private:
/**
* Get the Java Class org.rocksdb.InfoLogLevel
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env, "org/rocksdb/InfoLogLevel");
}
/**
* Get an enum field of org.rocksdb.InfoLogLevel
*
* @param env A pointer to the Java environment
* @param name The name of the enum field
*
* @return A reference to the enum field value or a nullptr if
* the enum field value could not be retrieved
*/
static jobject getEnum(JNIEnv* env, const char name[]) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jfieldID jfid =
env->GetStaticFieldID(jclazz, name, "Lorg/rocksdb/InfoLogLevel;");
if(env->ExceptionCheck()) {
// exception occurred while getting field
return nullptr;
} else if(jfid == nullptr) {
return nullptr;
}
jobject jinfo_log_level = env->GetStaticObjectField(jclazz, jfid);
assert(jinfo_log_level != nullptr);
return jinfo_log_level;
}
};
// The portal class for org.rocksdb.Logger
class LoggerJni : public RocksDBNativeClass<
std::shared_ptr<rocksdb::LoggerJniCallback>*, LoggerJni> {
public:
/**
* Get the Java Class org/rocksdb/Logger
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return RocksDBNativeClass::getJClass(env, "org/rocksdb/Logger");
}
/**
* Get the Java Method: Logger#log
*
* @param env A pointer to the Java environment
*
* @return The Java Method ID or nullptr if the class or method id could not
* be retieved
*/
static jmethodID getLogMethodId(JNIEnv* env) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
static jmethodID mid =
env->GetMethodID(jclazz, "log",
"(Lorg/rocksdb/InfoLogLevel;Ljava/lang/String;)V");
assert(mid != nullptr);
return mid;
}
};
// The portal class for org.rocksdb.TransactionLogIterator.BatchResult
class BatchResultJni : public JavaClass {
public:
/**
* Get the Java Class org.rocksdb.TransactionLogIterator.BatchResult
*
* @param env A pointer to the Java environment
*
* @return The Java Class or nullptr if one of the
* ClassFormatError, ClassCircularityError, NoClassDefFoundError,
* OutOfMemoryError or ExceptionInInitializerError exceptions is thrown
*/
static jclass getJClass(JNIEnv* env) {
return JavaClass::getJClass(env,
"org/rocksdb/TransactionLogIterator$BatchResult");
}
/**
* Create a new Java org.rocksdb.TransactionLogIterator.BatchResult object
* with the same properties as the provided C++ rocksdb::BatchResult object
*
* @param env A pointer to the Java environment
* @param batch_result The rocksdb::BatchResult object
*
* @return A reference to a Java
* org.rocksdb.TransactionLogIterator.BatchResult object,
* or nullptr if an an exception occurs
*/
static jobject construct(JNIEnv* env,
rocksdb::BatchResult& batch_result) {
jclass jclazz = getJClass(env);
if(jclazz == nullptr) {
// exception occurred accessing class
return nullptr;
}
jmethodID mid = env->GetMethodID(
jclazz, "<init>", "(JJ)V");
if(mid == nullptr) {
// exception thrown: NoSuchMethodException or OutOfMemoryError
return nullptr;
}
jobject jbatch_result = env->NewObject(jclazz, mid,
batch_result.sequence, batch_result.writeBatchPtr.get());
if(jbatch_result == nullptr) {
// exception thrown: InstantiationException or OutOfMemoryError
return nullptr;
}
batch_result.writeBatchPtr.release();
return jbatch_result;
}
};
// The portal class for org.rocksdb.CompactionStopStyle
class CompactionStopStyleJni {
public:
// Returns the equivalent org.rocksdb.CompactionStopStyle for the provided
// C++ rocksdb::CompactionStopStyle enum
static jbyte toJavaCompactionStopStyle(
const rocksdb::CompactionStopStyle& compaction_stop_style) {
switch(compaction_stop_style) {
case rocksdb::CompactionStopStyle::kCompactionStopStyleSimilarSize:
return 0x0;
case rocksdb::CompactionStopStyle::kCompactionStopStyleTotalSize:
return 0x1;
default:
return 0x7F; // undefined
}
}
// Returns the equivalent C++ rocksdb::CompactionStopStyle enum for the
// provided Java org.rocksdb.CompactionStopStyle
static rocksdb::CompactionStopStyle toCppCompactionStopStyle(
jbyte jcompaction_stop_style) {
switch(jcompaction_stop_style) {
case 0x0:
return rocksdb::CompactionStopStyle::kCompactionStopStyleSimilarSize;
case 0x1:
return rocksdb::CompactionStopStyle::kCompactionStopStyleTotalSize;
default:
// undefined/default
return rocksdb::CompactionStopStyle::kCompactionStopStyleSimilarSize;
}
}
};
// The portal class for org.rocksdb.CompressionType
class CompressionTypeJni {
public:
// Returns the equivalent org.rocksdb.CompressionType for the provided
// C++ rocksdb::CompressionType enum
static jbyte toJavaCompressionType(
const rocksdb::CompressionType& compression_type) {
switch(compression_type) {
case rocksdb::CompressionType::kNoCompression:
return 0x0;
case rocksdb::CompressionType::kSnappyCompression:
return 0x1;
case rocksdb::CompressionType::kZlibCompression:
return 0x2;
case rocksdb::CompressionType::kBZip2Compression:
return 0x3;
case rocksdb::CompressionType::kLZ4Compression:
return 0x4;
case rocksdb::CompressionType::kLZ4HCCompression:
return 0x5;
case rocksdb::CompressionType::kXpressCompression:
return 0x6;
case rocksdb::CompressionType::kZSTD:
return 0x7;
case rocksdb::CompressionType::kDisableCompressionOption:
default:
return 0x7F;
}
}
// Returns the equivalent C++ rocksdb::CompressionType enum for the
// provided Java org.rocksdb.CompressionType
static rocksdb::CompressionType toCppCompressionType(
jbyte jcompression_type) {
switch(jcompression_type) {
case 0x0:
return rocksdb::CompressionType::kNoCompression;
case 0x1:
return rocksdb::CompressionType::kSnappyCompression;
case 0x2:
return rocksdb::CompressionType::kZlibCompression;
case 0x3:
return rocksdb::CompressionType::kBZip2Compression;
case 0x4:
return rocksdb::CompressionType::kLZ4Compression;
case 0x5:
return rocksdb::CompressionType::kLZ4HCCompression;
case 0x6:
return rocksdb::CompressionType::kXpressCompression;
case 0x7:
return rocksdb::CompressionType::kZSTD;
case 0x7F:
default:
return rocksdb::CompressionType::kDisableCompressionOption;
}
}
};
// The portal class for org.rocksdb.CompactionPriority
class CompactionPriorityJni {
public:
// Returns the equivalent org.rocksdb.CompactionPriority for the provided
// C++ rocksdb::CompactionPri enum
static jbyte toJavaCompactionPriority(
const rocksdb::CompactionPri& compaction_priority) {
switch(compaction_priority) {
case rocksdb::CompactionPri::kByCompensatedSize:
return 0x0;
case rocksdb::CompactionPri::kOldestLargestSeqFirst:
return 0x1;
case rocksdb::CompactionPri::kOldestSmallestSeqFirst:
return 0x2;
case rocksdb::CompactionPri::kMinOverlappingRatio:
return 0x3;
default:
return 0x0; // undefined
}
}
// Returns the equivalent C++ rocksdb::CompactionPri enum for the
// provided Java org.rocksdb.CompactionPriority
static rocksdb::CompactionPri toCppCompactionPriority(
jbyte jcompaction_priority) {
switch(jcompaction_priority) {
case 0x0:
return rocksdb::CompactionPri::kByCompensatedSize;
case 0x1:
return rocksdb::CompactionPri::kOldestLargestSeqFirst;
case 0x2:
return rocksdb::CompactionPri::kOldestSmallestSeqFirst;
case 0x3:
return rocksdb::CompactionPri::kMinOverlappingRatio;
default:
// undefined/default
return rocksdb::CompactionPri::kByCompensatedSize;
}
}
};
// The portal class for org.rocksdb.AccessHint
class AccessHintJni {
public:
// Returns the equivalent org.rocksdb.AccessHint for the provided
// C++ rocksdb::DBOptions::AccessHint enum
static jbyte toJavaAccessHint(
const rocksdb::DBOptions::AccessHint& access_hint) {
switch(access_hint) {
case rocksdb::DBOptions::AccessHint::NONE:
return 0x0;
case rocksdb::DBOptions::AccessHint::NORMAL:
return 0x1;
case rocksdb::DBOptions::AccessHint::SEQUENTIAL:
return 0x2;
case rocksdb::DBOptions::AccessHint::WILLNEED:
return 0x3;
default:
// undefined/default
return 0x1;
}
}
// Returns the equivalent C++ rocksdb::DBOptions::AccessHint enum for the
// provided Java org.rocksdb.AccessHint
static rocksdb::DBOptions::AccessHint toCppAccessHint(jbyte jaccess_hint) {
switch(jaccess_hint) {
case 0x0:
return rocksdb::DBOptions::AccessHint::NONE;
case 0x1:
return rocksdb::DBOptions::AccessHint::NORMAL;
case 0x2:
return rocksdb::DBOptions::AccessHint::SEQUENTIAL;
case 0x3:
return rocksdb::DBOptions::AccessHint::WILLNEED;
default:
// undefined/default
return rocksdb::DBOptions::AccessHint::NORMAL;
}
}
};
// The portal class for org.rocksdb.WALRecoveryMode
class WALRecoveryModeJni {
public:
// Returns the equivalent org.rocksdb.WALRecoveryMode for the provided
// C++ rocksdb::WALRecoveryMode enum
static jbyte toJavaWALRecoveryMode(
const rocksdb::WALRecoveryMode& wal_recovery_mode) {
switch(wal_recovery_mode) {
case rocksdb::WALRecoveryMode::kTolerateCorruptedTailRecords:
return 0x0;
case rocksdb::WALRecoveryMode::kAbsoluteConsistency:
return 0x1;
case rocksdb::WALRecoveryMode::kPointInTimeRecovery:
return 0x2;
case rocksdb::WALRecoveryMode::kSkipAnyCorruptedRecords:
return 0x3;
default:
// undefined/default
return 0x2;
}
}
// Returns the equivalent C++ rocksdb::WALRecoveryMode enum for the
// provided Java org.rocksdb.WALRecoveryMode
static rocksdb::WALRecoveryMode toCppWALRecoveryMode(jbyte jwal_recovery_mode) {
switch(jwal_recovery_mode) {
case 0x0:
return rocksdb::WALRecoveryMode::kTolerateCorruptedTailRecords;
case 0x1:
return rocksdb::WALRecoveryMode::kAbsoluteConsistency;
case 0x2:
return rocksdb::WALRecoveryMode::kPointInTimeRecovery;
case 0x3:
return rocksdb::WALRecoveryMode::kSkipAnyCorruptedRecords;
default:
// undefined/default
return rocksdb::WALRecoveryMode::kPointInTimeRecovery;
}
}
};
// The portal class for org.rocksdb.TickerType
class TickerTypeJni {
public:
// Returns the equivalent org.rocksdb.TickerType for the provided
// C++ rocksdb::Tickers enum
static jbyte toJavaTickerType(
const rocksdb::Tickers& tickers) {
switch(tickers) {
case rocksdb::Tickers::BLOCK_CACHE_MISS:
return 0x0;
case rocksdb::Tickers::BLOCK_CACHE_HIT:
return 0x1;
case rocksdb::Tickers::BLOCK_CACHE_ADD:
return 0x2;
case rocksdb::Tickers::BLOCK_CACHE_ADD_FAILURES:
return 0x3;
case rocksdb::Tickers::BLOCK_CACHE_INDEX_MISS:
return 0x4;
case rocksdb::Tickers::BLOCK_CACHE_INDEX_HIT:
return 0x5;
case rocksdb::Tickers::BLOCK_CACHE_INDEX_ADD:
return 0x6;
case rocksdb::Tickers::BLOCK_CACHE_INDEX_BYTES_INSERT:
return 0x7;
case rocksdb::Tickers::BLOCK_CACHE_INDEX_BYTES_EVICT:
return 0x8;
case rocksdb::Tickers::BLOCK_CACHE_FILTER_MISS:
return 0x9;
case rocksdb::Tickers::BLOCK_CACHE_FILTER_HIT:
return 0xA;
case rocksdb::Tickers::BLOCK_CACHE_FILTER_ADD:
return 0xB;
case rocksdb::Tickers::BLOCK_CACHE_FILTER_BYTES_INSERT:
return 0xC;
case rocksdb::Tickers::BLOCK_CACHE_FILTER_BYTES_EVICT:
return 0xD;
case rocksdb::Tickers::BLOCK_CACHE_DATA_MISS:
return 0xE;
case rocksdb::Tickers::BLOCK_CACHE_DATA_HIT:
return 0xF;
case rocksdb::Tickers::BLOCK_CACHE_DATA_ADD:
return 0x10;
case rocksdb::Tickers::BLOCK_CACHE_DATA_BYTES_INSERT:
return 0x11;
case rocksdb::Tickers::BLOCK_CACHE_BYTES_READ:
return 0x12;
case rocksdb::Tickers::BLOCK_CACHE_BYTES_WRITE:
return 0x13;
case rocksdb::Tickers::BLOOM_FILTER_USEFUL:
return 0x14;
case rocksdb::Tickers::PERSISTENT_CACHE_HIT:
return 0x15;
case rocksdb::Tickers::PERSISTENT_CACHE_MISS:
return 0x16;
case rocksdb::Tickers::SIM_BLOCK_CACHE_HIT:
return 0x17;
case rocksdb::Tickers::SIM_BLOCK_CACHE_MISS:
return 0x18;
case rocksdb::Tickers::MEMTABLE_HIT:
return 0x19;
case rocksdb::Tickers::MEMTABLE_MISS:
return 0x1A;
case rocksdb::Tickers::GET_HIT_L0:
return 0x1B;
case rocksdb::Tickers::GET_HIT_L1:
return 0x1C;
case rocksdb::Tickers::GET_HIT_L2_AND_UP:
return 0x1D;
case rocksdb::Tickers::COMPACTION_KEY_DROP_NEWER_ENTRY:
return 0x1E;
case rocksdb::Tickers::COMPACTION_KEY_DROP_OBSOLETE:
return 0x1F;
case rocksdb::Tickers::COMPACTION_KEY_DROP_RANGE_DEL:
return 0x20;
case rocksdb::Tickers::COMPACTION_KEY_DROP_USER:
return 0x21;
case rocksdb::Tickers::COMPACTION_RANGE_DEL_DROP_OBSOLETE:
return 0x22;
case rocksdb::Tickers::NUMBER_KEYS_WRITTEN:
return 0x23;
case rocksdb::Tickers::NUMBER_KEYS_READ:
return 0x24;
case rocksdb::Tickers::NUMBER_KEYS_UPDATED:
return 0x25;
case rocksdb::Tickers::BYTES_WRITTEN:
return 0x26;
case rocksdb::Tickers::BYTES_READ:
return 0x27;
case rocksdb::Tickers::NUMBER_DB_SEEK:
return 0x28;
case rocksdb::Tickers::NUMBER_DB_NEXT:
return 0x29;
case rocksdb::Tickers::NUMBER_DB_PREV:
return 0x2A;
case rocksdb::Tickers::NUMBER_DB_SEEK_FOUND:
return 0x2B;
case rocksdb::Tickers::NUMBER_DB_NEXT_FOUND:
return 0x2C;
case rocksdb::Tickers::NUMBER_DB_PREV_FOUND:
return 0x2D;
case rocksdb::Tickers::ITER_BYTES_READ:
return 0x2E;
case rocksdb::Tickers::NO_FILE_CLOSES:
return 0x2F;
case rocksdb::Tickers::NO_FILE_OPENS:
return 0x30;
case rocksdb::Tickers::NO_FILE_ERRORS:
return 0x31;
case rocksdb::Tickers::STALL_L0_SLOWDOWN_MICROS:
return 0x32;
case rocksdb::Tickers::STALL_MEMTABLE_COMPACTION_MICROS:
return 0x33;
case rocksdb::Tickers::STALL_L0_NUM_FILES_MICROS:
return 0x34;
case rocksdb::Tickers::STALL_MICROS:
return 0x35;
case rocksdb::Tickers::DB_MUTEX_WAIT_MICROS:
return 0x36;
case rocksdb::Tickers::RATE_LIMIT_DELAY_MILLIS:
return 0x37;
case rocksdb::Tickers::NO_ITERATORS:
return 0x38;
case rocksdb::Tickers::NUMBER_MULTIGET_CALLS:
return 0x39;
case rocksdb::Tickers::NUMBER_MULTIGET_KEYS_READ:
return 0x3A;
case rocksdb::Tickers::NUMBER_MULTIGET_BYTES_READ:
return 0x3B;
case rocksdb::Tickers::NUMBER_FILTERED_DELETES:
return 0x3C;
case rocksdb::Tickers::NUMBER_MERGE_FAILURES:
return 0x3D;
case rocksdb::Tickers::BLOOM_FILTER_PREFIX_CHECKED:
return 0x3E;
case rocksdb::Tickers::BLOOM_FILTER_PREFIX_USEFUL:
return 0x3F;
case rocksdb::Tickers::NUMBER_OF_RESEEKS_IN_ITERATION:
return 0x40;
case rocksdb::Tickers::GET_UPDATES_SINCE_CALLS:
return 0x41;
case rocksdb::Tickers::BLOCK_CACHE_COMPRESSED_MISS:
return 0x42;
case rocksdb::Tickers::BLOCK_CACHE_COMPRESSED_HIT:
return 0x43;
case rocksdb::Tickers::BLOCK_CACHE_COMPRESSED_ADD:
return 0x44;
case rocksdb::Tickers::BLOCK_CACHE_COMPRESSED_ADD_FAILURES:
return 0x45;
case rocksdb::Tickers::WAL_FILE_SYNCED:
return 0x46;
case rocksdb::Tickers::WAL_FILE_BYTES:
return 0x47;
case rocksdb::Tickers::WRITE_DONE_BY_SELF:
return 0x48;
case rocksdb::Tickers::WRITE_DONE_BY_OTHER:
return 0x49;
case rocksdb::Tickers::WRITE_TIMEDOUT:
return 0x4A;
case rocksdb::Tickers::WRITE_WITH_WAL:
return 0x4B;
case rocksdb::Tickers::COMPACT_READ_BYTES:
return 0x4C;
case rocksdb::Tickers::COMPACT_WRITE_BYTES:
return 0x4D;
case rocksdb::Tickers::FLUSH_WRITE_BYTES:
return 0x4E;
case rocksdb::Tickers::NUMBER_DIRECT_LOAD_TABLE_PROPERTIES:
return 0x4F;
case rocksdb::Tickers::NUMBER_SUPERVERSION_ACQUIRES:
return 0x50;
case rocksdb::Tickers::NUMBER_SUPERVERSION_RELEASES:
return 0x51;
case rocksdb::Tickers::NUMBER_SUPERVERSION_CLEANUPS:
return 0x52;
case rocksdb::Tickers::NUMBER_BLOCK_COMPRESSED:
return 0x53;
case rocksdb::Tickers::NUMBER_BLOCK_DECOMPRESSED:
return 0x54;
case rocksdb::Tickers::NUMBER_BLOCK_NOT_COMPRESSED:
return 0x55;
case rocksdb::Tickers::MERGE_OPERATION_TOTAL_TIME:
return 0x56;
case rocksdb::Tickers::FILTER_OPERATION_TOTAL_TIME:
return 0x57;
case rocksdb::Tickers::ROW_CACHE_HIT:
return 0x58;
case rocksdb::Tickers::ROW_CACHE_MISS:
return 0x59;
case rocksdb::Tickers::READ_AMP_ESTIMATE_USEFUL_BYTES:
return 0x5A;
case rocksdb::Tickers::READ_AMP_TOTAL_READ_BYTES:
return 0x5B;
case rocksdb::Tickers::NUMBER_RATE_LIMITER_DRAINS:
return 0x5C;
case rocksdb::Tickers::TICKER_ENUM_MAX:
return 0x5D;
default:
// undefined/default
return 0x0;
}
}
// Returns the equivalent C++ rocksdb::Tickers enum for the
// provided Java org.rocksdb.TickerType
static rocksdb::Tickers toCppTickers(jbyte jticker_type) {
switch(jticker_type) {
case 0x0:
return rocksdb::Tickers::BLOCK_CACHE_MISS;
case 0x1:
return rocksdb::Tickers::BLOCK_CACHE_HIT;
case 0x2:
return rocksdb::Tickers::BLOCK_CACHE_ADD;
case 0x3:
return rocksdb::Tickers::BLOCK_CACHE_ADD_FAILURES;
case 0x4:
return rocksdb::Tickers::BLOCK_CACHE_INDEX_MISS;
case 0x5:
return rocksdb::Tickers::BLOCK_CACHE_INDEX_HIT;
case 0x6:
return rocksdb::Tickers::BLOCK_CACHE_INDEX_ADD;
case 0x7:
return rocksdb::Tickers::BLOCK_CACHE_INDEX_BYTES_INSERT;
case 0x8:
return rocksdb::Tickers::BLOCK_CACHE_INDEX_BYTES_EVICT;
case 0x9:
return rocksdb::Tickers::BLOCK_CACHE_FILTER_MISS;
case 0xA:
return rocksdb::Tickers::BLOCK_CACHE_FILTER_HIT;
case 0xB:
return rocksdb::Tickers::BLOCK_CACHE_FILTER_ADD;
case 0xC:
return rocksdb::Tickers::BLOCK_CACHE_FILTER_BYTES_INSERT;
case 0xD:
return rocksdb::Tickers::BLOCK_CACHE_FILTER_BYTES_EVICT;
case 0xE:
return rocksdb::Tickers::BLOCK_CACHE_DATA_MISS;
case 0xF:
return rocksdb::Tickers::BLOCK_CACHE_DATA_HIT;
case 0x10:
return rocksdb::Tickers::BLOCK_CACHE_DATA_ADD;
case 0x11:
return rocksdb::Tickers::BLOCK_CACHE_DATA_BYTES_INSERT;
case 0x12:
return rocksdb::Tickers::BLOCK_CACHE_BYTES_READ;
case 0x13:
return rocksdb::Tickers::BLOCK_CACHE_BYTES_WRITE;
case 0x14:
return rocksdb::Tickers::BLOOM_FILTER_USEFUL;
case 0x15:
return rocksdb::Tickers::PERSISTENT_CACHE_HIT;
case 0x16:
return rocksdb::Tickers::PERSISTENT_CACHE_MISS;
case 0x17:
return rocksdb::Tickers::SIM_BLOCK_CACHE_HIT;
case 0x18:
return rocksdb::Tickers::SIM_BLOCK_CACHE_MISS;
case 0x19:
return rocksdb::Tickers::MEMTABLE_HIT;
case 0x1A:
return rocksdb::Tickers::MEMTABLE_MISS;
case 0x1B:
return rocksdb::Tickers::GET_HIT_L0;
case 0x1C:
return rocksdb::Tickers::GET_HIT_L1;
case 0x1D:
return rocksdb::Tickers::GET_HIT_L2_AND_UP;
case 0x1E:
return rocksdb::Tickers::COMPACTION_KEY_DROP_NEWER_ENTRY;
case 0x1F:
return rocksdb::Tickers::COMPACTION_KEY_DROP_OBSOLETE;
case 0x20:
return rocksdb::Tickers::COMPACTION_KEY_DROP_RANGE_DEL;
case 0x21:
return rocksdb::Tickers::COMPACTION_KEY_DROP_USER;
case 0x22:
return rocksdb::Tickers::COMPACTION_RANGE_DEL_DROP_OBSOLETE;
case 0x23:
return rocksdb::Tickers::NUMBER_KEYS_WRITTEN;
case 0x24:
return rocksdb::Tickers::NUMBER_KEYS_READ;
case 0x25:
return rocksdb::Tickers::NUMBER_KEYS_UPDATED;
case 0x26:
return rocksdb::Tickers::BYTES_WRITTEN;
case 0x27:
return rocksdb::Tickers::BYTES_READ;
case 0x28:
return rocksdb::Tickers::NUMBER_DB_SEEK;
case 0x29:
return rocksdb::Tickers::NUMBER_DB_NEXT;
case 0x2A:
return rocksdb::Tickers::NUMBER_DB_PREV;
case 0x2B:
return rocksdb::Tickers::NUMBER_DB_SEEK_FOUND;
case 0x2C:
return rocksdb::Tickers::NUMBER_DB_NEXT_FOUND;
case 0x2D:
return rocksdb::Tickers::NUMBER_DB_PREV_FOUND;
case 0x2E:
return rocksdb::Tickers::ITER_BYTES_READ;
case 0x2F:
return rocksdb::Tickers::NO_FILE_CLOSES;
case 0x30:
return rocksdb::Tickers::NO_FILE_OPENS;
case 0x31:
return rocksdb::Tickers::NO_FILE_ERRORS;
case 0x32:
return rocksdb::Tickers::STALL_L0_SLOWDOWN_MICROS;
case 0x33:
return rocksdb::Tickers::STALL_MEMTABLE_COMPACTION_MICROS;
case 0x34:
return rocksdb::Tickers::STALL_L0_NUM_FILES_MICROS;
case 0x35:
return rocksdb::Tickers::STALL_MICROS;
case 0x36:
return rocksdb::Tickers::DB_MUTEX_WAIT_MICROS;
case 0x37:
return rocksdb::Tickers::RATE_LIMIT_DELAY_MILLIS;
case 0x38:
return rocksdb::Tickers::NO_ITERATORS;
case 0x39:
return rocksdb::Tickers::NUMBER_MULTIGET_CALLS;
case 0x3A:
return rocksdb::Tickers::NUMBER_MULTIGET_KEYS_READ;
case 0x3B:
return rocksdb::Tickers::NUMBER_MULTIGET_BYTES_READ;
case 0x3C:
return rocksdb::Tickers::NUMBER_FILTERED_DELETES;
case 0x3D:
return rocksdb::Tickers::NUMBER_MERGE_FAILURES;
case 0x3E:
return rocksdb::Tickers::BLOOM_FILTER_PREFIX_CHECKED;
case 0x3F:
return rocksdb::Tickers::BLOOM_FILTER_PREFIX_USEFUL;
case 0x40:
return rocksdb::Tickers::NUMBER_OF_RESEEKS_IN_ITERATION;
case 0x41:
return rocksdb::Tickers::GET_UPDATES_SINCE_CALLS;
case 0x42:
return rocksdb::Tickers::BLOCK_CACHE_COMPRESSED_MISS;
case 0x43:
return rocksdb::Tickers::BLOCK_CACHE_COMPRESSED_HIT;
case 0x44:
return rocksdb::Tickers::BLOCK_CACHE_COMPRESSED_ADD;
case 0x45:
return rocksdb::Tickers::BLOCK_CACHE_COMPRESSED_ADD_FAILURES;
case 0x46:
return rocksdb::Tickers::WAL_FILE_SYNCED;
case 0x47:
return rocksdb::Tickers::WAL_FILE_BYTES;
case 0x48:
return rocksdb::Tickers::WRITE_DONE_BY_SELF;
case 0x49:
return rocksdb::Tickers::WRITE_DONE_BY_OTHER;
case 0x4A:
return rocksdb::Tickers::WRITE_TIMEDOUT;
case 0x4B:
return rocksdb::Tickers::WRITE_WITH_WAL;
case 0x4C:
return rocksdb::Tickers::COMPACT_READ_BYTES;
case 0x4D:
return rocksdb::Tickers::COMPACT_WRITE_BYTES;
case 0x4E:
return rocksdb::Tickers::FLUSH_WRITE_BYTES;
case 0x4F:
return rocksdb::Tickers::NUMBER_DIRECT_LOAD_TABLE_PROPERTIES;
case 0x50:
return rocksdb::Tickers::NUMBER_SUPERVERSION_ACQUIRES;
case 0x51:
return rocksdb::Tickers::NUMBER_SUPERVERSION_RELEASES;
case 0x52:
return rocksdb::Tickers::NUMBER_SUPERVERSION_CLEANUPS;
case 0x53:
return rocksdb::Tickers::NUMBER_BLOCK_COMPRESSED;
case 0x54:
return rocksdb::Tickers::NUMBER_BLOCK_DECOMPRESSED;
case 0x55:
return rocksdb::Tickers::NUMBER_BLOCK_NOT_COMPRESSED;
case 0x56:
return rocksdb::Tickers::MERGE_OPERATION_TOTAL_TIME;
case 0x57:
return rocksdb::Tickers::FILTER_OPERATION_TOTAL_TIME;
case 0x58:
return rocksdb::Tickers::ROW_CACHE_HIT;
case 0x59:
return rocksdb::Tickers::ROW_CACHE_MISS;
case 0x5A:
return rocksdb::Tickers::READ_AMP_ESTIMATE_USEFUL_BYTES;
case 0x5B:
return rocksdb::Tickers::READ_AMP_TOTAL_READ_BYTES;
case 0x5C:
return rocksdb::Tickers::NUMBER_RATE_LIMITER_DRAINS;
case 0x5D:
return rocksdb::Tickers::TICKER_ENUM_MAX;
default:
// undefined/default
return rocksdb::Tickers::BLOCK_CACHE_MISS;
}
}
};
// The portal class for org.rocksdb.HistogramType
class HistogramTypeJni {
public:
// Returns the equivalent org.rocksdb.HistogramType for the provided
// C++ rocksdb::Histograms enum
static jbyte toJavaHistogramsType(
const rocksdb::Histograms& histograms) {
switch(histograms) {
case rocksdb::Histograms::DB_GET:
return 0x0;
case rocksdb::Histograms::DB_WRITE:
return 0x1;
case rocksdb::Histograms::COMPACTION_TIME:
return 0x2;
case rocksdb::Histograms::SUBCOMPACTION_SETUP_TIME:
return 0x3;
case rocksdb::Histograms::TABLE_SYNC_MICROS:
return 0x4;
case rocksdb::Histograms::COMPACTION_OUTFILE_SYNC_MICROS:
return 0x5;
case rocksdb::Histograms::WAL_FILE_SYNC_MICROS:
return 0x6;
case rocksdb::Histograms::MANIFEST_FILE_SYNC_MICROS:
return 0x7;
case rocksdb::Histograms::TABLE_OPEN_IO_MICROS:
return 0x8;
case rocksdb::Histograms::DB_MULTIGET:
return 0x9;
case rocksdb::Histograms::READ_BLOCK_COMPACTION_MICROS:
return 0xA;
case rocksdb::Histograms::READ_BLOCK_GET_MICROS:
return 0xB;
case rocksdb::Histograms::WRITE_RAW_BLOCK_MICROS:
return 0xC;
case rocksdb::Histograms::STALL_L0_SLOWDOWN_COUNT:
return 0xD;
case rocksdb::Histograms::STALL_MEMTABLE_COMPACTION_COUNT:
return 0xE;
case rocksdb::Histograms::STALL_L0_NUM_FILES_COUNT:
return 0xF;
case rocksdb::Histograms::HARD_RATE_LIMIT_DELAY_COUNT:
return 0x10;
case rocksdb::Histograms::SOFT_RATE_LIMIT_DELAY_COUNT:
return 0x11;
case rocksdb::Histograms::NUM_FILES_IN_SINGLE_COMPACTION:
return 0x12;
case rocksdb::Histograms::DB_SEEK:
return 0x13;
case rocksdb::Histograms::WRITE_STALL:
return 0x14;
case rocksdb::Histograms::SST_READ_MICROS:
return 0x15;
case rocksdb::Histograms::NUM_SUBCOMPACTIONS_SCHEDULED:
return 0x16;
case rocksdb::Histograms::BYTES_PER_READ:
return 0x17;
case rocksdb::Histograms::BYTES_PER_WRITE:
return 0x18;
case rocksdb::Histograms::BYTES_PER_MULTIGET:
return 0x19;
case rocksdb::Histograms::BYTES_COMPRESSED:
return 0x1A;
case rocksdb::Histograms::BYTES_DECOMPRESSED:
return 0x1B;
case rocksdb::Histograms::COMPRESSION_TIMES_NANOS:
return 0x1C;
case rocksdb::Histograms::DECOMPRESSION_TIMES_NANOS:
return 0x1D;
case rocksdb::Histograms::READ_NUM_MERGE_OPERANDS:
return 0x1E;
case rocksdb::Histograms::HISTOGRAM_ENUM_MAX:
return 0x1F;
default:
// undefined/default
return 0x0;
}
}
// Returns the equivalent C++ rocksdb::Histograms enum for the
// provided Java org.rocksdb.HistogramsType
static rocksdb::Histograms toCppHistograms(jbyte jhistograms_type) {
switch(jhistograms_type) {
case 0x0:
return rocksdb::Histograms::DB_GET;
case 0x1:
return rocksdb::Histograms::DB_WRITE;
case 0x2:
return rocksdb::Histograms::COMPACTION_TIME;
case 0x3:
return rocksdb::Histograms::SUBCOMPACTION_SETUP_TIME;
case 0x4:
return rocksdb::Histograms::TABLE_SYNC_MICROS;
case 0x5:
return rocksdb::Histograms::COMPACTION_OUTFILE_SYNC_MICROS;
case 0x6:
return rocksdb::Histograms::WAL_FILE_SYNC_MICROS;
case 0x7:
return rocksdb::Histograms::MANIFEST_FILE_SYNC_MICROS;
case 0x8:
return rocksdb::Histograms::TABLE_OPEN_IO_MICROS;
case 0x9:
return rocksdb::Histograms::DB_MULTIGET;
case 0xA:
return rocksdb::Histograms::READ_BLOCK_COMPACTION_MICROS;
case 0xB:
return rocksdb::Histograms::READ_BLOCK_GET_MICROS;
case 0xC:
return rocksdb::Histograms::WRITE_RAW_BLOCK_MICROS;
case 0xD:
return rocksdb::Histograms::STALL_L0_SLOWDOWN_COUNT;
case 0xE:
return rocksdb::Histograms::STALL_MEMTABLE_COMPACTION_COUNT;
case 0xF:
return rocksdb::Histograms::STALL_L0_NUM_FILES_COUNT;
case 0x10:
return rocksdb::Histograms::HARD_RATE_LIMIT_DELAY_COUNT;
case 0x11:
return rocksdb::Histograms::SOFT_RATE_LIMIT_DELAY_COUNT;
case 0x12:
return rocksdb::Histograms::NUM_FILES_IN_SINGLE_COMPACTION;
case 0x13:
return rocksdb::Histograms::DB_SEEK;
case 0x14:
return rocksdb::Histograms::WRITE_STALL;
case 0x15:
return rocksdb::Histograms::SST_READ_MICROS;
case 0x16:
return rocksdb::Histograms::NUM_SUBCOMPACTIONS_SCHEDULED;
case 0x17:
return rocksdb::Histograms::BYTES_PER_READ;
case 0x18:
return rocksdb::Histograms::BYTES_PER_WRITE;
case 0x19:
return rocksdb::Histograms::BYTES_PER_MULTIGET;
case 0x1A:
return rocksdb::Histograms::BYTES_COMPRESSED;
case 0x1B:
return rocksdb::Histograms::BYTES_DECOMPRESSED;
case 0x1C:
return rocksdb::Histograms::COMPRESSION_TIMES_NANOS;
case 0x1D:
return rocksdb::Histograms::DECOMPRESSION_TIMES_NANOS;
case 0x1E:
return rocksdb::Histograms::READ_NUM_MERGE_OPERANDS;
case 0x1F:
return rocksdb::Histograms::HISTOGRAM_ENUM_MAX;
default:
// undefined/default
return rocksdb::Histograms::DB_GET;
}
}
};
// The portal class for org.rocksdb.StatsLevel
class StatsLevelJni {
public:
// Returns the equivalent org.rocksdb.StatsLevel for the provided
// C++ rocksdb::StatsLevel enum
static jbyte toJavaStatsLevel(
const rocksdb::StatsLevel& stats_level) {
switch(stats_level) {
case rocksdb::StatsLevel::kExceptDetailedTimers:
return 0x0;
case rocksdb::StatsLevel::kExceptTimeForMutex:
return 0x1;
case rocksdb::StatsLevel::kAll:
return 0x2;
default:
// undefined/default
return 0x0;
}
}
// Returns the equivalent C++ rocksdb::StatsLevel enum for the
// provided Java org.rocksdb.StatsLevel
static rocksdb::StatsLevel toCppStatsLevel(jbyte jstats_level) {
switch(jstats_level) {
case 0x0:
return rocksdb::StatsLevel::kExceptDetailedTimers;
case 0x1:
return rocksdb::StatsLevel::kExceptTimeForMutex;
case 0x2:
return rocksdb::StatsLevel::kAll;
default:
// undefined/default
return rocksdb::StatsLevel::kExceptDetailedTimers;
}
}
};
// various utility functions for working with RocksDB and JNI
class JniUtil {
public:
/**
* Obtains a reference to the JNIEnv from
* the JVM
*
* If the current thread is not attached to the JavaVM
* then it will be attached so as to retrieve the JNIEnv
*
* If a thread is attached, it must later be manually
* released by calling JavaVM::DetachCurrentThread.
* This can be handled by always matching calls to this
* function with calls to {@link JniUtil::releaseJniEnv(JavaVM*, jboolean)}
*
* @param jvm (IN) A pointer to the JavaVM instance
* @param attached (OUT) A pointer to a boolean which
* will be set to JNI_TRUE if we had to attach the thread
*
* @return A pointer to the JNIEnv or nullptr if a fatal error
* occurs and the JNIEnv cannot be retrieved
*/
static JNIEnv* getJniEnv(JavaVM* jvm, jboolean* attached) {
assert(jvm != nullptr);
JNIEnv *env;
const jint env_rs = jvm->GetEnv(reinterpret_cast<void**>(&env),
JNI_VERSION_1_2);
if(env_rs == JNI_OK) {
// current thread is already attached, return the JNIEnv
*attached = JNI_FALSE;
return env;
} else if(env_rs == JNI_EDETACHED) {
// current thread is not attached, attempt to attach
const jint rs_attach = jvm->AttachCurrentThread(reinterpret_cast<void**>(&env), NULL);
if(rs_attach == JNI_OK) {
*attached = JNI_TRUE;
return env;
} else {
// error, could not attach the thread
std::cerr << "JniUtil::getJinEnv - Fatal: could not attach current thread to JVM!" << std::endl;
return nullptr;
}
} else if(env_rs == JNI_EVERSION) {
// error, JDK does not support JNI_VERSION_1_2+
std::cerr << "JniUtil::getJinEnv - Fatal: JDK does not support JNI_VERSION_1_2" << std::endl;
return nullptr;
} else {
std::cerr << "JniUtil::getJinEnv - Fatal: Unknown error: env_rs=" << env_rs << std::endl;
return nullptr;
}
}
/**
* Counterpart to {@link JniUtil::getJniEnv(JavaVM*, jboolean*)}
*
* Detachess the current thread from the JVM if it was previously
* attached
*
* @param jvm (IN) A pointer to the JavaVM instance
* @param attached (IN) JNI_TRUE if we previously had to attach the thread
* to the JavaVM to get the JNIEnv
*/
static void releaseJniEnv(JavaVM* jvm, jboolean& attached) {
assert(jvm != nullptr);
if(attached == JNI_TRUE) {
const jint rs_detach = jvm->DetachCurrentThread();
assert(rs_detach == JNI_OK);
if(rs_detach != JNI_OK) {
std::cerr << "JniUtil::getJinEnv - Warn: Unable to detach current thread from JVM!" << std::endl;
}
}
}
/**
* Copies a Java String[] to a C++ std::vector<std::string>
*
* @param env (IN) A pointer to the java environment
* @param jss (IN) The Java String array to copy
* @param has_exception (OUT) will be set to JNI_TRUE
* if an OutOfMemoryError or ArrayIndexOutOfBoundsException
* exception occurs
*
* @return A std::vector<std:string> containing copies of the Java strings
*/
static std::vector<std::string> copyStrings(JNIEnv* env,
jobjectArray jss, jboolean* has_exception) {
return rocksdb::JniUtil::copyStrings(env, jss,
env->GetArrayLength(jss), has_exception);
}
/**
* Copies a Java String[] to a C++ std::vector<std::string>
*
* @param env (IN) A pointer to the java environment
* @param jss (IN) The Java String array to copy
* @param jss_len (IN) The length of the Java String array to copy
* @param has_exception (OUT) will be set to JNI_TRUE
* if an OutOfMemoryError or ArrayIndexOutOfBoundsException
* exception occurs
*
* @return A std::vector<std:string> containing copies of the Java strings
*/
static std::vector<std::string> copyStrings(JNIEnv* env,
jobjectArray jss, const jsize jss_len, jboolean* has_exception) {
std::vector<std::string> strs;
for (jsize i = 0; i < jss_len; i++) {
jobject js = env->GetObjectArrayElement(jss, i);
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
*has_exception = JNI_TRUE;
return strs;
}
jstring jstr = static_cast<jstring>(js);
const char* str = env->GetStringUTFChars(jstr, nullptr);
if(str == nullptr) {
// exception thrown: OutOfMemoryError
env->DeleteLocalRef(js);
*has_exception = JNI_TRUE;
return strs;
}
strs.push_back(std::string(str));
env->ReleaseStringUTFChars(jstr, str);
env->DeleteLocalRef(js);
}
*has_exception = JNI_FALSE;
return strs;
}
/**
* Copies a jstring to a std::string
* and releases the original jstring
*
* If an exception occurs, then JNIEnv::ExceptionCheck()
* will have been called
*
* @param env (IN) A pointer to the java environment
* @param js (IN) The java string to copy
* @param has_exception (OUT) will be set to JNI_TRUE
* if an OutOfMemoryError exception occurs
*
* @return A std:string copy of the jstring, or an
* empty std::string if has_exception == JNI_TRUE
*/
static std::string copyString(JNIEnv* env, jstring js,
jboolean* has_exception) {
const char *utf = env->GetStringUTFChars(js, nullptr);
if(utf == nullptr) {
// exception thrown: OutOfMemoryError
env->ExceptionCheck();
*has_exception = JNI_TRUE;
return std::string();
} else if(env->ExceptionCheck()) {
// exception thrown
env->ReleaseStringUTFChars(js, utf);
*has_exception = JNI_TRUE;
return std::string();
}
std::string name(utf);
env->ReleaseStringUTFChars(js, utf);
*has_exception = JNI_FALSE;
return name;
}
/**
* Copies bytes from a std::string to a jByteArray
*
* @param env A pointer to the java environment
* @param bytes The bytes to copy
*
* @return the Java byte[] or nullptr if an exception occurs
*/
static jbyteArray copyBytes(JNIEnv* env, std::string bytes) {
const jsize jlen = static_cast<jsize>(bytes.size());
jbyteArray jbytes = env->NewByteArray(jlen);
if(jbytes == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
env->SetByteArrayRegion(jbytes, 0, jlen,
const_cast<jbyte*>(reinterpret_cast<const jbyte*>(bytes.c_str())));
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
env->DeleteLocalRef(jbytes);
return nullptr;
}
return jbytes;
}
/**
* Given a Java byte[][] which is an array of java.lang.Strings
* where each String is a byte[], the passed function `string_fn`
* will be called on each String, the result is the collected by
* calling the passed function `collector_fn`
*
* @param env (IN) A pointer to the java environment
* @param jbyte_strings (IN) A Java array of Strings expressed as bytes
* @param string_fn (IN) A transform function to call for each String
* @param collector_fn (IN) A collector which is called for the result
* of each `string_fn`
* @param has_exception (OUT) will be set to JNI_TRUE
* if an ArrayIndexOutOfBoundsException or OutOfMemoryError
* exception occurs
*/
template <typename T> static void byteStrings(JNIEnv* env,
jobjectArray jbyte_strings,
std::function<T(const char*, const size_t)> string_fn,
std::function<void(size_t, T)> collector_fn,
jboolean *has_exception) {
const jsize jlen = env->GetArrayLength(jbyte_strings);
for(jsize i = 0; i < jlen; i++) {
jobject jbyte_string_obj = env->GetObjectArrayElement(jbyte_strings, i);
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
*has_exception = JNI_TRUE; // signal error
return;
}
jbyteArray jbyte_string_ary =
reinterpret_cast<jbyteArray>(jbyte_string_obj);
T result = byteString(env, jbyte_string_ary, string_fn, has_exception);
env->DeleteLocalRef(jbyte_string_obj);
if(*has_exception == JNI_TRUE) {
// exception thrown: OutOfMemoryError
return;
}
collector_fn(i, result);
}
*has_exception = JNI_FALSE;
}
/**
* Given a Java String which is expressed as a Java Byte Array byte[],
* the passed function `string_fn` will be called on the String
* and the result returned
*
* @param env (IN) A pointer to the java environment
* @param jbyte_string_ary (IN) A Java String expressed in bytes
* @param string_fn (IN) A transform function to call on the String
* @param has_exception (OUT) will be set to JNI_TRUE
* if an OutOfMemoryError exception occurs
*/
template <typename T> static T byteString(JNIEnv* env,
jbyteArray jbyte_string_ary,
std::function<T(const char*, const size_t)> string_fn,
jboolean* has_exception) {
const jsize jbyte_string_len = env->GetArrayLength(jbyte_string_ary);
jbyte* jbyte_string =
env->GetByteArrayElements(jbyte_string_ary, nullptr);
if(jbyte_string == nullptr) {
// exception thrown: OutOfMemoryError
*has_exception = JNI_TRUE;
return nullptr; // signal error
}
T result =
string_fn(reinterpret_cast<char *>(jbyte_string), jbyte_string_len);
env->ReleaseByteArrayElements(jbyte_string_ary, jbyte_string, JNI_ABORT);
*has_exception = JNI_FALSE;
return result;
}
/**
* Converts a std::vector<string> to a Java byte[][] where each Java String
* is expressed as a Java Byte Array byte[].
*
* @param env A pointer to the java environment
* @param strings A vector of Strings
*
* @return A Java array of Strings expressed as bytes
*/
static jobjectArray stringsBytes(JNIEnv* env, std::vector<std::string> strings) {
jclass jcls_ba = ByteJni::getArrayJClass(env);
if(jcls_ba == nullptr) {
// exception occurred
return nullptr;
}
const jsize len = static_cast<jsize>(strings.size());
jobjectArray jbyte_strings = env->NewObjectArray(len, jcls_ba, nullptr);
if(jbyte_strings == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
for (jsize i = 0; i < len; i++) {
std::string *str = &strings[i];
const jsize str_len = static_cast<jsize>(str->size());
jbyteArray jbyte_string_ary = env->NewByteArray(str_len);
if(jbyte_string_ary == nullptr) {
// exception thrown: OutOfMemoryError
env->DeleteLocalRef(jbyte_strings);
return nullptr;
}
env->SetByteArrayRegion(
jbyte_string_ary, 0, str_len,
const_cast<jbyte*>(reinterpret_cast<const jbyte*>(str->c_str())));
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
env->DeleteLocalRef(jbyte_string_ary);
env->DeleteLocalRef(jbyte_strings);
return nullptr;
}
env->SetObjectArrayElement(jbyte_strings, i, jbyte_string_ary);
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
// or ArrayStoreException
env->DeleteLocalRef(jbyte_string_ary);
env->DeleteLocalRef(jbyte_strings);
return nullptr;
}
env->DeleteLocalRef(jbyte_string_ary);
}
return jbyte_strings;
}
/*
* Helper for operations on a key and value
* for example WriteBatch->Put
*
* TODO(AR) could be extended to cover returning rocksdb::Status
* from `op` and used for RocksDB->Put etc.
*/
static void kv_op(
std::function<void(rocksdb::Slice, rocksdb::Slice)> op,
JNIEnv* env, jobject jobj,
jbyteArray jkey, jint jkey_len,
jbyteArray jentry_value, jint jentry_value_len) {
jbyte* key = env->GetByteArrayElements(jkey, nullptr);
if(env->ExceptionCheck()) {
// exception thrown: OutOfMemoryError
return;
}
jbyte* value = env->GetByteArrayElements(jentry_value, nullptr);
if(env->ExceptionCheck()) {
// exception thrown: OutOfMemoryError
if(key != nullptr) {
env->ReleaseByteArrayElements(jkey, key, JNI_ABORT);
}
return;
}
rocksdb::Slice key_slice(reinterpret_cast<char*>(key), jkey_len);
rocksdb::Slice value_slice(reinterpret_cast<char*>(value),
jentry_value_len);
op(key_slice, value_slice);
if(value != nullptr) {
env->ReleaseByteArrayElements(jentry_value, value, JNI_ABORT);
}
if(key != nullptr) {
env->ReleaseByteArrayElements(jkey, key, JNI_ABORT);
}
}
/*
* Helper for operations on a key
* for example WriteBatch->Delete
*
* TODO(AR) could be extended to cover returning rocksdb::Status
* from `op` and used for RocksDB->Delete etc.
*/
static void k_op(
std::function<void(rocksdb::Slice)> op,
JNIEnv* env, jobject jobj,
jbyteArray jkey, jint jkey_len) {
jbyte* key = env->GetByteArrayElements(jkey, nullptr);
if(env->ExceptionCheck()) {
// exception thrown: OutOfMemoryError
return;
}
rocksdb::Slice key_slice(reinterpret_cast<char*>(key), jkey_len);
op(key_slice);
if(key != nullptr) {
env->ReleaseByteArrayElements(jkey, key, JNI_ABORT);
}
}
/*
* Helper for operations on a value
* for example WriteBatchWithIndex->GetFromBatch
*/
static jbyteArray v_op(
std::function<rocksdb::Status(rocksdb::Slice, std::string*)> op,
JNIEnv* env, jbyteArray jkey, jint jkey_len) {
jbyte* key = env->GetByteArrayElements(jkey, nullptr);
if(env->ExceptionCheck()) {
// exception thrown: OutOfMemoryError
return nullptr;
}
rocksdb::Slice key_slice(reinterpret_cast<char*>(key), jkey_len);
std::string value;
rocksdb::Status s = op(key_slice, &value);
if(key != nullptr) {
env->ReleaseByteArrayElements(jkey, key, JNI_ABORT);
}
if (s.IsNotFound()) {
return nullptr;
}
if (s.ok()) {
jbyteArray jret_value =
env->NewByteArray(static_cast<jsize>(value.size()));
if(jret_value == nullptr) {
// exception thrown: OutOfMemoryError
return nullptr;
}
env->SetByteArrayRegion(jret_value, 0, static_cast<jsize>(value.size()),
const_cast<jbyte*>(reinterpret_cast<const jbyte*>(value.c_str())));
if(env->ExceptionCheck()) {
// exception thrown: ArrayIndexOutOfBoundsException
if(jret_value != nullptr) {
env->DeleteLocalRef(jret_value);
}
return nullptr;
}
return jret_value;
}
rocksdb::RocksDBExceptionJni::ThrowNew(env, s);
return nullptr;
}
};
} // namespace rocksdb
#endif // JAVA_ROCKSJNI_PORTAL_H_