Generate the instruction sequence needed to "unbox" the boxed data at
the top of stack.

@param type the <code>Type</code> associated with the unboxed data
170265
protected void unbox(final Type type) {
        switch (type.getSort()) {
            case Type.BOOLEAN:
                visitTypeInsn(CHECKCAST, "java/lang/Boolean");
                visitMethodInsn(INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false);
                break;
            case Type.BYTE:
                visitTypeInsn(CHECKCAST, "java/lang/Byte");
                visitMethodInsn(INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B", false);
                break;
            case Type.CHAR:
                visitTypeInsn(CHECKCAST, "java/lang/Character");
                visitMethodInsn(INVOKEVIRTUAL, "java/lang/Character", "charValue", "()C", false);
                break;
            case Type.DOUBLE:
                visitTypeInsn(CHECKCAST, "java/lang/Double");
                visitMethodInsn(INVOKEVIRTUAL, "java/lang/Double", "doubleValue", "()D", false);
                break;
            case Type.FLOAT:
                visitTypeInsn(CHECKCAST, "java/lang/Float");
                visitMethodInsn(INVOKEVIRTUAL, "java/lang/Float", "floatValue", "()F", false);
                break;
            case Type.INT:
                visitTypeInsn(CHECKCAST, "java/lang/Integer");
                visitMethodInsn(INVOKEVIRTUAL, "java/lang/Integer", "intValue", "()I", false);
                break;
            case Type.LONG:
                visitTypeInsn(CHECKCAST, "java/lang/Long");
                visitMethodInsn(INVOKEVIRTUAL, "java/lang/Long", "longValue", "()J", false);
                break;
            case Type.SHORT:
                visitTypeInsn(CHECKCAST, "java/lang/Short");
                visitMethodInsn(INVOKEVIRTUAL, "java/lang/Short", "shortValue", "()S", false);
                break;
            case Type.ARRAY:
            case Type.OBJECT:
                visitTypeInsn(CHECKCAST, type.getInternalName());
                break;
            default:
                break;
        }
    }
763244
public void setType(final Type type) {
		getOrCreateComponentModel().type = type == null ? Type.TABLE : type;
	}
495399
public static Class<?> unboxType( Class<?> wrapperType )
    {
        Class<?> c = wrapperMap.get( wrapperType );
        if ( c != null )
            return c;
        throw new InterpreterError(
            "Not a primitive wrapper type: "+wrapperType );
    }
935159
public ClassReloadingStrategy preregistered(Class<?>... type) {
        Map<String, Class<?>> preregisteredTypes = new HashMap<String, Class<?>>(this.preregisteredTypes);
        for (Class<?> aType : type) {
            preregisteredTypes.put(TypeDescription.ForLoadedType.getName(aType), aType);
        }
        return new ClassReloadingStrategy(instrumentation, strategy, bootstrapInjection, preregisteredTypes);
    }
745146
public static <T> T as(Object src, Class<T> type) {
        Class<?> t = type;
        while (t.isArray()) {
            t = t.getComponentType();
        }
        if (t == type) {
            // not an array at all
            return boxAs(src, type);
        } else {        
            if (t.isPrimitive()) {
                return deepUnboxAs(src, type);
            } else {
                return deepBoxAs(src, type);
            }
        }
    }
1017723
public static Optional<SoyRuntimeType> getUnboxedType(SoyType soyType) {
    // Optional is immutable so Optional<Subclass> can always be safely cast to Optional<SuperClass>
    @SuppressWarnings({"unchecked", "rawtypes"})
    Optional<SoyRuntimeType> typed = (Optional) primitiveTypeCache.getUnchecked(soyType);
    return typed;
  }
1259934
protected void write(BufferedWriter out, String type, byte[] data) throws IOException
    {
        writeHeader(out, type);
        out.write(this.base64.encode(data, 64));
        out.newLine();
        writeFooter(out, type);
    }
80312
public Type boxedTypeOrType(Type t) {
        return t.isPrimitive() ?
            boxedClass(t).type :
            t;
    }
366208
@SuppressWarnings ( "unchecked" )
    @Override
    public <T extends Address> T unwrap ( Class<T> type ) {
        if ( this.addr instanceof Address ) {
            return ( (Address) this.addr ).unwrap(type);
        }
        else if ( this.getClass().isAssignableFrom(type) ) {
            return (T) this;
        }
        return null;
    }
1147078
public static Object[] boxAll(Class<?> type, Object src, int srcPos, int len) {
        switch (tId(type)) {
            case I_BOOLEAN:     return boxBooleans(src, srcPos, len);
            case I_BYTE:        return boxBytes(src, srcPos, len);
            case I_CHARACTER:   return boxCharacters(src, srcPos, len);
            case I_DOUBLE:      return boxDoubles(src, srcPos, len);
            case I_FLOAT:       return boxFloats(src, srcPos, len);
            case I_INTEGER:     return boxIntegers(src, srcPos, len);
            case I_LONG:        return boxLongs(src, srcPos, len);
            case I_SHORT:       return boxShorts(src, srcPos, len);
        }
        throw new IllegalArgumentException("No primitive/box: " + type);
    }
335673
public void loadFromArray(TypeDesc type) {
        byte op;
        int stackAdjust = -1;

        switch (type.getTypeCode()) {
        case TypeDesc.INT_CODE:
            op = Opcode.IALOAD;
            break;
        case TypeDesc.BOOLEAN_CODE:
        case TypeDesc.BYTE_CODE:
            op = Opcode.BALOAD;
            break;
        case TypeDesc.SHORT_CODE:
            op = Opcode.SALOAD;
            break;
        case TypeDesc.CHAR_CODE:
            op = Opcode.CALOAD;
            break;
        case TypeDesc.FLOAT_CODE:
            op = Opcode.FALOAD;
            break;
        case TypeDesc.LONG_CODE:
            stackAdjust = 0;
            op = Opcode.LALOAD;
            break;
        case TypeDesc.DOUBLE_CODE:
            stackAdjust = 0;
            op = Opcode.DALOAD;
            break;
        default:
            op = Opcode.AALOAD;
            break;
        }

        addCode(stackAdjust, op);
    }
1005465
public Packet setPacketType(Packet.Type type) {
        int nonTypeFlags = flags & (~FLAG_TYPE0 & ~FLAG_TYPE1 & ~FLAG_TYPE2);
        resetFlagsTo(type.headerEncoding | nonTypeFlags);
        return this;
    }
1065361
public org.inferred.freebuilder.processor.property.Property.Builder setBoxedType(
      TypeMirror boxedType) {
    this.boxedType = Objects.requireNonNull(boxedType);
    return (org.inferred.freebuilder.processor.property.Property.Builder) this;
  }
86620
public void decode(byte data[], OutputStream uncompData) {
        
        if(data[0] == (byte)0x00 && data[1] == (byte)0x01) {
            throw new RuntimeException("LZW flavour not supported.");
        }
        
        initializeStringTable();
        
        this.data = data;
        this.uncompData = uncompData;
        
        // Initialize pointers
        bytePointer = 0;
        bitPointer = 0;
        
        nextData = 0;
        nextBits = 0;
        
        int code, oldCode = 0;
        byte string[];
        
        while ((code = getNextCode()) != 257) {
            
            if (code == 256) {
                
                initializeStringTable();
                code = getNextCode();
                
                if (code == 257) {
                    break;
                }
                
                writeString(stringTable[code]);
                oldCode = code;
                
            } else {
                
                if (code < tableIndex) {
                    
                    string = stringTable[code];
                    
                    writeString(string);
                    addStringToTable(stringTable[oldCode], string[0]);
                    oldCode = code;
                    
                } else {
                    
                    string = stringTable[oldCode];
                    string = composeString(string, string[0]);
                    writeString(string);
                    addStringToTable(string);
                    oldCode = code;
                }
            }
        }
    }
264291
public TypeName unbox() {
    if (keyword != null) return this; // Already unboxed.
    if (this.equals(BOXED_VOID)) return VOID;
    if (this.equals(BOXED_BOOLEAN)) return BOOLEAN;
    if (this.equals(BOXED_BYTE)) return BYTE;
    if (this.equals(BOXED_SHORT)) return SHORT;
    if (this.equals(BOXED_INT)) return INT;
    if (this.equals(BOXED_LONG)) return LONG;
    if (this.equals(BOXED_CHAR)) return CHAR;
    if (this.equals(BOXED_FLOAT)) return FLOAT;
    if (this.equals(BOXED_DOUBLE)) return DOUBLE;
    throw new UnsupportedOperationException("cannot unbox " + this);
  }
1065440
public void addUpperConstraint(String type) {
		final JvmUpperBound constraint = this.jvmTypesFactory.createJvmUpperBound();
		constraint.setTypeReference(newTypeRef(this.context, type));
		getJvmTypeParameter().getConstraints().add(constraint);
	}
1047527
public JSType createOptionalType(JSType type) {
    if (type instanceof UnknownType || type.isAllType()) {
      return type;
    } else {
      return createUnionType(type, getNativeType(JSTypeNative.VOID_TYPE));
    }
  }