Merge branch 'wsw0108-typed-array'

joeferner · joeferner · commit 5b42353ddd35 · 2016-09-20T21:46:25.000-04:00
diff --git a/src/utils.cpp b/src/utils.cpp
@@ -477,6 +477,14 @@ jvalueType javaGetArrayComponentType(JNIEnv *env, jobjectArray array) {
   return arrayComponentType;
 }
 
+#if (NODE_VERSION_AT_LEAST(4, 0, 0))
+v8::Local<v8::ArrayBuffer> newArrayBuffer(void* elems, size_t length) {
+  v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), length);
+  memcpy(ab->GetContents().Data(), elems, length);
+  return ab;
+}
+#endif
+
 v8::Local<v8::String> javaCharToV8String(jchar c) {
 #if ((NODE_MAJOR_VERSION == 0) && (NODE_MINOR_VERSION <= 10))
   return v8::String::New(&c, 1);
@@ -499,76 +507,126 @@ v8::Local<v8::Value> javaArrayToV8(Java* java, JNIEnv* env, jobjectArray objArra
   //printf("array size: %d\n", arraySize);
 
   v8::Local<v8::Array> result = Nan::New<v8::Array>(arraySize);
+  // http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/types.html
   switch(arrayComponentType) {
   case TYPE_CHAR:
     {
       jchar* elems = env->GetCharArrayElements((jcharArray)objArray, 0);
+#if (NODE_VERSION_AT_LEAST(4, 0, 0))
+      size_t byteLength = arraySize * 2;
+      v8::Local<v8::ArrayBuffer> ab = newArrayBuffer(elems, byteLength);
+      env->ReleaseCharArrayElements((jcharArray)objArray, elems, 0);
+      return v8::Uint16Array::New(ab, 0, arraySize);
+#else
       jchar str;
       for(jsize i=0; i<arraySize; i++) {
         str = elems[i];
         result->Set(i, javaCharToV8String(str));
       }
       env->ReleaseCharArrayElements((jcharArray)objArray, elems, 0);
+#endif
     }
     break;
 
   case TYPE_INT:
     {
       jint* elems = env->GetIntArrayElements((jintArray)objArray, 0);
+#if (NODE_VERSION_AT_LEAST(4, 0, 0))
+      size_t byteLength = arraySize * 4;
+      v8::Local<v8::ArrayBuffer> ab = newArrayBuffer(elems, byteLength);
+      env->ReleaseIntArrayElements((jintArray)objArray, elems, 0);
+      return v8::Int32Array::New(ab, 0, arraySize);
+#else
       for(jsize i=0; i<arraySize; i++) {
         result->Set(i, Nan::New<v8::Integer>(elems[i]));
       }
       env->ReleaseIntArrayElements((jintArray)objArray, elems, 0);
+#endif
     }
     break;
 
   case TYPE_BYTE:
     {
       jbyte* elems = env->GetByteArrayElements((jbyteArray)objArray, 0);
+#if (NODE_VERSION_AT_LEAST(4, 0, 0))
+      size_t byteLength = arraySize;
+      v8::Local<v8::ArrayBuffer> ab = newArrayBuffer(elems, byteLength);
+      env->ReleaseByteArrayElements((jbyteArray)objArray, elems, 0);
+      return v8::Int8Array::New(ab, 0, arraySize);
+#else
       for(jsize i=0; i<arraySize; i++) {
         result->Set(i, Nan::New<v8::Number>(elems[i]));
       }
       env->ReleaseByteArrayElements((jbyteArray)objArray, elems, 0);
+#endif
     }
     break;
 
   case TYPE_BOOLEAN:
     {
       jboolean* elems = env->GetBooleanArrayElements((jbooleanArray)objArray, 0);
+#if (NODE_VERSION_AT_LEAST(4, 0, 0))
+      size_t byteLength = arraySize;
+      v8::Local<v8::ArrayBuffer> ab = newArrayBuffer(elems, byteLength);
+      env->ReleaseBooleanArrayElements((jbooleanArray)objArray, elems, 0);
+      return v8::Uint8Array::New(ab, 0, arraySize);
+#else
       for(jsize i=0; i<arraySize; i++) {
         result->Set(i, Nan::New<v8::Boolean>(elems[i]));
       }
       env->ReleaseBooleanArrayElements((jbooleanArray)objArray, elems, 0);
+#endif
     }
     break;
 
   case TYPE_SHORT:
     {
       jshort* elems = env->GetShortArrayElements((jshortArray)objArray, 0);
+#if (NODE_VERSION_AT_LEAST(4, 0, 0))
+      size_t byteLength = arraySize * 2;
+      v8::Local<v8::ArrayBuffer> ab = newArrayBuffer(elems, byteLength);
+      env->ReleaseShortArrayElements((jshortArray)objArray, elems, 0);
+      return v8::Int16Array::New(ab, 0, arraySize);
+#else
       for(jsize i=0; i<arraySize; i++) {
         result->Set(i, Nan::New<v8::Number>(elems[i]));
       }
       env->ReleaseShortArrayElements((jshortArray)objArray, elems, 0);
+#endif
     }
     break;
 
   case TYPE_DOUBLE:
     {
       jdouble* elems = env->GetDoubleArrayElements((jdoubleArray)objArray, 0);
+#if (NODE_VERSION_AT_LEAST(4, 0, 0))
+      size_t byteLength = arraySize * 8;
+      v8::Local<v8::ArrayBuffer> ab = newArrayBuffer(elems, byteLength);
+      env->ReleaseDoubleArrayElements((jdoubleArray)objArray, elems, 0);
+      return v8::Float64Array::New(ab, 0, arraySize);
+#else
       for(jsize i=0; i<arraySize; i++) {
         result->Set(i, Nan::New<v8::Number>(elems[i]));
       }
       env->ReleaseDoubleArrayElements((jdoubleArray)objArray, elems, 0);
+#endif
     }
     break;
 
   case TYPE_FLOAT:
     {
       jfloat* elems = env->GetFloatArrayElements((jfloatArray)objArray, 0);
+#if (NODE_VERSION_AT_LEAST(4, 0, 0))
+      size_t byteLength = arraySize * 4;
+      v8::Local<v8::ArrayBuffer> ab = newArrayBuffer(elems, byteLength);
+      env->ReleaseFloatArrayElements((jfloatArray)objArray, elems, 0);
+      return v8::Float32Array::New(ab, 0, arraySize);
+#else
       for(jsize i=0; i<arraySize; i++) {
         result->Set(i, Nan::New<v8::Number>(elems[i]));
       }
       env->ReleaseFloatArrayElements((jfloatArray)objArray, elems, 0);
+#endif
     }
     break;
 
diff --git a/test/utils-types-test.js b/test/utils-types-test.js
@@ -57,8 +57,13 @@ exports['Utils - Types'] = nodeunit.testCase({
     var arr2 = list.toArraySync();
     test.equal(arr2.length, 1);
     test.equal(arr2[0].length, 9);
+    var isTypedArrayReturn = !(typeof arr2[0][0] === 'string');
     for(var i=0; i<originalArray.length; i++) {
-      test.equal(arr2[0][i], originalArray[i]);
+      if (isTypedArrayReturn) {
+        test.equal(arr2[0][i], originalArray[i].charCodeAt(0));
+      } else {
+        test.equal(arr2[0][i], originalArray[i]);
+      }
     }
     test.done();
   }
