Use length-aware accessors

Author: Chessray

src/main/c++/bytearray/GetByteArray.cpp

@@ -58,23 +58,33 @@ static const auto DB_READ_MOCK = std::unordered_map<std::string, std::string>{
     {"testKeyWithReturnValueSize0131072Bytes", STR_128_KB},
     {"testKeyWithReturnValueSize0262144Bytes", STR_256_KB}};
 
-const std::string &GetByteArrayInternal(const char *key)
-{
-  std::string str(key, 38);
-
-  //std::cerr << std::endl << "Getting " << str << std::endl << std::endl;
-  return DB_READ_MOCK.at(str);
-}
-
-struct WriteKey
-{
-  std::string key;
-  size_t length;
-
-  WriteKey(const std::string &key, size_t length) : key(key, 38), length(length)
-  {
-  }
-};
+static const std::string &GetByteArrayInternal(const char *key)
+{
+  std::string str(key, 38);
+
+  //std::cerr << std::endl << "Getting " << str << std::endl << std::endl;
+  return DB_READ_MOCK.at(str);
+}
+
+const std::string &GetByteArrayInternalWithLength(const char *key, size_t key_len)
+{
+  std::string str(key, key_len);
+  return DB_READ_MOCK.at(str);
+}
+
+struct WriteKey
+{
+  std::string key;
+  size_t length;
+
+  WriteKey(const std::string &key, size_t length) : key(key), length(length)
+  {
+  }
+
+  WriteKey(const char *key_ptr, size_t key_len, size_t length) : key(key_ptr, key_len), length(length)
+  {
+  }
+};
 
 bool operator==(const WriteKey &lhs, const WriteKey &rhs)
 {
@@ -98,17 +108,29 @@ namespace std
 
 static auto DB_WRITE_MOCK = std::unordered_map<WriteKey, char *>();
 
-char *GetByteArrayInternalForWrite(const char *key, size_t size)
-{
-  auto writeKey = WriteKey(key, size);
-  auto it = DB_WRITE_MOCK.find(writeKey);
+static char *GetByteArrayInternalForWrite(const char *key, size_t size)
+{
+  auto writeKey = WriteKey(key, 38, size);
+  auto it = DB_WRITE_MOCK.find(writeKey);
   if (it == DB_WRITE_MOCK.end())
   {
     DB_WRITE_MOCK[writeKey] = new char[size];
     it = DB_WRITE_MOCK.find(writeKey);
-  }
-  return it->second;
-}
+  }
+  return it->second;
+}
+
+char *GetByteArrayInternalForWriteWithLength(const char *key, size_t key_len, size_t size)
+{
+  auto writeKey = WriteKey(key, key_len, size);
+  auto it = DB_WRITE_MOCK.find(writeKey);
+  if (it == DB_WRITE_MOCK.end())
+  {
+    DB_WRITE_MOCK[writeKey] = new char[size];
+    it = DB_WRITE_MOCK.find(writeKey);
+  }
+  return it->second;
+}
 
 jclass g_jbyte_buffer_clazz;
 jmethodID g_jbyte_buffer_array_mid;

src/main/c++/bytearray/Portal.h

@@ -27,6 +27,95 @@
 #include <assert.h>
 #include <jni.h>
 
+#include <cstring>
+#include <string>
+
+extern jclass g_jbyte_buffer_clazz;
+extern jmethodID g_jbyte_buffer_array_mid;
+extern jmethodID g_jbyte_buffer_allocate_mid;
+
+const std::string &GetByteArrayInternalWithLength(const char *key, size_t key_len);
+char *GetByteArrayInternalForWriteWithLength(const char *key, size_t key_len, size_t len);
+
+inline jbyteArray StringToJavaByteArray(JNIEnv *env, const std::string& str) {
+  const jsize jlen = static_cast<jsize>(str.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*>(str.c_str())));
+  if(env->ExceptionCheck()) {
+    // exception thrown: ArrayIndexOutOfBoundsException
+    env->DeleteLocalRef(jbytes);
+    return nullptr;
+  }
+
+  return jbytes;
+}
+
+inline void SetByteBufferData(JNIEnv* env, const jmethodID jarray_mid, const jobject& jbuf,
+    const char* content, const size_t content_len) {
+  jbyteArray jarray = static_cast<jbyteArray>(env->CallObjectMethod(jbuf, jarray_mid));
+  if (env->ExceptionCheck()) {
+    // exception occurred
+    env->DeleteLocalRef(jbuf);
+    return;
+  }
+
+  jboolean is_copy = JNI_FALSE;
+  jbyte* ja = reinterpret_cast<jbyte*>(
+      env->GetPrimitiveArrayCritical(jarray, &is_copy));
+  if (ja == nullptr) {
+    // exception occurred
+     env->DeleteLocalRef(jarray);
+     env->DeleteLocalRef(jbuf);
+     return;
+  }
+
+  memcpy(ja, const_cast<char*>(content), content_len);
+
+  env->ReleasePrimitiveArrayCritical(jarray, ja, is_copy ? 0 : JNI_ABORT);
+
+  env->DeleteLocalRef(jarray);
+}
+
+inline jobject NewByteBuffer(JNIEnv* env, const size_t capacity, const char* content) {
+
+  const jobject jbuf = env->CallStaticObjectMethod(
+      g_jbyte_buffer_clazz, g_jbyte_buffer_allocate_mid, static_cast<jint>(capacity));
+  if (env->ExceptionCheck()) {
+    // exception occurred
+    return nullptr;
+  }
+
+  // Set buffer data
+  if (content != nullptr) {
+    SetByteBufferData(env, g_jbyte_buffer_array_mid, jbuf, content, capacity);
+  }
+
+  return jbuf;
+}
+
+inline jobject NewDirectByteBuffer(JNIEnv* env, const size_t capacity, const char* content) {
+  bool allocated = false;
+  if (content == nullptr) {
+    content = new char[capacity];
+    allocated = true;
+  }
+  jobject jbuf = env->NewDirectByteBuffer(const_cast<char*>(content), static_cast<jlong>(capacity));
+  if (jbuf == nullptr) {
+    // exception occurred
+    if (allocated) {
+      delete[] static_cast<const char*>(content);
+    }
+    return nullptr;
+  }
+  return jbuf;
+}
+
 namespace jnibench {
 
 // Native class template
@@ -81,4 +170,4 @@ class FooByCallInvokeFinalJni : public FooJniClass<jnibench::Foo*, FooByCallInvo
   }
 };
 
-}  //end namespace jnibench
+}  //end namespace jnibench