How to use

V8ArrayBuffer

in

com.eclipsesource.v8

/**
 * Create a new ArrayBuffer from a java.nio.ByteBuffer
 *
 * @param v8 the Runtime on which to create the ArrayBuffer
 * @param byteBuffer the ByteBuffer to use to back the ArrayBuffer
 */
public ArrayBuffer(final V8 v8, final ByteBuffer byteBuffer) {
  V8ArrayBuffer v8ArrayBuffer = new V8ArrayBuffer(v8, byteBuffer);
  try {
    arrayBuffer = (V8ArrayBuffer) v8ArrayBuffer.twin().setWeak();
  } finally {
    v8ArrayBuffer.close();
  }
}

public V8ArrayBuffer(final V8 v8, ByteBuffer byteBuffer) {
  super(v8);
  if (byteBuffer == null) {
    byteBuffer = ByteBuffer.allocateDirect(0);
  }
  if (!byteBuffer.isDirect()) {
    throw new IllegalArgumentException("ByteBuffer must be a allocated as a direct ByteBuffer");
  }
  initialize(v8.getV8RuntimePtr(), byteBuffer);
  this.byteBuffer = byteBuffer;
  byteBuffer.order(ByteOrder.nativeOrder());
}

/**
 * Determine if the underlying V8ArrayBuffer is still available, or if it's been cleaned up by the JavaScript
 * garbage collector.
 *
 * @return true if the underlying V8ArrayBuffer is still available, false otherwise.
 */
public boolean isAvailable() {
  return !arrayBuffer.isReleased();
}

ArrayBuffer(final V8ArrayBuffer arrayBuffer) {
  this.arrayBuffer = (V8ArrayBuffer) arrayBuffer.twin().setWeak();
}

  @Override
  public Object invoke(final V8Object receiver, final V8Array parameters) {
    V8ArrayBuffer arrayBuffer = new V8ArrayBuffer(v8, 8);
    V8TypedArray array = new V8TypedArray(v8, arrayBuffer, V8Value.INT_32_ARRAY, 0, 2);
    array.add("0", 800000000);
    arrayBuffer.close();
    return array;
  }
};

@Test
public void testCreateByteTypedArray() {
  V8ArrayBuffer buffer = new V8ArrayBuffer(v8, 8);
  V8TypedArray typedArray = new V8TypedArray(v8, buffer, V8Value.BYTE, 0, 2);
  typedArray.add("0", 7);
  typedArray.add("1", 8);
  assertEquals(7, buffer.get());
  assertEquals(8, buffer.get());
  buffer.close();
  typedArray.close();
}

@Test
public void testInt8TypedArray_Length() {
  V8ArrayBuffer buffer = new V8ArrayBuffer(v8, 8);
  V8TypedArray v8Int8Array = new V8TypedArray(v8, buffer, V8Value.BYTE, 0, 2);
  buffer.put((byte) 4);
  buffer.put((byte) 8);
  assertEquals(2, v8Int8Array.length());
  buffer.close();
  v8Int8Array.close();
}

/**
 * Returns the buffers capacity
 *
 * @return the buffers capacity
 */
public final int capacity() {
  v8.checkThread();
  checkReleased();
  return byteBuffer.capacity();
}

@Test
public void testArrayBufferGetValue() {
  V8ArrayBuffer buf = (V8ArrayBuffer) v8.executeScript("var buf = new ArrayBuffer(100);\n"
      + "buf;\n");
  V8ArrayBuffer result = ((ArrayBuffer) V8ObjectUtils.getValue(buf)).getV8ArrayBuffer();
  assertEquals(100, result.limit());
  buf.close();
  result.close();
}

@Test
public void testGetArrayBuffer() {
  ArrayBuffer arrayBuffer = new ArrayBuffer(v8, ByteBuffer.allocateDirect(8));
  V8ArrayBuffer v8ArrayBuffer = (V8ArrayBuffer) V8ObjectUtils.getV8Result(v8, arrayBuffer);
  assertEquals(arrayBuffer.getV8ArrayBuffer().setWeak(), v8ArrayBuffer);
  v8ArrayBuffer.close();
}

@Test
public void testGetTypedRangeArrayValue_FromBackingStore() {
  V8ArrayBuffer buffer = new V8ArrayBuffer(v8, 100);
  v8.add("buf", buffer);
  v8.executeVoidScript("var ints = new Int32Array(buf); for(var i = 0; i < 25; i++) {ints[i] = i;};");
  assertEquals(25, buffer.intLimit());
  for (int i = 0; i < buffer.intLimit(); i++) {
    assertEquals(i, buffer.getInt(i * 4));
  }
  buffer.close();
}

/**
 * Returns the underlying ByteBuffer used to back this TypedArray.
 *
 * @return The ByteBuffer used as the backing store for this TypedArray
 */
public ByteBuffer getByteBuffer() {
  V8ArrayBuffer buffer = getBuffer();
  try {
    return buffer.getBackingStore();
  } finally {
    buffer.release();
  }
}

@Test
public void testGetTypedArrayType32BitFloatValue_FromBackingStore() {
  V8ArrayBuffer buffer = new V8ArrayBuffer(v8, 4);
  v8.add("buf", buffer);
  v8.executeVoidScript("var floats = new Float32Array(buf); floats[0] = 255.5;");
  assertEquals(255.5, buffer.getFloat(0), 0.00001);
  buffer.close();
}

@Test
public void testCreateIntegerTypedArray() {
  V8ArrayBuffer buffer = new V8ArrayBuffer(v8, 8);
  V8TypedArray v8Int32Array = new V8TypedArray(v8, buffer, V8Value.INTEGER, 0, 2);
  v8Int32Array.add("0", 7);
  v8Int32Array.add("1", 8);
  assertEquals(7, buffer.getInt());
  assertEquals(8, buffer.getInt());
  buffer.close();
  v8Int32Array.close();
}

@Test
public void testAccess64BitFloatFromTypedArray() {
  V8ArrayBuffer buffer = new V8ArrayBuffer(v8, 8);
  V8TypedArray typedArray = new V8TypedArray(v8, buffer, V8Value.FLOAT_64_ARRAY, 0, 1);
  typedArray.add("0", 3.14159265359);
  assertEquals(V8Value.FLOAT_64_ARRAY, typedArray.getType());
  assertEquals(3.14159265359, buffer.getDouble(), 0.000000000001);
  buffer.close();
  typedArray.close();
}

@Test
public void testArrayBufferTwinHasSameBackingStore() {
  V8ArrayBuffer arrayBuffer = (V8ArrayBuffer) v8.executeScript("var buf = new ArrayBuffer(100);  buf;");
  V8ArrayBuffer twin = arrayBuffer.twin();
  assertEquals(twin.byteBuffer, arrayBuffer.byteBuffer);
  arrayBuffer.close();
  twin.close();
}

@Override
protected void initialize(final long runtimePtr, final Object data) {
  v8.checkThread();
  if (data instanceof ByteBuffer) {
    ByteBuffer buffer = (ByteBuffer) data;
    int capacity = buffer.limit();
    objectHandle = v8.initNewV8ArrayBuffer(v8.getV8RuntimePtr(), buffer, capacity);
  } else {
    int capacity = (Integer) data;
    objectHandle = v8.initNewV8ArrayBuffer(v8.getV8RuntimePtr(), capacity);
  }
  released = false;
  addObjectReference(objectHandle);
}

@Override
protected V8Value createTwin() {
  return new V8ArrayBuffer(v8, byteBuffer);
}

@Test
public void testAccessArrayBuffer_Int8ArrayView() {
  V8ArrayBuffer buffer = (V8ArrayBuffer) v8.executeScript("var buf = new ArrayBuffer(4); var ints = new Int8Array(buf); ints[0] = 7; buf");
  assertEquals(4, buffer.limit());
  assertEquals(7, buffer.get(0));
  buffer.close();
}

@Test
public void testGetArrayBufferNotReleased() {
  ArrayBuffer arrayBuffer = new ArrayBuffer(v8, ByteBuffer.allocateDirect(8));
  V8ArrayBuffer v8ArrayBuffer = (V8ArrayBuffer) V8ObjectUtils.getV8Result(v8, arrayBuffer);
  assertFalse(v8ArrayBuffer.isReleased());
  v8ArrayBuffer.close();
}