/*
 * 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();
  }
}