Example usage for org.eclipse.jdt.internal.compiler.lookup TypeConstants JAVA_LANG_INTEGER

List of usage examples for org.eclipse.jdt.internal.compiler.lookup TypeConstants JAVA_LANG_INTEGER

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.lookup TypeConstants JAVA_LANG_INTEGER.

Prototype

null JAVA_LANG_INTEGER

To view the source code for org.eclipse.jdt.internal.compiler.lookup TypeConstants JAVA_LANG_INTEGER.

Click Source Link

Usage

From source file:lombok.eclipse.handlers.singulars.EclipseJavaUtilSingularizer.java

License:Open Source License

protected List<Statement> createJavaUtilSimpleCreationAndFillStatements(SingularData data,
        EclipseNode builderType, boolean mapMode, boolean defineVar, boolean addInitialCapacityArg,
        boolean nullGuard, String targetType) {
    char[] varName = mapMode ? (new String(data.getPluralName()) + "$key").toCharArray() : data.getPluralName();

    Statement createStat;// ww w  .j  a  v  a2 s. c om
    {
        // pluralName = new java.util.TargetType(initialCap);
        Expression[] constructorArgs = null;
        if (addInitialCapacityArg) {
            // this.varName.size() < MAX_POWER_OF_2 ? 1 + this.varName.size() + (this.varName.size() - 3) / 3 : Integer.MAX_VALUE;
            // lessThanCutOff = this.varName.size() < MAX_POWER_OF_2
            Expression lessThanCutoff = new BinaryExpression(getSize(builderType, varName, nullGuard),
                    makeIntLiteral("0x40000000".toCharArray(), null), OperatorIds.LESS);
            FieldReference integerMaxValue = new FieldReference("MAX_VALUE".toCharArray(), 0L);
            integerMaxValue.receiver = new QualifiedNameReference(TypeConstants.JAVA_LANG_INTEGER, NULL_POSS, 0,
                    0);
            Expression sizeFormulaLeft = new BinaryExpression(makeIntLiteral(new char[] { '1' }, null),
                    getSize(builderType, varName, nullGuard), OperatorIds.PLUS);
            Expression sizeFormulaRightLeft = new BinaryExpression(getSize(builderType, varName, nullGuard),
                    makeIntLiteral(new char[] { '3' }, null), OperatorIds.MINUS);
            Expression sizeFormulaRight = new BinaryExpression(sizeFormulaRightLeft,
                    makeIntLiteral(new char[] { '3' }, null), OperatorIds.DIVIDE);
            Expression sizeFormula = new BinaryExpression(sizeFormulaLeft, sizeFormulaRight, OperatorIds.PLUS);
            Expression cond = new ConditionalExpression(lessThanCutoff, sizeFormula, integerMaxValue);
            constructorArgs = new Expression[] { cond };
        }

        TypeReference targetTypeRef = new QualifiedTypeReference(
                new char[][] { TypeConstants.JAVA, TypeConstants.UTIL, targetType.toCharArray() }, NULL_POSS);
        targetTypeRef = addTypeArgs(mapMode ? 2 : 1, false, builderType, targetTypeRef, data.getTypeArgs());
        AllocationExpression constructorCall = new AllocationExpression();
        constructorCall.type = targetTypeRef;
        constructorCall.arguments = constructorArgs;

        if (defineVar) {
            TypeReference localShadowerType = new QualifiedTypeReference(fromQualifiedName(data.getTargetFqn()),
                    NULL_POSS);
            localShadowerType = addTypeArgs(mapMode ? 2 : 1, false, builderType, localShadowerType,
                    data.getTypeArgs());
            LocalDeclaration localShadowerDecl = new LocalDeclaration(data.getPluralName(), 0, 0);
            localShadowerDecl.type = localShadowerType;
            localShadowerDecl.initialization = constructorCall;
            createStat = localShadowerDecl;
        } else {
            createStat = new Assignment(new SingleNameReference(data.getPluralName(), 0L), constructorCall, 0);
        }
    }

    Statement fillStat;
    {
        if (mapMode) {
            // for (int $i = 0; $i < this.pluralname$key.size(); i++) pluralname.put(this.pluralname$key.get($i), this.pluralname$value.get($i));
            char[] iVar = new char[] { '$', 'i' };
            MessageSend pluralnameDotPut = new MessageSend();
            pluralnameDotPut.selector = new char[] { 'p', 'u', 't' };
            pluralnameDotPut.receiver = new SingleNameReference(data.getPluralName(), 0L);
            FieldReference thisDotKey = new FieldReference(varName, 0L);
            thisDotKey.receiver = new ThisReference(0, 0);
            FieldReference thisDotValue = new FieldReference(
                    (new String(data.getPluralName()) + "$value").toCharArray(), 0L);
            thisDotValue.receiver = new ThisReference(0, 0);
            MessageSend keyArg = new MessageSend();
            keyArg.receiver = thisDotKey;
            keyArg.arguments = new Expression[] { new SingleNameReference(iVar, 0L) };
            keyArg.selector = new char[] { 'g', 'e', 't' };
            MessageSend valueArg = new MessageSend();
            valueArg.receiver = thisDotValue;
            valueArg.arguments = new Expression[] { new SingleNameReference(iVar, 0L) };
            valueArg.selector = new char[] { 'g', 'e', 't' };
            pluralnameDotPut.arguments = new Expression[] { keyArg, valueArg };

            LocalDeclaration forInit = new LocalDeclaration(iVar, 0, 0);
            forInit.type = TypeReference.baseTypeReference(TypeIds.T_int, 0);
            forInit.initialization = makeIntLiteral(new char[] { '0' }, null);
            Expression checkExpr = new BinaryExpression(new SingleNameReference(iVar, 0L),
                    getSize(builderType, varName, nullGuard), OperatorIds.LESS);
            Expression incrementExpr = new PostfixExpression(new SingleNameReference(iVar, 0L), IntLiteral.One,
                    OperatorIds.PLUS, 0);
            fillStat = new ForStatement(new Statement[] { forInit }, checkExpr,
                    new Statement[] { incrementExpr }, pluralnameDotPut, true, 0, 0);
        } else {
            // pluralname.addAll(this.pluralname);
            MessageSend pluralnameDotAddAll = new MessageSend();
            pluralnameDotAddAll.selector = new char[] { 'a', 'd', 'd', 'A', 'l', 'l' };
            pluralnameDotAddAll.receiver = new SingleNameReference(data.getPluralName(), 0L);
            FieldReference thisDotPluralname = new FieldReference(varName, 0L);
            thisDotPluralname.receiver = new ThisReference(0, 0);
            pluralnameDotAddAll.arguments = new Expression[] { thisDotPluralname };
            fillStat = pluralnameDotAddAll;
        }

        if (nullGuard) {
            FieldReference thisDotField = new FieldReference(varName, 0L);
            thisDotField.receiver = new ThisReference(0, 0);
            Expression cond = new EqualExpression(thisDotField, new NullLiteral(0, 0), OperatorIds.NOT_EQUAL);
            fillStat = new IfStatement(cond, fillStat, 0, 0);
        }
    }

    Statement unmodifiableStat;
    {
        // pluralname = Collections.unmodifiableInterfaceType(pluralname);
        Expression arg = new SingleNameReference(data.getPluralName(), 0L);
        MessageSend invoke = new MessageSend();
        invoke.arguments = new Expression[] { arg };
        invoke.selector = ("unmodifiable" + data.getTargetSimpleType()).toCharArray();
        invoke.receiver = new QualifiedNameReference(JAVA_UTIL_COLLECTIONS, NULL_POSS, 0, 0);
        unmodifiableStat = new Assignment(new SingleNameReference(data.getPluralName(), 0L), invoke, 0);
    }

    return Arrays.asList(createStat, fillStat, unmodifiableStat);
}

From source file:org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding.java

License:Open Source License

public void computeId() {
    // try to avoid multiple checks against a package/type name
    switch (this.compoundName.length) {

    case 3:// w w  w. j  av a 2 s. c o m
        if (!CharOperation.equals(TypeConstants.JAVA, this.compoundName[0]))
            return;

        char[] packageName = this.compoundName[1];
        if (packageName.length == 0)
            return; // just to be safe
        char[] typeName = this.compoundName[2];
        if (typeName.length == 0)
            return; // just to be safe
        // remaining types MUST be in java.*.*
        if (!CharOperation.equals(TypeConstants.LANG, this.compoundName[1])) {
            switch (packageName[0]) {
            case 'i':
                if (CharOperation.equals(packageName, TypeConstants.IO)) {
                    switch (typeName[0]) {
                    case 'E':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_EXTERNALIZABLE[2]))
                            this.id = TypeIds.T_JavaIoExternalizable;
                        return;
                    case 'I':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_IOEXCEPTION[2]))
                            this.id = TypeIds.T_JavaIoException;
                        return;
                    case 'O':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_OBJECTSTREAMEXCEPTION[2]))
                            this.id = TypeIds.T_JavaIoObjectStreamException;
                        return;
                    case 'P':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_PRINTSTREAM[2]))
                            this.id = TypeIds.T_JavaIoPrintStream;
                        return;
                    case 'S':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_SERIALIZABLE[2]))
                            this.id = TypeIds.T_JavaIoSerializable;
                        return;
                    }
                }
                return;
            case 'u':
                if (CharOperation.equals(packageName, TypeConstants.UTIL)) {
                    switch (typeName[0]) {
                    case 'C':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_UTIL_COLLECTION[2]))
                            this.id = TypeIds.T_JavaUtilCollection;
                        return;
                    case 'I':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_UTIL_ITERATOR[2]))
                            this.id = TypeIds.T_JavaUtilIterator;
                        return;
                    }
                }
                return;
            }
            return;
        }

        // remaining types MUST be in java.lang.*
        switch (typeName[0]) {
        case 'A':
            switch (typeName.length) {
            case 13:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_AUTOCLOSEABLE[2]))
                    this.id = TypeIds.T_JavaLangAutoCloseable;
                return;
            case 14:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ASSERTIONERROR[2]))
                    this.id = TypeIds.T_JavaLangAssertionError;
                return;
            }
            return;
        case 'B':
            switch (typeName.length) {
            case 4:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_BYTE[2]))
                    this.id = TypeIds.T_JavaLangByte;
                return;
            case 7:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_BOOLEAN[2]))
                    this.id = TypeIds.T_JavaLangBoolean;
                return;
            }
            return;
        case 'C':
            switch (typeName.length) {
            case 5:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CLASS[2]))
                    this.id = TypeIds.T_JavaLangClass;
                return;
            case 9:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CHARACTER[2]))
                    this.id = TypeIds.T_JavaLangCharacter;
                else if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CLONEABLE[2]))
                    this.id = TypeIds.T_JavaLangCloneable;
                return;
            case 22:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CLASSNOTFOUNDEXCEPTION[2]))
                    this.id = TypeIds.T_JavaLangClassNotFoundException;
                return;
            }
            return;
        case 'D':
            switch (typeName.length) {
            case 6:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_DOUBLE[2]))
                    this.id = TypeIds.T_JavaLangDouble;
                return;
            case 10:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_DEPRECATED[2]))
                    this.id = TypeIds.T_JavaLangDeprecated;
                return;
            }
            return;
        case 'E':
            switch (typeName.length) {
            case 4:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ENUM[2]))
                    this.id = TypeIds.T_JavaLangEnum;
                return;
            case 5:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ERROR[2]))
                    this.id = TypeIds.T_JavaLangError;
                return;
            case 9:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_EXCEPTION[2]))
                    this.id = TypeIds.T_JavaLangException;
                return;
            }
            return;
        case 'F':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_FLOAT[2]))
                this.id = TypeIds.T_JavaLangFloat;
            return;
        case 'I':
            switch (typeName.length) {
            case 7:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_INTEGER[2]))
                    this.id = TypeIds.T_JavaLangInteger;
                return;
            case 8:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ITERABLE[2]))
                    this.id = TypeIds.T_JavaLangIterable;
                return;
            case 24:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ILLEGALARGUMENTEXCEPTION[2]))
                    this.id = TypeIds.T_JavaLangIllegalArgumentException;
                return;
            }
            return;
        case 'L':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_LONG[2]))
                this.id = TypeIds.T_JavaLangLong;
            return;
        case 'N':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_NOCLASSDEFERROR[2]))
                this.id = TypeIds.T_JavaLangNoClassDefError;
            return;
        case 'O':
            switch (typeName.length) {
            case 6:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_OBJECT[2]))
                    this.id = TypeIds.T_JavaLangObject;
                return;
            case 8:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_OVERRIDE[2]))
                    this.id = TypeIds.T_JavaLangOverride;
                return;
            }
            return;
        case 'R':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_RUNTIMEEXCEPTION[2]))
                this.id = TypeIds.T_JavaLangRuntimeException;
            break;
        case 'S':
            switch (typeName.length) {
            case 5:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SHORT[2]))
                    this.id = TypeIds.T_JavaLangShort;
                return;
            case 6:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_STRING[2]))
                    this.id = TypeIds.T_JavaLangString;
                else if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SYSTEM[2]))
                    this.id = TypeIds.T_JavaLangSystem;
                return;
            case 11:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SAFEVARARGS[2]))
                    this.id = TypeIds.T_JavaLangSafeVarargs;
                return;
            case 12:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_STRINGBUFFER[2]))
                    this.id = TypeIds.T_JavaLangStringBuffer;
                return;
            case 13:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_STRINGBUILDER[2]))
                    this.id = TypeIds.T_JavaLangStringBuilder;
                return;
            case 16:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SUPPRESSWARNINGS[2]))
                    this.id = TypeIds.T_JavaLangSuppressWarnings;
                return;
            }
            return;
        case 'T':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_THROWABLE[2]))
                this.id = TypeIds.T_JavaLangThrowable;
            return;
        case 'V':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_VOID[2]))
                this.id = TypeIds.T_JavaLangVoid;
            return;
        }
        break;

    case 4:
        if (!CharOperation.equals(TypeConstants.JAVA, this.compoundName[0]))
            return;
        packageName = this.compoundName[1];
        if (packageName.length == 0)
            return; // just to be safe

        packageName = this.compoundName[2];
        if (packageName.length == 0)
            return; // just to be safe
        typeName = this.compoundName[3];
        if (typeName.length == 0)
            return; // just to be safe
        switch (packageName[0]) {
        case 'a':
            if (CharOperation.equals(packageName, TypeConstants.ANNOTATION)) {
                switch (typeName[0]) {
                case 'A':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_ANNOTATION[3]))
                        this.id = TypeIds.T_JavaLangAnnotationAnnotation;
                    return;
                case 'D':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_DOCUMENTED[3]))
                        this.id = TypeIds.T_JavaLangAnnotationDocumented;
                    return;
                case 'E':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_ELEMENTTYPE[3]))
                        this.id = TypeIds.T_JavaLangAnnotationElementType;
                    return;
                case 'I':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_INHERITED[3]))
                        this.id = TypeIds.T_JavaLangAnnotationInherited;
                    return;
                case 'R':
                    switch (typeName.length) {
                    case 9:
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_RETENTION[3]))
                            this.id = TypeIds.T_JavaLangAnnotationRetention;
                        return;
                    case 15:
                        if (CharOperation.equals(typeName,
                                TypeConstants.JAVA_LANG_ANNOTATION_RETENTIONPOLICY[3]))
                            this.id = TypeIds.T_JavaLangAnnotationRetentionPolicy;
                        return;
                    }
                    return;
                case 'T':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_TARGET[3]))
                        this.id = TypeIds.T_JavaLangAnnotationTarget;
                    return;
                }
            }
            return;
        case 'i':
            if (CharOperation.equals(packageName, TypeConstants.INVOKE)) {
                if (typeName.length == 0)
                    return; // just to be safe
                switch (typeName[0]) {
                case 'M':
                    if (CharOperation.equals(typeName,
                            TypeConstants.JAVA_LANG_INVOKE_METHODHANDLE_$_POLYMORPHICSIGNATURE[3]))
                        this.id = TypeIds.T_JavaLangInvokeMethodHandlePolymorphicSignature;
                    return;
                }
            }
            return;
        case 'r':
            if (CharOperation.equals(packageName, TypeConstants.REFLECT)) {
                switch (typeName[0]) {
                case 'C':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_REFLECT_CONSTRUCTOR[2]))
                        this.id = TypeIds.T_JavaLangReflectConstructor;
                    return;
                case 'F':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_REFLECT_FIELD[2]))
                        this.id = TypeIds.T_JavaLangReflectField;
                    return;
                case 'M':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_REFLECT_METHOD[2]))
                        this.id = TypeIds.T_JavaLangReflectMethod;
                    return;
                }
            }
            return;
        }
        break;
    case 5:
        if (!CharOperation.equals(TypeConstants.JAVA, this.compoundName[0]))
            return;
        packageName = this.compoundName[1];
        if (packageName.length == 0)
            return; // just to be safe

        if (CharOperation.equals(TypeConstants.LANG, packageName)) {
            packageName = this.compoundName[2];
            if (packageName.length == 0)
                return; // just to be safe
            switch (packageName[0]) {
            case 'i':
                if (CharOperation.equals(packageName, TypeConstants.INVOKE)) {
                    typeName = this.compoundName[3];
                    if (typeName.length == 0)
                        return; // just to be safe
                    switch (typeName[0]) {
                    case 'M':
                        char[] memberTypeName = this.compoundName[4];
                        if (memberTypeName.length == 0)
                            return; // just to be safe
                        if (CharOperation.equals(typeName,
                                TypeConstants.JAVA_LANG_INVOKE_METHODHANDLE_POLYMORPHICSIGNATURE[3])
                                && CharOperation.equals(memberTypeName,
                                        TypeConstants.JAVA_LANG_INVOKE_METHODHANDLE_POLYMORPHICSIGNATURE[4]))
                            this.id = TypeIds.T_JavaLangInvokeMethodHandlePolymorphicSignature;
                        return;
                    }
                }
                return;
            }
            return;
        }
    }
}

From source file:org.eclipse.objectteams.otdt.internal.core.compiler.statemachine.transformer.TeamMethodGenerator.java

License:Open Source License

/** create field ASTs. */
@SuppressWarnings("nls")
void addFields(TypeDeclaration teamDecl, AstGenerator gen) {
    // private WeakHashMap<Thread, Boolean> _OT$activatedThreads = new WeakHashMap<Thread, Boolean>();
    addPrivateField(teamDecl, gen, weakHashMapTypeReference(gen), "_OT$activatedThreads".toCharArray(),
            gen.allocation(weakHashMapTypeReference(gen), null));

    // private Object _OT$registrationLock= new Object();
    addPrivateField(teamDecl, gen, gen.qualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT),
            "_OT$registrationLock".toCharArray(),
            gen.allocation(gen.qualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT), null));

    // private boolean _OT$lazyGlobalActiveFlag = false;
    addPrivateField(teamDecl, gen, gen.baseTypeReference(TypeConstants.BOOLEAN),
            "_OT$lazyGlobalActiveFlag".toCharArray(), gen.booleanLiteral(false));

    // private boolean _OT$isExecutingCallin = false;
    addPrivateField(teamDecl, gen, gen.baseTypeReference(TypeConstants.BOOLEAN),
            "_OT$isExecutingCallin".toCharArray(), gen.booleanLiteral(false));

    // private  int _OT$registrationState = _OT$UNREGISTERED;
    addPrivateField(teamDecl, gen, gen.baseTypeReference(TypeConstants.INT),
            "_OT$registrationState".toCharArray(), gen.intLiteral(0));

    // private boolean _OT$globalActive = false;
    addPrivateField(teamDecl, gen, gen.baseTypeReference(TypeConstants.BOOLEAN),
            "_OT$globalActive".toCharArray(), gen.booleanLiteral(false));

    // private ThreadLocal<Integer> _OT$implicitActivationsPerThread = new ThreadLocal<Integer>() {
    //       protected synchronized Integer initialValue() {
    //          return Integer.valueOf(0);
    //       }//from  w  w  w  .  j  a va 2s.com
    // };
    TypeDeclaration anonThreadLocal = gen.anonymousType(teamDecl.compilationResult);
    anonThreadLocal.methods = new MethodDeclaration[] {
            gen.method(teamDecl.compilationResult, AccProtected | AccSynchronized,
                    gen.qualifiedTypeReference(TypeConstants.JAVA_LANG_INTEGER), "initialValue".toCharArray(),
                    null/*arguments*/, new Statement[] { gen.returnStatement(gen.intLiteral(0)) // rely on autoboxing   
                    }) };
    addPrivateField(teamDecl, gen, threadLocalReference(gen), "_OT$implicitActivationsPerThread".toCharArray(),
            gen.anonymousAllocation(threadLocalReference(gen), null/*arguments*/, anonThreadLocal));
}

From source file:org.eclipse.objectteams.otdt.internal.core.compiler.statemachine.transformer.TeamMethodGenerator.java

License:Open Source License

QualifiedTypeReference threadLocalReference(AstGenerator gen) {
    return gen.parameterizedQualifiedTypeReference(JAVA_LANG_THREADLOCAL,
            new TypeReference[] { gen.qualifiedTypeReference(TypeConstants.JAVA_LANG_INTEGER) });
}

From source file:org.eclipse.objectteams.otdt.internal.core.compiler.util.AstGenerator.java

License:Open Source License

public static char[][] boxTypeName(BaseTypeBinding type) {
    switch (type.id) {
    case TypeIds.T_byte:
        return TypeConstants.JAVA_LANG_BYTE;
    case TypeIds.T_boolean:
        return TypeConstants.JAVA_LANG_BOOLEAN;
    case TypeIds.T_int:
        return TypeConstants.JAVA_LANG_INTEGER;
    case TypeIds.T_short:
        return TypeConstants.JAVA_LANG_SHORT;
    case TypeIds.T_long:
        return TypeConstants.JAVA_LANG_LONG;
    case TypeIds.T_double:
        return TypeConstants.JAVA_LANG_DOUBLE;
    case TypeIds.T_float:
        return TypeConstants.JAVA_LANG_FLOAT;
    case TypeIds.T_char:
        return TypeConstants.JAVA_LANG_CHARACTER;
    default:/* ww  w .j a va2s  . c  om*/
        throw new InternalCompilerError("trying to box non-primitive type"); //$NON-NLS-1$
    }
}