/*

  * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.

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

  *

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

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

  * published by the Free Software Foundation.  Oracle designates this

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

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

  *

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

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

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

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

  * accompanied this code).

  *

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

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

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

  *

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

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

  * questions.

  */

 package sun.invoke.util;

 public enum Wrapper {

     BOOLEAN(Boolean.class, boolean.class, 'Z', (Boolean)false, new boolean[0], Format.unsigned(1)),

     // These must be in the order defined for widening primitive conversions in JLS 5.1.2

     BYTE(Byte.class, byte.class, 'B', (Byte)(byte)0, new byte[0], Format.signed(8)),

     SHORT(Short.class, short.class, 'S', (Short)(short)0, new short[0], Format.signed(16)),

     CHAR(Character.class, char.class, 'C', (Character)(char)0, new char[0], Format.unsigned(16)),

     INT(Integer.class, int.class, 'I', (Integer)/*(int)*/0, new int[0], Format.signed(32)),

     LONG(Long.class, long.class, 'J', (Long)(long)0, new long[0], Format.signed(64)),

     FLOAT(Float.class, float.class, 'F', (Float)(float)0, new float[0], Format.floating(32)),

     DOUBLE(Double.class, double.class, 'D', (Double)(double)0, new double[0], Format.floating(64)),

     //NULL(Null.class, null.class, 'N', null, null, Format.other(1)),

     OBJECT(Object.class, Object.class, 'L', null, new Object[0], Format.other(1)),

     // VOID must be the last type, since it is "assignable" from any other type:

     VOID(Void.class, void.class, 'V', null, null, Format.other(0)),

     ;

     private final Class<?> wrapperType;

     private final Class<?> primitiveType;

     private final char     basicTypeChar;

     private final Object   zero;

     private final Object   emptyArray;

     private final int      format;

     private final String   wrapperSimpleName;

     private final String   primitiveSimpleName;

     private Wrapper(Class<?> wtype, Class<?> ptype, char tchar, Object zero, Object emptyArray, int format) {

         this.wrapperType = wtype;

         this.primitiveType = ptype;

         this.basicTypeChar = tchar;

         this.zero = zero;

         this.emptyArray = emptyArray;

         this.format = format;

         this.wrapperSimpleName = wtype.getSimpleName();

         this.primitiveSimpleName = ptype.getSimpleName();

     }

     /** For debugging, give the details of this wrapper. */

     public String detailString() {

         return wrapperSimpleName+

                 java.util.Arrays.asList(wrapperType, primitiveType,

                 basicTypeChar, zero,

                 "0x"+Integer.toHexString(format));

     }

     private static abstract class Format {

         static final int SLOT_SHIFT = 0, SIZE_SHIFT = 2, KIND_SHIFT = 12;

         static final int

                 SIGNED   = (-1) << KIND_SHIFT,

                 UNSIGNED = 0    << KIND_SHIFT,

                 FLOATING = 1    << KIND_SHIFT;

         static final int

                 SLOT_MASK = ((1<<(SIZE_SHIFT-SLOT_SHIFT))-1),

                 SIZE_MASK = ((1<<(KIND_SHIFT-SIZE_SHIFT))-1);

         static int format(int kind, int size, int slots) {

             assert(((kind >> KIND_SHIFT) << KIND_SHIFT) == kind);

             assert((size & (size-1)) == 0); // power of two

             assert((kind == SIGNED)   ? (size > 0) :

                    (kind == UNSIGNED) ? (size > 0) :

                    (kind == FLOATING) ? (size == 32 || size == 64)  :

                    false);

             assert((slots == 2) ? (size == 64) :

                    (slots == 1) ? (size <= 32) :

                    false);

             return kind | (size << SIZE_SHIFT) | (slots << SLOT_SHIFT);

         }

         static final int

                 INT      = SIGNED   | (32 << SIZE_SHIFT) | (1 << SLOT_SHIFT),

                 SHORT    = SIGNED   | (16 << SIZE_SHIFT) | (1 << SLOT_SHIFT),

                 BOOLEAN  = UNSIGNED | (1  << SIZE_SHIFT) | (1 << SLOT_SHIFT),

                 CHAR     = UNSIGNED | (16 << SIZE_SHIFT) | (1 << SLOT_SHIFT),

                 FLOAT    = FLOATING | (32 << SIZE_SHIFT) | (1 << SLOT_SHIFT),

                 VOID     = UNSIGNED | (0  << SIZE_SHIFT) | (0 << SLOT_SHIFT),

                 NUM_MASK = (-1) << SIZE_SHIFT;

         static int signed(int size)   { return format(SIGNED,   size, (size > 32 ? 2 : 1)); }

         static int unsigned(int size) { return format(UNSIGNED, size, (size > 32 ? 2 : 1)); }

         static int floating(int size) { return format(FLOATING, size, (size > 32 ? 2 : 1)); }

         static int other(int slots)   { return slots << SLOT_SHIFT; }

     }

     /// format queries:

     /** How many bits are in the wrapped value?  Returns 0 for OBJECT or VOID. */

     public int     bitWidth()      { return (format >> Format.SIZE_SHIFT) & Format.SIZE_MASK; }

     /** How many JVM stack slots occupied by the wrapped value?  Returns 0 for VOID. */

     public int     stackSlots()    { return (format >> Format.SLOT_SHIFT) & Format.SLOT_MASK; }

     /** Does the wrapped value occupy a single JVM stack slot? */

     public boolean isSingleWord()  { return (format & (1 << Format.SLOT_SHIFT)) != 0; }

     /** Does the wrapped value occupy two JVM stack slots? */

     public boolean isDoubleWord()  { return (format & (2 << Format.SLOT_SHIFT)) != 0; }

     /** Is the wrapped type numeric (not void or object)? */

     public boolean isNumeric()     { return (format & Format.NUM_MASK) != 0; }

     /** Is the wrapped type a primitive other than float, double, or void? */

     public boolean isIntegral()    { return isNumeric() && format < Format.FLOAT; }

     /** Is the wrapped type one of int, boolean, byte, char, or short? */

     public boolean isSubwordOrInt() { return isIntegral() && isSingleWord(); }

     /* Is the wrapped value a signed integral type (one of byte, short, int, or long)? */

     public boolean isSigned()      { return format < Format.VOID; }

     /* Is the wrapped value an unsigned integral type (one of boolean or char)? */

     public boolean isUnsigned()    { return format >= Format.BOOLEAN && format < Format.FLOAT; }

     /** Is the wrapped type either float or double? */

     public boolean isFloating()    { return format >= Format.FLOAT; }

     /** Is the wrapped type either void or a reference? */

     public boolean isOther()       { return (format & ~Format.SLOT_MASK) == 0; }

     /** Does the JLS 5.1.2 allow a variable of this wrapper's

      *  primitive type to be assigned from a value of the given wrapper's primitive type?

      *  Cases:

      *  <ul>

      *  <li>unboxing followed by widening primitive conversion

      *  <li>any type converted to {@code void} (i.e., dropping a method call's value)

      *  <li>boxing conversion followed by widening reference conversion to {@code Object}

      *  </ul>

      *  These are the cases allowed by MethodHandle.asType.

      */

     public boolean isConvertibleFrom(Wrapper source) {

         if (this == source)  return true;

         if (this.compareTo(source) < 0) {

             // At best, this is a narrowing conversion.

             return false;

         }

         // All conversions are allowed in the enum order between floats and signed ints.

         // First detect non-signed non-float types (boolean, char, Object, void).

         boolean floatOrSigned = (((this.format & source.format) & Format.SIGNED) != 0);

         if (!floatOrSigned) {

             if (this.isOther())  return true;

             // can convert char to int or wider, but nothing else

             if (source.format == Format.CHAR)  return true;

             // no other conversions are classified as widening

             return false;

         }

         // All signed and float conversions in the enum order are widening.

         assert(this.isFloating() || this.isSigned());

         assert(source.isFloating() || source.isSigned());

         return true;

     }

     static { assert(checkConvertibleFrom()); }

     private static boolean checkConvertibleFrom() {

         // Check the matrix for correct classification of widening conversions.

         for (Wrapper w : values()) {

             assert(w.isConvertibleFrom(w));

             assert(VOID.isConvertibleFrom(w));

             if (w != VOID) {

                 assert(OBJECT.isConvertibleFrom(w));

                 assert(!w.isConvertibleFrom(VOID));

             }

             // check relations with unsigned integral types:

             if (w != CHAR) {

                 assert(!CHAR.isConvertibleFrom(w));

                 if (!w.isConvertibleFrom(INT))

                     assert(!w.isConvertibleFrom(CHAR));

             }

             if (w != BOOLEAN) {

                 assert(!BOOLEAN.isConvertibleFrom(w));

                 if (w != VOID && w != OBJECT)

                     assert(!w.isConvertibleFrom(BOOLEAN));

             }

             // check relations with signed integral types:

             if (w.isSigned()) {

                 for (Wrapper x : values()) {

                     if (w == x)  continue;

                     if (x.isFloating())

                         assert(!w.isConvertibleFrom(x));

                     else if (x.isSigned()) {

                         if (w.compareTo(x) < 0)

                             assert(!w.isConvertibleFrom(x));

                         else

                             assert(w.isConvertibleFrom(x));

                     }

                 }

             }

             // check relations with floating types:

             if (w.isFloating()) {

                 for (Wrapper x : values()) {

                     if (w == x)  continue;

                     if (x.isSigned())

                         assert(w.isConvertibleFrom(x));

                     else if (x.isFloating()) {

                         if (w.compareTo(x) < 0)

                             assert(!w.isConvertibleFrom(x));

                         else

                             assert(w.isConvertibleFrom(x));

                     }

                 }

             }

         }

         return true;  // i.e., assert(true)

     }

     /** Produce a zero value for the given wrapper type.

      *  This will be a numeric zero for a number or character,

      *  false for a boolean, and null for a reference or void.

      *  The common thread is that this is what is contained

      *  in a default-initialized variable of the given primitive

      *  type.  (For void, it is what a reflective method returns

      *  instead of no value at all.)

      */

     public Object zero() { return zero; }

     /** Produce a zero value for the given wrapper type T.

      *  The optional argument must a type compatible with this wrapper.

      *  Equivalent to {@code this.cast(this.zero(), type)}.

      */

     public <T> T zero(Class<T> type) { return convert(zero, type); }

 //    /** Produce a wrapper for the given wrapper or primitive type. */

 //    public static Wrapper valueOf(Class<?> type) {

 //        if (isPrimitiveType(type))

 //            return forPrimitiveType(type);

 //        else

 //            return forWrapperType(type);

 //    }

     /** Return the wrapper that wraps values of the given type.

      *  The type may be {@code Object}, meaning the {@code OBJECT} wrapper.

      *  Otherwise, the type must be a primitive.

      *  @throws IllegalArgumentException for unexpected types

      */

     public static Wrapper forPrimitiveType(Class<?> type) {

         Wrapper w = findPrimitiveType(type);

         if (w != null)  return w;

         if (type.isPrimitive())

             throw new InternalError(); // redo hash function

         throw newIllegalArgumentException("not primitive: "+type);

     }

     static Wrapper findPrimitiveType(Class<?> type) {

         Wrapper w = FROM_PRIM[hashPrim(type)];

         if (w != null && w.primitiveType == type) {

             return w;

         }

         return null;

     }

     /** Return the wrapper that wraps values into the given wrapper type.

      *  If it is {@code Object}, return {@code OBJECT}.

      *  Otherwise, it must be a wrapper type.

      *  The type must not be a primitive type.

      *  @throws IllegalArgumentException for unexpected types

      */

     public static Wrapper forWrapperType(Class<?> type) {

         Wrapper w = findWrapperType(type);

         if (w != null)  return w;

         for (Wrapper x : values())

             if (x.wrapperType == type)

                 throw new InternalError(); // redo hash function

         throw newIllegalArgumentException("not wrapper: "+type);

     }

     static Wrapper findWrapperType(Class<?> type) {

         Wrapper w = FROM_WRAP[hashWrap(type)];

         if (w != null && w.wrapperType == type) {

             return w;

         }

         return null;

     }

     /** Return the wrapper that corresponds to the given bytecode

      *  signature character.  Return {@code OBJECT} for the character 'L'.

      *  @throws IllegalArgumentException for any non-signature character or {@code '['}.

      */

     public static Wrapper forBasicType(char type) {

         Wrapper w = FROM_CHAR[hashChar(type)];

         if (w != null && w.basicTypeChar == type) {

             return w;

         }

         for (Wrapper x : values())

             if (w.basicTypeChar == type)

                 throw new InternalError(); // redo hash function

         throw newIllegalArgumentException("not basic type char: "+type);

     }

     /** Return the wrapper for the given type, if it is

      *  a primitive type, else return {@code OBJECT}.

      */

     public static Wrapper forBasicType(Class<?> type) {

         if (type.isPrimitive())

             return forPrimitiveType(type);

         return OBJECT;  // any reference, including wrappers or arrays

     }

     // Note on perfect hashes:

     //   for signature chars c, do (c + (c >> 1)) % 16

     //   for primitive type names n, do (n[0] + n[2]) % 16

     // The type name hash works for both primitive and wrapper names.

     // You can add "java/lang/Object" to the primitive names.

     // But you add the wrapper name Object, use (n[2] + (3*n[1])) % 16.

     private static final Wrapper[] FROM_PRIM = new Wrapper[16];

     private static final Wrapper[] FROM_WRAP = new Wrapper[16];

     private static final Wrapper[] FROM_CHAR = new Wrapper[16];

     private static int hashPrim(Class<?> x) {

         String xn = x.getName();

         if (xn.length() < 3)  return 0;

         return (xn.charAt(0) + xn.charAt(2)) % 16;

     }

     private static int hashWrap(Class<?> x) {

         String xn = x.getName();

         final int offset = 10; assert(offset == "java.lang.".length());

         if (xn.length() < offset+3)  return 0;

         return (3*xn.charAt(offset+1) + xn.charAt(offset+2)) % 16;

     }

     private static int hashChar(char x) {

         return (x + (x >> 1)) % 16;

     }

     static {

         for (Wrapper w : values()) {

             int pi = hashPrim(w.primitiveType);

             int wi = hashWrap(w.wrapperType);

             int ci = hashChar(w.basicTypeChar);

             assert(FROM_PRIM[pi] == null);

             assert(FROM_WRAP[wi] == null);

             assert(FROM_CHAR[ci] == null);

             FROM_PRIM[pi] = w;

             FROM_WRAP[wi] = w;

             FROM_CHAR[ci] = w;

         }

         //assert(jdk.sun.invoke.util.WrapperTest.test(false));

     }

     /** What is the primitive type wrapped by this wrapper? */

     public Class<?> primitiveType() { return primitiveType; }

     /** What is the wrapper type for this wrapper? */

     public Class<?> wrapperType() { return wrapperType; }

     /** What is the wrapper type for this wrapper?

      * Otherwise, the example type must be the wrapper type,

      * or the corresponding primitive type.

      * (For {@code OBJECT}, the example type can be any non-primitive,

      * and is normalized to {@code Object.class}.)

      * The resulting class type has the same type parameter.

      */

     public <T> Class<T> wrapperType(Class<T> exampleType) {

         if (exampleType == wrapperType) {

             return exampleType;

         } else if (exampleType == primitiveType ||

                    wrapperType == Object.class ||

                    exampleType.isInterface()) {

             return forceType(wrapperType, exampleType);

         }

         throw newClassCastException(exampleType, primitiveType);

     }

     private static ClassCastException newClassCastException(Class<?> actual, Class<?> expected) {

         return new ClassCastException(actual + " is not compatible with " + expected);

     }

     /** If {@code type} is a primitive type, return the corresponding

      *  wrapper type, else return {@code type} unchanged.

      */

     public static <T> Class<T> asWrapperType(Class<T> type) {

         if (type.isPrimitive()) {

             return forPrimitiveType(type).wrapperType(type);

         }

         return type;

     }

     /** If {@code type} is a wrapper type, return the corresponding

      *  primitive type, else return {@code type} unchanged.

      */

     public static <T> Class<T> asPrimitiveType(Class<T> type) {

         Wrapper w = findWrapperType(type);

         if (w != null) {

             return forceType(w.primitiveType(), type);

         }

         return type;

     }

     /** Query:  Is the given type a wrapper, such as {@code Integer} or {@code Void}? */

     public static boolean isWrapperType(Class<?> type) {

         return findWrapperType(type) != null;

     }

     /** Query:  Is the given type a primitive, such as {@code int} or {@code void}? */

     public static boolean isPrimitiveType(Class<?> type) {

         return type.isPrimitive();

     }

     /** What is the bytecode signature character for this type?

      *  All non-primitives, including array types, report as 'L', the signature character for references.

      */

     public static char basicTypeChar(Class<?> type) {

         if (!type.isPrimitive())

             return 'L';

         else

             return forPrimitiveType(type).basicTypeChar();

     }

     /** What is the bytecode signature character for this wrapper's

      *  primitive type?

      */

     public char basicTypeChar() { return basicTypeChar; }

     /** What is the simple name of the wrapper type?

      */

     public String wrapperSimpleName() { return wrapperSimpleName; }

     /** What is the simple name of the primitive type?

      */

     public String primitiveSimpleName() { return primitiveSimpleName; }

 //    /** Wrap a value in the given type, which may be either a primitive or wrapper type.

 //     *  Performs standard primitive conversions, including truncation and float conversions.

 //     */

 //    public static <T> T wrap(Object x, Class<T> type) {

 //        return Wrapper.valueOf(type).cast(x, type);

 //    }

     /** Cast a wrapped value to the given type, which may be either a primitive or wrapper type.

      *  The given target type must be this wrapper's primitive or wrapper type.

      *  If this wrapper is OBJECT, the target type may also be an interface, perform no runtime check.

      *  Performs standard primitive conversions, including truncation and float conversions.

      *  The given type must be compatible with this wrapper.  That is, it must either

      *  be the wrapper type (or a subtype, in the case of {@code OBJECT}) or else

      *  it must be the wrapper's primitive type.

      *  Primitive conversions are only performed if the given type is itself a primitive.

      *  @throws ClassCastException if the given type is not compatible with this wrapper

      */

     public <T> T cast(Object x, Class<T> type) {

         return convert(x, type, true);

     }

     /** Convert a wrapped value to the given type.

      *  The given target type must be this wrapper's primitive or wrapper type.

      *  This is equivalent to {@link #cast}, except that it refuses to perform

      *  narrowing primitive conversions.

      */

     public <T> T convert(Object x, Class<T> type) {

         return convert(x, type, false);

     }

     private <T> T convert(Object x, Class<T> type, boolean isCast) {

         if (this == OBJECT) {

             // If the target wrapper is OBJECT, just do a reference cast.

             // If the target type is an interface, perform no runtime check.

             // (This loophole is safe, and is allowed by the JVM verifier.)

             // If the target type is a primitive, change it to a wrapper.

             assert(!type.isPrimitive());

             if (!type.isInterface())

                 type.cast(x);

             @SuppressWarnings("unchecked")

             T result = (T) x;  // unchecked warning is expected here

             return result;

         }

         Class<T> wtype = wrapperType(type);

         if (wtype.isInstance(x)) {

             return wtype.cast(x);

         }

         if (!isCast) {

             Class<?> sourceType = x.getClass();  // throw NPE if x is null

             Wrapper source = findWrapperType(sourceType);

             if (source == null || !this.isConvertibleFrom(source)) {

                 throw newClassCastException(wtype, sourceType);

             }

         } else if (x == null) {

             @SuppressWarnings("unchecked")

             T z = (T) zero;

             return z;

         }

         @SuppressWarnings("unchecked")

         T result = (T) wrap(x);  // unchecked warning is expected here

         assert (result == null ? Void.class : result.getClass()) == wtype;

         return result;

     }

     /** Cast a reference type to another reference type.

      * If the target type is an interface, perform no runtime check.

      * (This loophole is safe, and is allowed by the JVM verifier.)

      * If the target type is a primitive, change it to a wrapper.

      */

     static <T> Class<T> forceType(Class<?> type, Class<T> exampleType) {

         boolean z = (type == exampleType ||

                type.isPrimitive() && forPrimitiveType(type) == findWrapperType(exampleType) ||

                exampleType.isPrimitive() && forPrimitiveType(exampleType) == findWrapperType(type) ||

                type == Object.class && !exampleType.isPrimitive());

         if (!z)

             System.out.println(type+" <= "+exampleType);

         assert(type == exampleType ||

                type.isPrimitive() && forPrimitiveType(type) == findWrapperType(exampleType) ||

                exampleType.isPrimitive() && forPrimitiveType(exampleType) == findWrapperType(type) ||

                type == Object.class && !exampleType.isPrimitive());

         @SuppressWarnings("unchecked")

         Class<T> result = (Class<T>) type;  // unchecked warning is expected here

         return result;

     }

     /** Wrap a value in this wrapper's type.

      * Performs standard primitive conversions, including truncation and float conversions.

      * Performs returns the unchanged reference for {@code OBJECT}.

      * Returns null for {@code VOID}.

      * Returns a zero value for a null input.

      * @throws ClassCastException if this wrapper is numeric and the operand

      *                            is not a number, character, boolean, or null

      */

     public Object wrap(Object x) {

         // do non-numeric wrappers first

         switch (basicTypeChar) {

             case 'L': return x;

             case 'V': return null;

         }

         Number xn = numberValue(x);

         switch (basicTypeChar) {

             case 'I': return Integer.valueOf(xn.intValue());

             case 'J': return Long.valueOf(xn.longValue());

             case 'F': return Float.valueOf(xn.floatValue());

             case 'D': return Double.valueOf(xn.doubleValue());

             case 'S': return Short.valueOf((short) xn.intValue());

             case 'B': return Byte.valueOf((byte) xn.intValue());

             case 'C': return Character.valueOf((char) xn.intValue());

             case 'Z': return Boolean.valueOf(boolValue(xn.byteValue()));

         }

         throw new InternalError("bad wrapper");

     }

     /** Wrap a value (an int or smaller value) in this wrapper's type.

      * Performs standard primitive conversions, including truncation and float conversions.

      * Produces an {@code Integer} for {@code OBJECT}, although the exact type

      * of the operand is not known.

      * Returns null for {@code VOID}.

      */

     public Object wrap(int x) {

         if (basicTypeChar == 'L')  return (Integer)x;

         switch (basicTypeChar) {

             case 'L': throw newIllegalArgumentException("cannot wrap to object type");

             case 'V': return null;

             case 'I': return Integer.valueOf(x);

             case 'J': return Long.valueOf(x);

             case 'F': return Float.valueOf(x);

             case 'D': return Double.valueOf(x);

             case 'S': return Short.valueOf((short) x);

             case 'B': return Byte.valueOf((byte) x);

             case 'C': return Character.valueOf((char) x);

             case 'Z': return Boolean.valueOf(boolValue((byte) x));

         }

         throw new InternalError("bad wrapper");

     }

     private static Number numberValue(Object x) {

         if (x instanceof Number)     return (Number)x;

         if (x instanceof Character)  return (int)(Character)x;

         if (x instanceof Boolean)    return (Boolean)x ? 1 : 0;

         // Remaining allowed case of void:  Must be a null reference.

         return (Number)x;

     }

     // Parameter type of boolValue must be byte, because

     // MethodHandles.explicitCastArguments defines boolean

     // conversion as first converting to byte.

     private static boolean boolValue(byte bits) {

         bits &= 1;  // simple 31-bit zero extension

         return (bits != 0);

     }

     private static RuntimeException newIllegalArgumentException(String message, Object x) {

         return newIllegalArgumentException(message + x);

     }

     private static RuntimeException newIllegalArgumentException(String message) {

         return new IllegalArgumentException(message);

     }

     // primitive array support

     public Object makeArray(int len) {

         return java.lang.reflect.Array.newInstance(primitiveType, len);

     }

     public Class<?> arrayType() {

         return emptyArray.getClass();

     }

     public void copyArrayUnboxing(Object[] values, int vpos, Object a, int apos, int length) {

         if (a.getClass() != arrayType())

             arrayType().cast(a);  // throw NPE or CCE if bad type

         for (int i = 0; i < length; i++) {

             Object value = values[i+vpos];

             value = convert(value, primitiveType);

             java.lang.reflect.Array.set(a, i+apos, value);

         }

     }

     public void copyArrayBoxing(Object a, int apos, Object[] values, int vpos, int length) {

         if (a.getClass() != arrayType())

             arrayType().cast(a);  // throw NPE or CCE if bad type

         for (int i = 0; i < length; i++) {

             Object value = java.lang.reflect.Array.get(a, i+apos);

             //Already done: value = convert(value, primitiveType);

             assert(value.getClass() == wrapperType);

             values[i+vpos] = value;

         }

     }

 }