/*
* Copyright 2012 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.typedarrays.shared;
/**
* Factory class for various typed arrays. Behavior of all other methods is
* undefined if {@link #isSupported()} returns false.
* <p>
* In client code, the various types are implemented by JavaScriptObjects,
* so you cannot reliable use instanceof checks on any of the returned
* implementations.
*/
public class TypedArrays {
/**
* Base class of implementations for creating various typed array structures.
* <p>
* <b>*** NOT A PUBLIC API ***</b>
*/
public abstract static class Impl {
/**
* Get the number of elements in a number of bytes, throwing an exception
* if it isn't an integral number.
*
* @param byteLength
* @param elemLength length of each element in bytes
* @return count of elements
* @throws IllegalArgumentException if {@code byteLength} isn't an integral
* multiple of {@code elemLength}
*/
protected static int getElementCount(int byteLength, int elemLength) {
int count = byteLength / elemLength;
if (count * elemLength != byteLength) {
throw new IllegalArgumentException();
}
return count;
}
public abstract ArrayBuffer createArrayBuffer(int length);
public DataView createDataView(ArrayBuffer buffer) {
return createDataView(buffer, 0, buffer.byteLength());
}
public DataView createDataView(ArrayBuffer buffer, int offset) {
return createDataView(buffer, offset, buffer.byteLength() - offset);
}
public abstract DataView createDataView(ArrayBuffer buffer, int byteOffset, int byteLength);
public Float32Array createFloat32Array(ArrayBuffer buffer) {
return createFloat32Array(buffer, 0, getElementCount(buffer.byteLength(),
Float32Array.BYTES_PER_ELEMENT));
}
public Float32Array createFloat32Array(ArrayBuffer buffer, int byteOffset) {
return createFloat32Array(buffer, byteOffset, getElementCount(
buffer.byteLength() - byteOffset, Float32Array.BYTES_PER_ELEMENT));
}
public abstract Float32Array createFloat32Array(ArrayBuffer buffer, int byteOffset, int length);
public Float32Array createFloat32Array(float[] array) {
Float32Array result = createFloat32Array(array.length);
result.set(array);
return result;
}
public Float32Array createFloat32Array(int length) {
return createFloat32Array(createArrayBuffer(length * Float32Array.BYTES_PER_ELEMENT));
}
public Float64Array createFloat64Array(ArrayBuffer buffer) {
return createFloat64Array(buffer, 0, getElementCount(buffer.byteLength(),
Float64Array.BYTES_PER_ELEMENT));
}
public Float64Array createFloat64Array(ArrayBuffer buffer, int byteOffset) {
return createFloat64Array(buffer, byteOffset, getElementCount(
buffer.byteLength() - byteOffset, Float64Array.BYTES_PER_ELEMENT));
}
public abstract Float64Array createFloat64Array(ArrayBuffer buffer, int byteOffset, int length);
public Float64Array createFloat64Array(double[] array) {
Float64Array result = createFloat64Array(array.length);
result.set(array);
return result;
}
public Float64Array createFloat64Array(int length) {
return createFloat64Array(createArrayBuffer(length * Float64Array.BYTES_PER_ELEMENT));
}
public Int16Array createInt16Array(ArrayBuffer buffer) {
return createInt16Array(buffer, 0, getElementCount(buffer.byteLength(),
Int16Array.BYTES_PER_ELEMENT));
}
public Int16Array createInt16Array(ArrayBuffer buffer, int byteOffset) {
return createInt16Array(buffer, byteOffset, getElementCount(
buffer.byteLength() - byteOffset, Int16Array.BYTES_PER_ELEMENT));
}
public abstract Int16Array createInt16Array(ArrayBuffer buffer, int byteOffset, int length);
public Int16Array createInt16Array(int length) {
return createInt16Array(createArrayBuffer(length * Int16Array.BYTES_PER_ELEMENT));
}
public Int16Array createInt16Array(short[] array) {
Int16Array result = createInt16Array(array.length);
result.set(array);
return result;
}
public Int32Array createInt32Array(ArrayBuffer buffer) {
return createInt32Array(buffer, 0, getElementCount(buffer.byteLength(),
Int32Array.BYTES_PER_ELEMENT));
}
public Int32Array createInt32Array(ArrayBuffer buffer, int byteOffset) {
return createInt32Array(buffer, byteOffset, getElementCount(
buffer.byteLength() - byteOffset, Int32Array.BYTES_PER_ELEMENT));
}
public abstract Int32Array createInt32Array(ArrayBuffer buffer, int byteOffset, int length);
public Int32Array createInt32Array(int length) {
return createInt32Array(createArrayBuffer(length * Int32Array.BYTES_PER_ELEMENT));
}
public Int32Array createInt32Array(int[] array) {
Int32Array result = createInt32Array(array.length);
result.set(array);
return result;
}
public Int8Array createInt8Array(ArrayBuffer buffer) {
return createInt8Array(buffer, 0, buffer.byteLength());
}
public Int8Array createInt8Array(ArrayBuffer buffer, int byteOffset) {
return createInt8Array(buffer, byteOffset, buffer.byteLength() - byteOffset);
}
public abstract Int8Array createInt8Array(ArrayBuffer buffer, int byteOffset, int length);
public Int8Array createInt8Array(byte[] array) {
Int8Array result = createInt8Array(array.length);
result.set(array);
return result;
}
public Int8Array createInt8Array(int length) {
return createInt8Array(createArrayBuffer(length));
}
public Uint16Array createUint16Array(ArrayBuffer buffer) {
return createUint16Array(buffer, 0, getElementCount(buffer.byteLength(),
Uint16Array.BYTES_PER_ELEMENT));
}
public Uint16Array createUint16Array(ArrayBuffer buffer, int byteOffset) {
return createUint16Array(buffer, byteOffset, getElementCount(
buffer.byteLength() - byteOffset, Uint16Array.BYTES_PER_ELEMENT));
}
public abstract Uint16Array createUint16Array(ArrayBuffer buffer, int byteOffset, int length);
public Uint16Array createUint16Array(int length) {
return createUint16Array(createArrayBuffer(length * Uint16Array.BYTES_PER_ELEMENT));
}
public Uint16Array createUint16Array(int[] array) {
Uint16Array result = createUint16Array(array.length);
result.set(array);
return result;
}
public Uint32Array createUint32Array(ArrayBuffer buffer) {
return createUint32Array(buffer, 0, getElementCount(buffer.byteLength(),
Uint32Array.BYTES_PER_ELEMENT));
}
public Uint32Array createUint32Array(ArrayBuffer buffer, int byteOffset) {
return createUint32Array(buffer, byteOffset, getElementCount(
buffer.byteLength() - byteOffset, Uint32Array.BYTES_PER_ELEMENT));
}
public abstract Uint32Array createUint32Array(ArrayBuffer buffer, int byteOffset, int length);
public Uint32Array createUint32Array(double[] array) {
Uint32Array result = createUint32Array(array.length);
result.set(array);
return result;
}
public Uint32Array createUint32Array(int length) {
return createUint32Array(createArrayBuffer(length * Uint32Array.BYTES_PER_ELEMENT));
}
public Uint32Array createUint32Array(long[] array) {
Uint32Array result = createUint32Array(array.length);
result.set(array);
return result;
}
public Uint8Array createUint8Array(ArrayBuffer buffer) {
return createUint8Array(buffer, 0, buffer.byteLength());
}
public Uint8Array createUint8Array(ArrayBuffer buffer, int byteOffset) {
return createUint8Array(buffer, byteOffset, buffer.byteLength() - byteOffset);
}
public abstract Uint8Array createUint8Array(ArrayBuffer buffer, int byteOffset, int length);
public Uint8Array createUint8Array(int length) {
return createUint8Array(createArrayBuffer(length));
}
public Uint8Array createUint8Array(short[] array) {
Uint8Array result = createUint8Array(array.length);
result.set(array);
return result;
}
public Uint8ClampedArray createUint8ClampedArray(ArrayBuffer buffer) {
return createUint8ClampedArray(buffer, 0, buffer.byteLength());
}
public Uint8ClampedArray createUint8ClampedArray(ArrayBuffer buffer, int byteOffset) {
return createUint8ClampedArray(buffer, byteOffset, buffer.byteLength() - byteOffset);
}
public abstract Uint8ClampedArray createUint8ClampedArray(ArrayBuffer buffer, int byteOffset,
int length);
public Uint8ClampedArray createUint8ClampedArray(int length) {
return createUint8ClampedArray(createArrayBuffer(length));
}
public Uint8ClampedArray createUint8ClampedArray(short[] array) {
Uint8ClampedArray result = createUint8ClampedArray(array.length);
result.set(array);
return result;
}
/**
* Check if the current environment might possibly support typed arrays.
* <p>
* The default implementation always returns true, and this is intended to
* be a static check based on deffered-bound parameters.
*
* @return true if the current environment might possibly
* support typed arrays
*/
protected boolean mightBeSupported() {
return true;
}
/**
* Check if the current environment actually does support typed arrays
* (including emulation). There is no partial support, so if true is
* returned, there must be acceptable implementations for all of the
* {@code createXXX} methods.
*
* @return true if the current environment actually does support typed
* arrays
*/
protected boolean runtimeSupportCheck() {
return false;
}
}
/**
* This class exists to keep clinit calls from littering callsites when compiled
* to JS.
*/
private static class Instance {
protected static final Impl impl = TypedArraysFactory.createImpl();
}
/**
* Create a new {@link ArrayBuffer} of {@code length} bytes.
*
* @param length length of buffer in bytes
* @return an {@link ArrayBuffer} instance
*/
public static ArrayBuffer createArrayBuffer(int length) {
return Instance.impl.createArrayBuffer(length);
}
/**
* Create a new {@link DataView} instance on an {@link ArrayBuffer}.
*
* @param buffer {@link ArrayBuffer}
* @return {@link DataView} instance
*/
public static DataView createDataView(ArrayBuffer buffer) {
return Instance.impl.createDataView(buffer);
}
/**
* Create a new {@link DataView} instance on an {@link ArrayBuffer}, starting
* at an offset of {@code byteOffset}.
*
* @param buffer {@link ArrayBuffer}
* @param byteOffset offset into buffer
* @return {@link DataView} instance
*/
public static DataView createDataView(ArrayBuffer buffer, int byteOffset) {
return Instance.impl.createDataView(buffer, byteOffset);
}
/**
* Create a new {@link DataView} instance on an {@link ArrayBuffer}, starting
* at an offset of {@code byteOffset} and continuing for {@code length}
* bytes.
*
* @param buffer {@link ArrayBuffer}
* @param byteOffset offset into buffer
* @param byteLength length of view in bytes
* @return {@link DataView} instance
*/
public static DataView createDataView(ArrayBuffer buffer, int byteOffset, int byteLength) {
return Instance.impl.createDataView(buffer, byteOffset, byteLength);
}
/**
* Create a {@link Float32Array} instance on {@code buffer}, starting at
* starting at the beginning of the buffer and continuing to the end (which
* must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @return an {@link Float32Array} instance
*/
public static Float32Array createFloat32Array(ArrayBuffer buffer) {
return Instance.impl.createFloat32Array(buffer);
}
/**
* Create a {@link Float32Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing to the end of the buffer
* (which must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @return an {@link Float32Array} instance
*/
public static Float32Array createFloat32Array(ArrayBuffer buffer, int byteOffset) {
return Instance.impl.createFloat32Array(buffer, byteOffset);
}
/**
* Create a {@link Float32Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing for {@code length}
* elements.
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @param length number of elements in the resulting array
* @return an {@link Float32Array} instance
*/
public static Float32Array createFloat32Array(ArrayBuffer buffer, int byteOffset, int length) {
return Instance.impl.createFloat32Array(buffer, byteOffset, length);
}
/**
* Create a {@link Float32Array} instance of {@code length} elements, backed
* by a new {@link ArrayBuffer}.
*
* @param length size of array
* @return a {@link Float32Array} instance
*/
public static Float32Array createFloat32Array(int length) {
return Instance.impl.createFloat32Array(length);
}
/**
* Create a {@link Float64Array} instance on {@code buffer}, starting at
* starting at the beginning of the buffer and continuing to the end (which
* must be an integral number of elements).
* <p>
* <b>Note that Safari does not currently support Float64 Arrays!</b>
*
* @param buffer underlying {@link ArrayBuffer}
* @return an {@link Float64Array} instance
*/
public static Float64Array createFloat64Array(ArrayBuffer buffer) {
return Instance.impl.createFloat64Array(buffer);
}
/**
* Create a {@link Float64Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing to the end of the buffer
* (which must be an integral number of elements).
* <p>
* <b>Note that Safari does not currently support Float64 Arrays!</b>
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @return an {@link Float64Array} instance
*/
public static Float64Array createFloat64Array(ArrayBuffer buffer, int byteOffset) {
return Instance.impl.createFloat64Array(buffer, byteOffset);
}
/**
* Create a {@link Float64Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing for {@code length}
* elements.
* <p>
* <b>Note that Safari does not currently support Float64 Arrays!</b>
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @param length number of elements in the resulting array
* @return an {@link Float64Array} instance
*/
public static Float64Array createFloat64Array(ArrayBuffer buffer, int byteOffset, int length) {
return Instance.impl.createFloat64Array(buffer, byteOffset, length);
}
/**
* Create a {@link Float64Array} instance of {@code length} elements, backed
* by a new {@link ArrayBuffer}.
* <p>
* <b>Note that Safari does not currently support Float64 Arrays!</b>
*
* @param length size of array
* @return a {@link Float64Array} instance
*/
public static Float64Array createFloat64Array(int length) {
return Instance.impl.createFloat64Array(length);
}
/**
* Create a {@link Int16Array} instance on {@code buffer}, starting at
* starting at the beginning of the buffer and continuing to the end (which
* must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @return an {@link Int16Array} instance
*/
public static Int16Array createInt16Array(ArrayBuffer buffer) {
return Instance.impl.createInt16Array(buffer);
}
/**
* Create a {@link Int16Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing to the end of the buffer
* (which must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @return an {@link Int16Array} instance
*/
public static Int16Array createInt16Array(ArrayBuffer buffer, int byteOffset) {
return Instance.impl.createInt16Array(buffer, byteOffset);
}
/**
* Create a {@link Int16Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing for {@code length}
* elements.
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @param length number of elements in the resulting array
* @return an {@link Int16Array} instance
*/
public static Int16Array createInt16Array(ArrayBuffer buffer, int byteOffset, int length) {
return Instance.impl.createInt16Array(buffer, byteOffset, length);
}
/**
* Create a {@link Int16Array} instance of {@code length} elements, backed
* by a new {@link ArrayBuffer}.
*
* @param length size of array
* @return a {@link Int16Array} instance
*/
public static Int16Array createInt16Array(int length) {
return Instance.impl.createInt16Array(length);
}
/**
* Create a {@link Int32Array} instance on {@code buffer}, starting at
* starting at the beginning of the buffer and continuing to the end (which
* must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @return an {@link Int32Array} instance
*/
public static Int32Array createInt32Array(ArrayBuffer buffer) {
return Instance.impl.createInt32Array(buffer);
}
/**
* Create a {@link Int32Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing to the end of the buffer
* (which must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @return an {@link Int32Array} instance
*/
public static Int32Array createInt32Array(ArrayBuffer buffer, int byteOffset) {
return Instance.impl.createInt32Array(buffer, byteOffset);
}
/**
* Create a {@link Int32Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing for {@code length}
* elements.
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @param length number of elements in the resulting array
* @return an {@link Int32Array} instance
*/
public static Int32Array createInt32Array(ArrayBuffer buffer, int byteOffset, int length) {
return Instance.impl.createInt32Array(buffer, byteOffset, length);
}
/**
* Create a {@link Int32Array} instance of {@code length} elements, backed
* by a new {@link ArrayBuffer}.
*
* @param length size of array
* @return a {@link Int32Array} instance
*/
public static Int32Array createInt32Array(int length) {
return Instance.impl.createInt32Array(length);
}
/**
* Create a {@link Int8Array} instance on {@code buffer}, starting at
* starting at the beginning of the buffer and continuing to the end.
*
* @param buffer underlying {@link ArrayBuffer}
* @return an {@link Int8Array} instance
*/
public static Int8Array createInt8Array(ArrayBuffer buffer) {
return Instance.impl.createInt8Array(buffer);
}
/**
* Create a {@link Int8Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing to the end of the buffer
* (which must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @return an {@link Int8Array} instance
*/
public static Int8Array createInt8Array(ArrayBuffer buffer, int byteOffset) {
return Instance.impl.createInt8Array(buffer, byteOffset);
}
/**
* Create a {@link Int8Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing for {@code length}
* elements.
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @param length number of elements in the resulting array
* @return an {@link Int8Array} instance
*/
public static Int8Array createInt8Array(ArrayBuffer buffer, int byteOffset, int length) {
return Instance.impl.createInt8Array(buffer, byteOffset, length);
}
/**
* Create a {@link Int8Array} instance of {@code length} elements, backed
* by a new {@link ArrayBuffer}.
*
* @param length size of array
* @return a {@link Int8Array} instance
*/
public static Int8Array createInt8Array(int length) {
return Instance.impl.createInt8Array(length);
}
/**
* Create a {@link Uint16Array} instance on {@code buffer}, starting at
* starting at the beginning of the buffer and continuing to the end (which
* must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @return an {@link Uint16Array} instance
*/
public static Uint16Array createUint16Array(ArrayBuffer buffer) {
return Instance.impl.createUint16Array(buffer);
}
/**
* Create a {@link Uint16Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing to the end of the buffer
* (which must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @return an {@link Uint16Array} instance
*/
public static Uint16Array createUint16Array(ArrayBuffer buffer, int byteOffset) {
return Instance.impl.createUint16Array(buffer, byteOffset);
}
/**
* Create a {@link Uint16Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing for {@code length}
* elements.
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @param length number of elements in the resulting array
* @return an {@link Uint16Array} instance
*/
public static Uint16Array createUint16Array(ArrayBuffer buffer, int byteOffset, int length) {
return Instance.impl.createUint16Array(buffer, byteOffset, length);
}
/**
* Create a {@link Uint16Array} instance of {@code length} elements, backed
* by a new {@link ArrayBuffer}.
*
* @param length size of array
* @return a {@link Uint16Array} instance
*/
public static Uint16Array createUint16Array(int length) {
return Instance.impl.createUint16Array(length);
}
/**
* Create a {@link Uint32Array} instance on {@code buffer}, starting at
* starting at the beginning of the buffer and continuing to the end (which
* must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @return an {@link Uint32Array} instance
*/
public static Uint32Array createUint32Array(ArrayBuffer buffer) {
return Instance.impl.createUint32Array(buffer);
}
/**
* Create a {@link Uint32Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing to the end of the buffer
* (which must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @return an {@link Uint32Array} instance
*/
public static Uint32Array createUint32Array(ArrayBuffer buffer, int byteOffset) {
return Instance.impl.createUint32Array(buffer, byteOffset);
}
/**
* Create a {@link Uint32Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing for {@code length}
* elements.
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @param length number of elements in the resulting array
* @return an {@link Uint32Array} instance
*/
public static Uint32Array createUint32Array(ArrayBuffer buffer, int byteOffset, int length) {
return Instance.impl.createUint32Array(buffer, byteOffset, length);
}
/**
* Create a {@link Uint32Array} instance of {@code length} elements, backed
* by a new {@link ArrayBuffer}.
*
* @param length size of array
* @return a {@link Uint32Array} instance
*/
public static Uint32Array createUint32Array(int length) {
return Instance.impl.createUint32Array(length);
}
/**
* Create a {@link Uint8Array} instance on {@code buffer}, starting at
* starting at the beginning of the buffer and continuing to the end (which
* must be an integral number of elements).
*
* @param buffer underlying {@link ArrayBuffer}
* @return an {@link Uint8Array} instance
*/
public static Uint8Array createUint8Array(ArrayBuffer buffer) {
return Instance.impl.createUint8Array(buffer);
}
/**
* Create a {@link Uint8Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing to the end of the buffer.
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @return an {@link Uint8Array} instance
*/
public static Uint8Array createUint8Array(ArrayBuffer buffer, int byteOffset) {
return Instance.impl.createUint8Array(buffer, byteOffset);
}
/**
* Create a {@link Uint8Array} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing for {@code length}
* elements.
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @param length number of elements in the resulting array
* @return an {@link Uint8Array} instance
*/
public static Uint8Array createUint8Array(ArrayBuffer buffer, int byteOffset, int length) {
return Instance.impl.createUint8Array(buffer, byteOffset, length);
}
/**
* Create a {@link Uint8Array} instance of {@code length} elements, backed
* by a new {@link ArrayBuffer}.
*
* @param length size of array
* @return a {@link Uint8Array} instance
*/
public static Uint8Array createUint8Array(int length) {
return Instance.impl.createUint8Array(length);
}
/**
* Create a {@link Uint8ClampedArray} instance on {@code buffer}, starting at
* starting at the beginning of the buffer and continuing to the end.
*
* @param buffer underlying {@link ArrayBuffer}
* @return an {@link Uint8ClampedArray} instance
*/
public static Uint8ClampedArray createUint8ClampedArray(ArrayBuffer buffer) {
return Instance.impl.createUint8ClampedArray(buffer, 0, buffer.byteLength());
}
/**
* Create a {@link Uint8ClampedArray} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing to the end of the buffer.
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @return an {@link Uint8ClampedArray} instance
*/
public static Uint8ClampedArray createUint8ClampedArray(ArrayBuffer buffer, int byteOffset) {
return Instance.impl.createUint8ClampedArray(buffer, byteOffset);
}
/**
* Create a {@link Uint8ClampedArray} instance on {@code buffer}, starting at
* {@code byteOffset} into the buffer, continuing for {@code length}
* elements.
*
* @param buffer underlying {@link ArrayBuffer}
* @param byteOffset byte offset from the start of {@code buffer}
* @param length number of elements in the resulting array
* @return an {@link Uint8ClampedArray} instance
*/
public static Uint8ClampedArray createUint8ClampedArray(ArrayBuffer buffer,
int byteOffset, int length) {
return Instance.impl.createUint8ClampedArray(buffer, byteOffset, length);
}
/**
* Create a {@link Uint8ClampedArray} instance of {@code length} elements, backed
* by a new {@link ArrayBuffer}.
*
* @param length size of array
* @return a {@link Uint8ClampedArray} instance
*/
public static Uint8ClampedArray createUint8ClampedArray(int length) {
return Instance.impl.createUint8ClampedArray(length);
}
/**
* Check if the current environment supports typed arrays. Behavior of the
* various {@code createXXX} methods is undefined if this method returns
* {@code false}, but will typically throw some exception.
*
* @return true if typed arrays are support.
*/
public static boolean isSupported() {
return Instance.impl.mightBeSupported() && Instance.impl.runtimeSupportCheck();
}
}