How to use

TypedArray

in

com.eclipsesource.v8.utils

private static Object getValue(final Object value, final int valueType, final V8Map<Object> cache, final TypeAdapter adapter) {
  Object adapterResult = adapter.adapt(valueType, value);
  if (TypeAdapter.DEFAULT != adapterResult) {
    return adapterResult;
  }
  switch (valueType) {
    case V8Value.INTEGER:
    case V8Value.DOUBLE:
    case V8Value.BOOLEAN:
    case V8Value.STRING:
      return value;
    case V8Value.V8_FUNCTION:
      return IGNORE;
    case V8Value.V8_ARRAY_BUFFER:
      return new ArrayBuffer((V8ArrayBuffer) value);
    case V8Value.V8_TYPED_ARRAY:
      return new TypedArray((V8TypedArray) value);
    case V8Value.V8_ARRAY:
      return toList((V8Array) value, cache, adapter);
    case V8Value.V8_OBJECT:
      return toMap((V8Object) value, cache, adapter);
    case V8Value.NULL:
      return null;
    case V8Value.UNDEFINED:
      return V8.getUndefined();
    default:
      throw new IllegalStateException("Cannot convert type " + V8Value.getStringRepresentation(valueType));
  }
}

private static V8TypedArray toV8TypedArray(final V8 v8, final TypedArray typeArray, final Map<Object, V8Value> cache) {
  if (cache.containsKey(typeArray)) {
    return (V8TypedArray) cache.get(typeArray);
  }
  V8TypedArray result = typeArray.getV8TypedArray();
  cache.put(typeArray, result);
  return result;
}

@Test
public void testGetV8TypedArray() {
  TypedArray typedArray = new TypedArray(v8, new ArrayBuffer(v8, ByteBuffer.allocateDirect(8)), V8Value.INT_8_ARRAY, 0, 8);
  V8TypedArray v8TypedArray = typedArray.getV8TypedArray();
  assertNotNull(v8TypedArray);
  v8TypedArray.close();
}

@Test
public void testV8TypedArrayAvailable() {
  TypedArray typedArray = new TypedArray(v8, new ArrayBuffer(v8, ByteBuffer.allocateDirect(8)), V8Value.INT_8_ARRAY, 0, 8);
  assertTrue(typedArray.isAvailable());
}

@Test
public void testTypedArrayInList() {
  TypedArray int8Array = new TypedArray(v8, new ArrayBuffer(v8, ByteBuffer.allocateDirect(8)), V8Value.INT_8_ARRAY, 0, 8);
  V8TypedArray v8TypedArray = int8Array.getV8TypedArray();
  V8ArrayBuffer v8ArrayBuffer = v8TypedArray.getBuffer();
  v8ArrayBuffer.put(0, (byte) 7);
  v8TypedArray.close();
  v8ArrayBuffer.close();
  List<Object> list = new ArrayList<Object>();
  list.add(int8Array);
  V8Array array = V8ObjectUtils.toV8Array(v8, list);
  V8Array v8Array = (V8Array) array.get(0);
  assertEquals((byte) 7, v8Array.get(0));
  assertEquals(V8Value.INT_8_ARRAY, v8Array.getType());
  v8Array.close();
  array.close();
}

private static V8TypedArray toV8TypedArray(final V8 v8, final TypedArray typeArray, final Map<Object, V8Value> cache) {
  if (cache.containsKey(typeArray)) {
    return (V8TypedArray) cache.get(typeArray);
  }
  V8TypedArray result = typeArray.getV8TypedArray();
  cache.put(typeArray, result);
  return result;
}

@Test
public void testTypedArrayInMap() {
  TypedArray int8Array = new TypedArray(v8, new ArrayBuffer(v8, ByteBuffer.allocateDirect(8)), V8Value.INT_8_ARRAY, 0, 8);
  V8TypedArray v8TypedArray = int8Array.getV8TypedArray();
  V8ArrayBuffer v8ArrayBuffer = v8TypedArray.getBuffer();
  v8ArrayBuffer.put(0, (byte) 7);
  v8TypedArray.close();
  v8ArrayBuffer.close();
  HashMap<String, Object> map = new HashMap<String, Object>();
  map.put("array", int8Array);
  V8Object object = V8ObjectUtils.toV8Object(v8, map);
  V8TypedArray v8Array = (V8TypedArray) object.get("array");
  assertEquals((byte) 7, v8Array.get(0));
  assertEquals(V8Value.INT_8_ARRAY, v8Array.getType());
  v8Array.close();
  object.close();
}

private static Object getValue(final Object value, final int valueType, final V8Map<Object> cache, final TypeAdapter adapter) {
  Object adapterResult = adapter.adapt(valueType, value);
  if (TypeAdapter.DEFAULT != adapterResult) {
    return adapterResult;
  }
  switch (valueType) {
    case V8Value.INTEGER:
    case V8Value.DOUBLE:
    case V8Value.BOOLEAN:
    case V8Value.STRING:
      return value;
    case V8Value.V8_FUNCTION:
      return IGNORE;
    case V8Value.V8_ARRAY_BUFFER:
      return new ArrayBuffer((V8ArrayBuffer) value);
    case V8Value.V8_TYPED_ARRAY:
      return new TypedArray((V8TypedArray) value);
    case V8Value.V8_ARRAY:
      return toList((V8Array) value, cache, adapter);
    case V8Value.V8_OBJECT:
      return toMap((V8Object) value, cache, adapter);
    case V8Value.NULL:
      return null;
    case V8Value.UNDEFINED:
      return V8.getUndefined();
    default:
      throw new IllegalStateException("Cannot convert type " + V8Value.getStringRepresentation(valueType));
  }
}

  @Override
  public Boolean invoke(final V8Object receiver, final V8Array parameters) {
    V8TypedArray result = ((TypedArray) V8ObjectUtils.getValue(parameters, 0)).getV8TypedArray();
    try {
      return result.getType() == V8Value.FLOAT_64_ARRAY;
    } finally {
      result.close();
    }
  }
};

@Test
public void testGetTypedArray() {
  TypedArray int8Array = new TypedArray(v8, new ArrayBuffer(v8, ByteBuffer.allocateDirect(8)), V8Value.INT_8_ARRAY, 0, 8);
  V8TypedArray v8TypedArray = int8Array.getV8TypedArray();
  V8ArrayBuffer v8ArrayBuffer = v8TypedArray.getBuffer();
  v8ArrayBuffer.put(0, (byte) 7);
  v8TypedArray.close();
  v8ArrayBuffer.close();
  V8TypedArray v8Array = (V8TypedArray) V8ObjectUtils.getV8Result(v8, int8Array);
  assertEquals((byte) 7, v8Array.get(0));
  assertEquals(V8Value.INT_8_ARRAY, v8Array.getType());
  v8Array.close();
}

  @Override
  public Boolean invoke(final V8Object receiver, final V8Array parameters) {
    V8TypedArray result = ((TypedArray) V8ObjectUtils.getValue(parameters, 0)).getV8TypedArray();
    try {
      return result.getType() == V8Value.FLOAT_32_ARRAY;
    } finally {
      result.close();
    }
  }
};

  @Override
  public Boolean invoke(final V8Object receiver, final V8Array parameters) {
    V8TypedArray result = ((TypedArray) V8ObjectUtils.getValue(parameters, 0)).getV8TypedArray();
    try {
      return result.getType() == V8Value.INT_32_ARRAY;
    } finally {
      result.close();
    }
  }
};

  @Override
  public Boolean invoke(final V8Object receiver, final V8Array parameters) {
    V8TypedArray result = ((TypedArray) V8ObjectUtils.getValue(parameters, 0)).getV8TypedArray();
    try {
      return result.getType() == V8Value.UNSIGNED_INT_16_ARRAY;
    } finally {
      result.close();
    }
  }
};

  @Override
  public Boolean invoke(final V8Object receiver, final V8Array parameters) {
    V8TypedArray result = ((TypedArray) V8ObjectUtils.getValue(parameters, 0)).getV8TypedArray();
    try {
      return result.getType() == V8Value.UNSIGNED_INT_32_ARRAY;
    } finally {
      result.close();
    }
  }
};

  @Override
  public Boolean invoke(final V8Object receiver, final V8Array parameters) {
    V8TypedArray result = ((TypedArray) V8ObjectUtils.getValue(parameters, 0)).getV8TypedArray();
    try {
      return result.getType() == V8Value.INT_8_ARRAY;
    } finally {
      result.close();
    }
  }
};

  @Override
  public Boolean invoke(final V8Object receiver, final V8Array parameters) {
    V8TypedArray result = ((TypedArray) V8ObjectUtils.getValue(parameters, 0)).getV8TypedArray();
    try {
      return result.getType() == V8Value.INT_16_ARRAY;
    } finally {
      result.close();
    }
  }
};

  @Override
  public Boolean invoke(final V8Object receiver, final V8Array parameters) {
    V8TypedArray result = ((TypedArray) V8ObjectUtils.getValue(parameters, 0)).getV8TypedArray();
    try {
      return result.getType() == V8Value.UNSIGNED_INT_8_ARRAY;
    } finally {
      result.close();
    }
  }
};

  @Override
  public Boolean invoke(final V8Object receiver, final V8Array parameters) {
    V8TypedArray result = ((TypedArray) V8ObjectUtils.getValue(parameters, 0)).getV8TypedArray();
    try {
      return result.getType() == V8Value.UNSIGNED_INT_8_CLAMPED_ARRAY;
    } finally {
      result.close();
    }
  }
};

@Test
public void testArrayTypedArrayValue_Int8ArrayWithoutBackingStore() {
  V8Array root = v8.executeArrayScript(""
      + "var intsArray = new Int8Array(24);\n"
      + "var root = [intsArray];\n"
      + "root;\n");
  V8TypedArray result = ((TypedArray) V8ObjectUtils.getValue(root, 0)).getV8TypedArray();
  assertEquals(24, result.length());
  root.close();
  result.close();
}

@Test
public void testTypedArrayGetValue_Int8ArrayWithoutBackingStore() {
  V8Array intsArray = v8.executeArrayScript(""
      + "var intsArray = new Int8Array(24);\n"
      + "intsArray");
  V8TypedArray result = ((TypedArray) V8ObjectUtils.getValue(intsArray)).getV8TypedArray();
  assertEquals(24, result.length());
  intsArray.close();
  result.close();
}