jdk8-mips64-public/nashorn: src/jdk/nashorn/internal/objects/NativeUint16Array.java@61ffdd1b89f2

     1 /*

     2  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    26 package jdk.nashorn.internal.objects;

    28 import static jdk.nashorn.internal.codegen.CompilerConstants.specialCall;

    30 import java.lang.invoke.MethodHandle;

    31 import java.lang.invoke.MethodHandles;

    32 import java.nio.ByteBuffer;

    33 import java.nio.CharBuffer;

    34 import jdk.nashorn.internal.objects.annotations.Attribute;

    35 import jdk.nashorn.internal.objects.annotations.Constructor;

    36 import jdk.nashorn.internal.objects.annotations.Function;

    37 import jdk.nashorn.internal.objects.annotations.Property;

    38 import jdk.nashorn.internal.objects.annotations.ScriptClass;

    39 import jdk.nashorn.internal.objects.annotations.Where;

    40 import jdk.nashorn.internal.runtime.JSType;

    41 import jdk.nashorn.internal.runtime.PropertyMap;

    42 import jdk.nashorn.internal.runtime.ScriptObject;

    43 import jdk.nashorn.internal.runtime.arrays.ArrayData;

    44 import jdk.nashorn.internal.runtime.arrays.TypedArrayData;

    46 /**

    47  * Uint16 array for TypedArray extension

    48  */

    49 @ScriptClass("Uint16Array")

    50 public final class NativeUint16Array extends ArrayBufferView {

    51     /**

    52      * The size in bytes of each element in the array.

    53      */

    54     @Property(attributes = Attribute.NOT_ENUMERABLE | Attribute.NOT_WRITABLE | Attribute.NOT_CONFIGURABLE, where = Where.CONSTRUCTOR)

    55     public static final int BYTES_PER_ELEMENT = 2;

    57     // initialized by nasgen

    58     @SuppressWarnings("unused")

    59     private static PropertyMap $nasgenmap$;

    61     private static final Factory FACTORY = new Factory(BYTES_PER_ELEMENT) {

    62         @Override

    63         public ArrayBufferView construct(final NativeArrayBuffer buffer, final int byteOffset, final int length) {

    64             return new NativeUint16Array(buffer, byteOffset, length);

    65         }

    67         @Override

    68         public Uint16ArrayData createArrayData(final ByteBuffer nb, final int start, final int end) {

    69             return new Uint16ArrayData(nb.asCharBuffer(), start, end);

    70         }

    72         @Override

    73         public String getClassName() {

    74             return "Uint16Array";

    75         }

    76     };

    78     private static final class Uint16ArrayData extends TypedArrayData<CharBuffer> {

    80         private static final MethodHandle GET_ELEM = specialCall(MethodHandles.lookup(), Uint16ArrayData.class, "getElem", int.class, int.class).methodHandle();

    81         private static final MethodHandle SET_ELEM = specialCall(MethodHandles.lookup(), Uint16ArrayData.class, "setElem", void.class, int.class, int.class).methodHandle();

    83         private Uint16ArrayData(final CharBuffer nb, final int start, final int end) {

    84             super(((CharBuffer)nb.position(start).limit(end)).slice(), end - start);

    85         }

    87         @Override

    88         protected MethodHandle getGetElem() {

    89             return GET_ELEM;

    90         }

    92         @Override

    93         protected MethodHandle getSetElem() {

    94             return SET_ELEM;

    95         }

    97         private int getElem(final int index) {

    98             try {

    99                 return nb.get(index);

   100             } catch (final IndexOutOfBoundsException e) {

   101                 throw new ClassCastException(); //force relink - this works for unoptimistic too

   102             }

   103         }

   105         private void setElem(final int index, final int elem) {

   106             try {

   107                 if (index < nb.limit()) {

   108                     nb.put(index, (char) elem);

   109                 }

   110             } catch (final IndexOutOfBoundsException e) {

   111                 throw new ClassCastException();

   112             }

   113         }

   115         @Override

   116         public boolean isUnsigned() {

   117             return true;

   118         }

   120         @Override

   121         public Class<?> getElementType() {

   122             return int.class;

   123         }

   125         @Override

   126         public Class<?> getBoxedElementType() {

   127             return Integer.class;

   128         }

   130         @Override

   131         public int getInt(final int index) {

   132             return getElem(index);

   133         }

   135         @Override

   136         public int getIntOptimistic(final int index, final int programPoint) {

   137             return getElem(index);

   138         }

   140         @Override

   141         public double getDouble(final int index) {

   142             return getInt(index);

   143         }

   145         @Override

   146         public double getDoubleOptimistic(final int index, final int programPoint) {

   147             return getElem(index);

   148         }

   150         @Override

   151         public Object getObject(final int index) {

   152             return getInt(index);

   153         }

   155         @Override

   156         public ArrayData set(final int index, final Object value, final boolean strict) {

   157             return set(index, JSType.toInt32(value), strict);

   158         }

   160         @Override

   161         public ArrayData set(final int index, final int value, final boolean strict) {

   162             setElem(index, value);

   163             return this;

   164         }

   166         @Override

   167         public ArrayData set(final int index, final double value, final boolean strict) {

   168             return set(index, (int)value, strict);

   169         }

   170     }

   172     /**

   173      * Constructor

   174      *

   175      * @param newObj is this typed array instantiated with the new operator

   176      * @param self   self reference

   177      * @param args   args

   178      *

   179      * @return new typed array

   180      */

   181     @Constructor(arity = 1)

   182     public static NativeUint16Array constructor(final boolean newObj, final Object self, final Object... args) {

   183         return (NativeUint16Array)constructorImpl(newObj, args, FACTORY);

   184     }

   186     NativeUint16Array(final NativeArrayBuffer buffer, final int byteOffset, final int length) {

   187         super(buffer, byteOffset, length);

   188     }

   190     @Override

   191     protected Factory factory() {

   192         return FACTORY;

   193     }

   195     /**

   196      * Set values

   197      * @param self   self reference

   198      * @param array  multiple values of array's type to set

   199      * @param offset optional start index, interpreted  0 if undefined

   200      * @return undefined

   201      */

   202     @Function(attributes = Attribute.NOT_ENUMERABLE)

   203     protected static Object set(final Object self, final Object array, final Object offset) {

   204         return ArrayBufferView.setImpl(self, array, offset);

   205     }

   207     /**

   208      * Returns a new TypedArray view of the ArrayBuffer store for this TypedArray,

   209      * referencing the elements at begin, inclusive, up to end, exclusive. If either

   210      * begin or end is negative, it refers to an index from the end of the array,

   211      * as opposed to from the beginning.

   212      * <p>

   213      * If end is unspecified, the subarray contains all elements from begin to the end

   214      * of the TypedArray. The range specified by the begin and end values is clamped to

   215      * the valid index range for the current array. If the computed length of the new

   216      * TypedArray would be negative, it is clamped to zero.

   217      * <p>

   218      * The returned TypedArray will be of the same type as the array on which this

   219      * method is invoked.

   220      *

   221      * @param self self reference

   222      * @param begin begin position

   223      * @param end end position

   224      *

   225      * @return sub array

   226      */

   227     @Function(attributes = Attribute.NOT_ENUMERABLE)

   228     protected static NativeUint16Array subarray(final Object self, final Object begin, final Object end) {

   229         return (NativeUint16Array)ArrayBufferView.subarrayImpl(self, begin, end);

   230     }

   232     @Override

   233     protected ScriptObject getPrototype(final Global global) {

   234         return global.getUint16ArrayPrototype();

   235     }

   236 }

Mercurial > jdk8-mips64-public > nashorn / file revision

src/jdk/nashorn/internal/objects/NativeUint16Array.java@61ffdd1b89f2

src/jdk/nashorn/internal/objects/NativeUint16Array.java