Example usage for org.eclipse.jdt.core IMemberValuePair K

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IMemberValuePair K_CLASS.

Prototype

int K_CLASS

To view the source code for org.eclipse.jdt.core IMemberValuePair K_CLASS.

Click Source Link

Document

Constant indicating that the value kind is a Class represented by the name of the class (i.e.

Usage

From source file:at.bestsolution.fxide.jdt.text.viewersupport.JavaElementLabelComposer.java

License:Open Source License

private void appendAnnotationValue(IAnnotation annotation, Object value, int valueKind, long flags)
        throws JavaModelException {
    // Note: To be bug-compatible with Javadoc from Java 5/6/7, we currently don't escape HTML tags in String-valued annotations.
    if (value instanceof Object[]) {
        fBuffer.append('{');
        Object[] values = (Object[]) value;
        for (int j = 0; j < values.length; j++) {
            if (j > 0)
                fBuffer.append(JavaElementLabels.COMMA_STRING);
            value = values[j];/*from  w  w w.jav  a 2s  .c o m*/
            appendAnnotationValue(annotation, value, valueKind, flags);
        }
        fBuffer.append('}');
    } else {
        switch (valueKind) {
        case IMemberValuePair.K_CLASS:
            appendTypeSignatureLabel(annotation, Signature.createTypeSignature((String) value, false), flags);
            fBuffer.append(".class"); //$NON-NLS-1$
            break;
        case IMemberValuePair.K_QUALIFIED_NAME:
            String name = (String) value;
            int lastDot = name.lastIndexOf('.');
            if (lastDot != -1) {
                String type = name.substring(0, lastDot);
                String field = name.substring(lastDot + 1);
                appendTypeSignatureLabel(annotation, Signature.createTypeSignature(type, false), flags);
                fBuffer.append('.');
                fBuffer.append(getMemberName(annotation, type, field));
                break;
            }
            //            case IMemberValuePair.K_SIMPLE_NAME: // can't implement, since parent type is not known
            //$FALL-THROUGH$
        case IMemberValuePair.K_ANNOTATION:
            appendAnnotationLabel((IAnnotation) value, flags);
            break;
        case IMemberValuePair.K_STRING:
            fBuffer.append(ASTNodes.getEscapedStringLiteral((String) value));
            break;
        case IMemberValuePair.K_CHAR:
            fBuffer.append(ASTNodes.getEscapedCharacterLiteral(((Character) value).charValue()));
            break;
        default:
            fBuffer.append(String.valueOf(value));
            break;
        }
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.CompilationUnitStructureRequestor.java

License:Open Source License

protected Object getMemberValue(com.codenvy.ide.ext.java.server.internal.core.MemberValuePair memberValuePair,
        Expression expression) {/* www .j av a  2 s.  c  om*/
    if (expression instanceof NullLiteral) {
        return null;
    } else if (expression instanceof Literal) {
        ((Literal) expression).computeConstant();
        return Util.getAnnotationMemberValue(memberValuePair, expression.constant);
    } else if (expression instanceof org.eclipse.jdt.internal.compiler.ast.Annotation) {
        org.eclipse.jdt.internal.compiler.ast.Annotation annotation = (org.eclipse.jdt.internal.compiler.ast.Annotation) expression;
        Object handle = acceptAnnotation(annotation, null, (JavaElement) this.handleStack.peek());
        memberValuePair.valueKind = IMemberValuePair.K_ANNOTATION;
        return handle;
    } else if (expression instanceof ClassLiteralAccess) {
        ClassLiteralAccess classLiteral = (ClassLiteralAccess) expression;
        char[] name = CharOperation.concatWith(classLiteral.type.getTypeName(), '.');
        memberValuePair.valueKind = IMemberValuePair.K_CLASS;
        return new String(name);
    } else if (expression instanceof QualifiedNameReference) {
        char[] qualifiedName = CharOperation.concatWith(((QualifiedNameReference) expression).tokens, '.');
        memberValuePair.valueKind = IMemberValuePair.K_QUALIFIED_NAME;
        return new String(qualifiedName);
    } else if (expression instanceof SingleNameReference) {
        char[] simpleName = ((SingleNameReference) expression).token;
        if (simpleName == RecoveryScanner.FAKE_IDENTIFIER) {
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            return null;
        }
        memberValuePair.valueKind = IMemberValuePair.K_SIMPLE_NAME;
        return new String(simpleName);
    } else if (expression instanceof ArrayInitializer) {
        memberValuePair.valueKind = -1; // modified below by the first call to getMemberValue(...)
        Expression[] expressions = ((ArrayInitializer) expression).expressions;
        int length = expressions == null ? 0 : expressions.length;
        Object[] values = new Object[length];
        for (int i = 0; i < length; i++) {
            int previousValueKind = memberValuePair.valueKind;
            Object value = getMemberValue(memberValuePair, expressions[i]);
            if (previousValueKind != -1 && memberValuePair.valueKind != previousValueKind) {
                // values are heterogeneous, value kind is thus unknown
                memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            }
            values[i] = value;
        }
        if (memberValuePair.valueKind == -1)
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return values;
    } else if (expression instanceof UnaryExpression) { // to deal with negative numerals (see bug - 248312)
        UnaryExpression unaryExpression = (UnaryExpression) expression;
        if ((unaryExpression.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT == OperatorIds.MINUS) {
            if (unaryExpression.expression instanceof Literal) {
                Literal subExpression = (Literal) unaryExpression.expression;
                subExpression.computeConstant();
                return Util.getNegativeAnnotationMemberValue(memberValuePair, subExpression.constant);
            }
        }
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    } else {
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.LocalVariable.java

License:Open Source License

private Object getAnnotationMemberValue(MemberValuePair memberValuePair, Expression expression,
        JavaElement parentElement) {//from w  ww.j  a v a  2  s .  c o  m
    if (expression instanceof NullLiteral) {
        return null;
    } else if (expression instanceof Literal) {
        ((Literal) expression).computeConstant();
        return Util.getAnnotationMemberValue(memberValuePair, expression.constant);
    } else if (expression instanceof org.eclipse.jdt.internal.compiler.ast.Annotation) {
        memberValuePair.valueKind = IMemberValuePair.K_ANNOTATION;
        return getAnnotation((org.eclipse.jdt.internal.compiler.ast.Annotation) expression, parentElement);
    } else if (expression instanceof ClassLiteralAccess) {
        ClassLiteralAccess classLiteral = (ClassLiteralAccess) expression;
        char[] typeName = CharOperation.concatWith(classLiteral.type.getTypeName(), '.');
        memberValuePair.valueKind = IMemberValuePair.K_CLASS;
        return new String(typeName);
    } else if (expression instanceof QualifiedNameReference) {
        char[] qualifiedName = CharOperation.concatWith(((QualifiedNameReference) expression).tokens, '.');
        memberValuePair.valueKind = IMemberValuePair.K_QUALIFIED_NAME;
        return new String(qualifiedName);
    } else if (expression instanceof SingleNameReference) {
        char[] simpleName = ((SingleNameReference) expression).token;
        if (simpleName == RecoveryScanner.FAKE_IDENTIFIER) {
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            return null;
        }
        memberValuePair.valueKind = IMemberValuePair.K_SIMPLE_NAME;
        return new String(simpleName);
    } else if (expression instanceof ArrayInitializer) {
        memberValuePair.valueKind = -1; // modified below by the first call to getMemberValue(...)
        Expression[] expressions = ((ArrayInitializer) expression).expressions;
        int length = expressions == null ? 0 : expressions.length;
        Object[] values = new Object[length];
        for (int i = 0; i < length; i++) {
            int previousValueKind = memberValuePair.valueKind;
            Object value = getAnnotationMemberValue(memberValuePair, expressions[i], parentElement);
            if (previousValueKind != -1 && memberValuePair.valueKind != previousValueKind) {
                // values are heterogeneous, value kind is thus unknown
                memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            }
            values[i] = value;
        }
        if (memberValuePair.valueKind == -1)
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return values;
    } else if (expression instanceof UnaryExpression) { //to deal with negative numerals (see bug - 248312)
        UnaryExpression unaryExpression = (UnaryExpression) expression;
        if ((unaryExpression.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT == OperatorIds.MINUS) {
            if (unaryExpression.expression instanceof Literal) {
                Literal subExpression = (Literal) unaryExpression.expression;
                subExpression.computeConstant();
                return Util.getNegativeAnnotationMemberValue(memberValuePair, subExpression.constant);
            }
        }
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    } else {
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.util.Util.java

License:Open Source License

public static Object getAnnotationMemberValue(JavaElement parent, JavaModelManager manager,
        MemberValuePair memberValuePair, Object binaryValue) {
    if (binaryValue instanceof Constant) {
        return getAnnotationMemberValue(memberValuePair, (Constant) binaryValue);
    } else if (binaryValue instanceof IBinaryAnnotation) {
        memberValuePair.valueKind = IMemberValuePair.K_ANNOTATION;
        return getAnnotation(parent, manager, (IBinaryAnnotation) binaryValue, memberValuePair.getMemberName());
    } else if (binaryValue instanceof ClassSignature) {
        memberValuePair.valueKind = IMemberValuePair.K_CLASS;
        char[] className = Signature.toCharArray(
                CharOperation.replaceOnCopy(((ClassSignature) binaryValue).getTypeName(), '/', '.'));
        return new String(className);
    } else if (binaryValue instanceof EnumConstantSignature) {
        memberValuePair.valueKind = IMemberValuePair.K_QUALIFIED_NAME;
        EnumConstantSignature enumConstant = (EnumConstantSignature) binaryValue;
        char[] enumName = Signature
                .toCharArray(CharOperation.replaceOnCopy(enumConstant.getTypeName(), '/', '.'));
        char[] qualifiedName = CharOperation.concat(enumName, enumConstant.getEnumConstantName(), '.');
        return new String(qualifiedName);
    } else if (binaryValue instanceof Object[]) {
        memberValuePair.valueKind = -1; // modified below by the first call to getMemberValue(...)
        Object[] binaryValues = (Object[]) binaryValue;
        int length = binaryValues.length;
        Object[] values = new Object[length];
        for (int i = 0; i < length; i++) {
            int previousValueKind = memberValuePair.valueKind;
            Object value = getAnnotationMemberValue(parent, manager, memberValuePair, binaryValues[i]);
            if (previousValueKind != -1 && memberValuePair.valueKind != previousValueKind) {
                // values are heterogeneous, value kind is thus unknown
                memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            }//from www  .java2  s. c  o m
            if (value instanceof Annotation) {
                Annotation annotation = (Annotation) value;
                for (int j = 0; j < i; j++) {
                    if (annotation.equals(values[j])) {
                        annotation.occurrenceCount++;
                    }
                }
            }
            values[i] = value;
        }
        if (memberValuePair.valueKind == -1)
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return values;
    } else {
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    }
}

From source file:com.codenvy.ide.ext.java.server.SourcesFromBytecodeGenerator.java

License:Open Source License

private void appendAnnotationValue(IAnnotation annotation, Object value, int valueKind, long flags,
        StringBuilder builder) throws JavaModelException {
    // Note: To be bug-compatible with Javadoc from Java 5/6/7, we currently don't escape HTML tags in String-valued annotations.
    if (value instanceof Object[]) {
        builder.append('{');
        Object[] values = (Object[]) value;
        for (int j = 0; j < values.length; j++) {
            if (j > 0)
                builder.append(JavaElementLabels.COMMA_STRING);
            value = values[j];/*from  w  w  w  .  j a v a2  s .c o  m*/
            appendAnnotationValue(annotation, value, valueKind, flags, builder);
        }
        builder.append('}');
    } else {
        switch (valueKind) {
        case IMemberValuePair.K_CLASS:
            appendTypeSignatureLabel(annotation, Signature.createTypeSignature((String) value, false), flags,
                    builder);
            builder.append(".class"); //$NON-NLS-1$
            break;
        case IMemberValuePair.K_QUALIFIED_NAME:
            String name = (String) value;
            int lastDot = name.lastIndexOf('.');
            if (lastDot != -1) {
                String type = name.substring(0, lastDot);
                String field = name.substring(lastDot + 1);
                appendTypeSignatureLabel(annotation, Signature.createTypeSignature(type, false), flags,
                        builder);
                builder.append('.');
                builder.append(getMemberName(annotation, type, field));
                break;
            }
            //            case IMemberValuePair.K_SIMPLE_NAME: // can't implement, since parent type is not known
            //$FALL-THROUGH$
        case IMemberValuePair.K_ANNOTATION:
            appendAnnotationLabel((IAnnotation) value, flags, builder);
            break;
        case IMemberValuePair.K_STRING:
            builder.append(ASTNodes.getEscapedStringLiteral((String) value));
            break;
        case IMemberValuePair.K_CHAR:
            builder.append(ASTNodes.getEscapedCharacterLiteral(((Character) value).charValue()));
            break;
        default:
            builder.append(String.valueOf(value));
            break;
        }
    }
}

From source file:com.microsoft.javapkgsrv.JavaElementLabelComposer.java

License:Open Source License

private void appendAnnotationValue(IAnnotation annotation, Object value, int valueKind, long flags)
        throws JavaModelException {
    // Note: To be bug-compatible with Javadoc from Java 5/6/7, we currently don't escape HTML tags in String-valued annotations.
    if (value instanceof Object[]) {
        fBuffer.append('{');
        Object[] values = (Object[]) value;
        for (int j = 0; j < values.length; j++) {
            if (j > 0)
                fBuffer.append(COMMA_STRING);
            value = values[j];//  w  w  w  .j  a  v a  2 s  .c  om
            appendAnnotationValue(annotation, value, valueKind, flags);
        }
        fBuffer.append('}');
    } else {
        switch (valueKind) {
        case IMemberValuePair.K_CLASS:
            appendTypeSignatureLabel(annotation, Signature.createTypeSignature((String) value, false), flags);
            fBuffer.append(".class"); //$NON-NLS-1$
            break;
        case IMemberValuePair.K_QUALIFIED_NAME:
            String name = (String) value;
            int lastDot = name.lastIndexOf('.');
            if (lastDot != -1) {
                String type = name.substring(0, lastDot);
                String field = name.substring(lastDot + 1);
                appendTypeSignatureLabel(annotation, Signature.createTypeSignature(type, false), flags);
                fBuffer.append('.');
                fBuffer.append(getMemberName(annotation, type, field));
                break;
            }
            //            case IMemberValuePair.K_SIMPLE_NAME: // can't implement, since parent type is not known
            //$FALL-THROUGH$
        case IMemberValuePair.K_ANNOTATION:
            appendAnnotationLabel((IAnnotation) value, flags);
            break;
        case IMemberValuePair.K_STRING:
            fBuffer.append(getEscapedStringLiteral((String) value));
            break;
        case IMemberValuePair.K_CHAR:
            fBuffer.append(getEscapedCharacterLiteral(((Character) value).charValue()));
            break;
        default:
            fBuffer.append(String.valueOf(value));
            break;
        }
    }
}

From source file:org.eclipse.che.jdt.internal.core.CompilationUnitStructureRequestor.java

License:Open Source License

protected Object getMemberValue(org.eclipse.che.jdt.internal.core.MemberValuePair memberValuePair,
        Expression expression) {//from  w w w  .j  av  a  2s. c o m
    if (expression instanceof NullLiteral) {
        return null;
    } else if (expression instanceof Literal) {
        ((Literal) expression).computeConstant();
        return Util.getAnnotationMemberValue(memberValuePair, expression.constant);
    } else if (expression instanceof org.eclipse.jdt.internal.compiler.ast.Annotation) {
        org.eclipse.jdt.internal.compiler.ast.Annotation annotation = (org.eclipse.jdt.internal.compiler.ast.Annotation) expression;
        Object handle = acceptAnnotation(annotation, null, (JavaElement) this.handleStack.peek());
        memberValuePair.valueKind = IMemberValuePair.K_ANNOTATION;
        return handle;
    } else if (expression instanceof ClassLiteralAccess) {
        ClassLiteralAccess classLiteral = (ClassLiteralAccess) expression;
        char[] name = CharOperation.concatWith(classLiteral.type.getTypeName(), '.');
        memberValuePair.valueKind = IMemberValuePair.K_CLASS;
        return new String(name);
    } else if (expression instanceof QualifiedNameReference) {
        char[] qualifiedName = CharOperation.concatWith(((QualifiedNameReference) expression).tokens, '.');
        memberValuePair.valueKind = IMemberValuePair.K_QUALIFIED_NAME;
        return new String(qualifiedName);
    } else if (expression instanceof SingleNameReference) {
        char[] simpleName = ((SingleNameReference) expression).token;
        if (simpleName == RecoveryScanner.FAKE_IDENTIFIER) {
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            return null;
        }
        memberValuePair.valueKind = IMemberValuePair.K_SIMPLE_NAME;
        return new String(simpleName);
    } else if (expression instanceof ArrayInitializer) {
        memberValuePair.valueKind = -1; // modified below by the first call to getMemberValue(...)
        Expression[] expressions = ((ArrayInitializer) expression).expressions;
        int length = expressions == null ? 0 : expressions.length;
        Object[] values = new Object[length];
        for (int i = 0; i < length; i++) {
            int previousValueKind = memberValuePair.valueKind;
            Object value = getMemberValue(memberValuePair, expressions[i]);
            if (previousValueKind != -1 && memberValuePair.valueKind != previousValueKind) {
                // values are heterogeneous, value kind is thus unknown
                memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
            }
            values[i] = value;
        }
        if (memberValuePair.valueKind == -1)
            memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return values;
    } else if (expression instanceof UnaryExpression) { // to deal with negative numerals (see bug - 248312)
        UnaryExpression unaryExpression = (UnaryExpression) expression;
        if ((unaryExpression.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT == OperatorIds.MINUS) {
            if (unaryExpression.expression instanceof Literal) {
                Literal subExpression = (Literal) unaryExpression.expression;
                subExpression.computeConstant();
                return Util.getNegativeAnnotationMemberValue(memberValuePair, subExpression.constant);
            }
        }
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    } else {
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    }
}

From source file:org.eclipse.jst.jsf.core.jsfappconfig.AnnotationSearchRequestor.java

License:Open Source License

private void addConverter(IAnnotation converterAnnotation, IType converterType) throws JavaModelException {
    String converterClassName = converterType.getFullyQualifiedName();
    IMemberValuePair[] pairs = converterAnnotation.getMemberValuePairs();
    String converterIDString = null;
    String converterForClassString = null;
    if (pairs != null) {
        for (IMemberValuePair pair : pairs) {
            if ("value".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) { //$NON-NLS-1$
                converterIDString = (String) pair.getValue();
            } else if ("forClass".equals(pair.getMemberName()) //$NON-NLS-1$
                    && pair.getValueKind() == IMemberValuePair.K_CLASS) {
                converterForClassString = (String) pair.getValue();
            }//from w  ww  . ja va2s .  com
        }
    }
    if (converterClassName != null) {
        ConverterType converter = FacesConfigFactory.eINSTANCE.createConverterType();
        ConverterClassType converterClass = FacesConfigFactory.eINSTANCE.createConverterClassType();
        converterClass.setTextContent(converterClassName);
        converter.setConverterClass(converterClass);

        if (converterIDString != null) {
            ConverterIdType converterID = FacesConfigFactory.eINSTANCE.createConverterIdType();
            converterID.setTextContent(converterIDString);
            converter.setConverterId(converterID);
        }

        if (converterForClassString == null) {
            //use the default
            converterForClassString = "java.lang.Object"; //$NON-NLS-1$
        }
        ConverterForClassType converterForClass = FacesConfigFactory.eINSTANCE.createConverterForClassType();
        converterForClass.setTextContent(converterForClassString);
        converter.setConverterForClass(converterForClass);
        facesConfig.getConverter().add(converter);
    }
}

From source file:org.eclipse.modisco.java.discoverer.internal.io.library.ClassFileParser.java

License:Open Source License

private Expression manageMemberValuePair(final IMemberValuePair defaultValue) {

    Expression result = null;//from  w  w  w .  j a  va2s. c  o m

    switch (defaultValue.getValueKind()) {
    case IMemberValuePair.K_CLASS:
        result = manageValuePairClassKind(defaultValue);
        break;

    case IMemberValuePair.K_ANNOTATION:
        result = manageValuePairAnnotationKind(defaultValue);
        break;

    case IMemberValuePair.K_QUALIFIED_NAME:
        result = manageValuePairQualifiedNameKind(defaultValue);
        break;

    case IMemberValuePair.K_BOOLEAN:
        if (defaultValue.getValue().getClass().isArray()) {
            Object[] tab = (Object[]) defaultValue.getValue();
            ArrayInitializer array = getFactory().createArrayInitializer();
            initializeNode(array);
            for (Object element : tab) {
                BooleanLiteral bool = getFactory().createBooleanLiteral();
                bool.setValue(((Boolean) element).booleanValue());
                array.getExpressions().add(bool);
            }
            result = array;
        } else {
            BooleanLiteral bool = getFactory().createBooleanLiteral();
            bool.setValue(((Boolean) defaultValue.getValue()).booleanValue());
            result = bool;
        }
        break;

    case IMemberValuePair.K_CHAR:
        if (defaultValue.getValue().getClass().isArray()) {
            Object[] tab = (Object[]) defaultValue.getValue();
            ArrayInitializer array = getFactory().createArrayInitializer();
            initializeNode(array);
            for (Object element : tab) {
                CharacterLiteral ch = getFactory().createCharacterLiteral();
                char value = ((Character) element).charValue();
                ch.setEscapedValue(ClassFileParserUtils.escapeCharacter(value));
                array.getExpressions().add(ch);
            }
            result = array;
        } else {
            CharacterLiteral ch = getFactory().createCharacterLiteral();
            char value = ((Character) defaultValue.getValue()).charValue();
            ch.setEscapedValue(ClassFileParserUtils.escapeCharacter(value));
            result = ch;
        }
        break;

    case IMemberValuePair.K_DOUBLE:
    case IMemberValuePair.K_BYTE:
    case IMemberValuePair.K_FLOAT:
    case IMemberValuePair.K_INT:
    case IMemberValuePair.K_LONG:
        if (defaultValue.getValue().getClass().isArray()) {
            Object[] tab = (Object[]) defaultValue.getValue();
            ArrayInitializer array = getFactory().createArrayInitializer();
            initializeNode(array);
            for (Object element : tab) {
                NumberLiteral number = getFactory().createNumberLiteral();
                number.setTokenValue(element.toString());
                array.getExpressions().add(number);
            }
            result = array;
        } else {
            NumberLiteral number = getFactory().createNumberLiteral();
            number.setTokenValue(defaultValue.getValue().toString());
            result = number;
        }
        break;

    case IMemberValuePair.K_STRING:
        if (defaultValue.getValue().getClass().isArray()) {
            Object[] tab = (Object[]) defaultValue.getValue();
            ArrayInitializer array = getFactory().createArrayInitializer();
            initializeNode(array);
            for (Object element : tab) {
                StringLiteral string = getFactory().createStringLiteral();
                String value = String.valueOf(element);
                string.setEscapedValue(ClassFileParserUtils.escapeString(value));
                array.getExpressions().add(string);
            }
            result = array;
        } else {
            StringLiteral string = getFactory().createStringLiteral();
            String value = String.valueOf(defaultValue.getValue());
            string.setEscapedValue(ClassFileParserUtils.escapeString(value));
            result = string;
        }
        break;

    case IMemberValuePair.K_SIMPLE_NAME: // there should be no K_SIMPLE_NAME
        // in .class files
    case IMemberValuePair.K_UNKNOWN:
    default:
        if (defaultValue.getValue().getClass().isArray()) {
            Object[] tab = (Object[]) defaultValue.getValue();
            ArrayInitializer array = getFactory().createArrayInitializer();
            initializeNode(array);
            for (Object element : tab) {
                UnresolvedItemAccess unrAcc = getFactory().createUnresolvedItemAccess();
                UnresolvedItem item = getFactory().createUnresolvedItem();
                unrAcc.setElement(item);
                item.setName(String.valueOf(element));
                array.getExpressions().add(unrAcc);
            }
            result = array;
        } else {
            UnresolvedItemAccess unrAcc = getFactory().createUnresolvedItemAccess();
            UnresolvedItem item = getFactory().createUnresolvedItem();
            unrAcc.setElement(item);
            item.setName(String.valueOf(defaultValue.getValue()));
            result = unrAcc;
        }
        break;
    }
    return result;
}

From source file:org.eclipse.objectteams.otdt.tests.AbstractJavaModelTests.java

License:Open Source License

private void appendAnnotationMemberValue(StringBuffer buffer, Object value, int kind)
        throws JavaModelException {
    if (value == null) {
        buffer.append("<null>");
        return;//from   w  w w. j  a va 2  s.  co m
    }
    switch (kind) {
    case IMemberValuePair.K_INT:
        buffer.append("(int)");
        buffer.append(value);
        break;
    case IMemberValuePair.K_BYTE:
        buffer.append("(byte)");
        buffer.append(value);
        break;
    case IMemberValuePair.K_SHORT:
        buffer.append("(short)");
        buffer.append(value);
        break;
    case IMemberValuePair.K_CHAR:
        buffer.append('\'');
        buffer.append(value);
        buffer.append('\'');
        break;
    case IMemberValuePair.K_FLOAT:
        buffer.append(value);
        buffer.append('f');
        break;
    case IMemberValuePair.K_DOUBLE:
        buffer.append("(double)");
        buffer.append(value);
        break;
    case IMemberValuePair.K_BOOLEAN:
        buffer.append(value);
        break;
    case IMemberValuePair.K_LONG:
        buffer.append(value);
        buffer.append('L');
        break;
    case IMemberValuePair.K_STRING:
        buffer.append('\"');
        buffer.append(value);
        buffer.append('\"');
        break;
    case IMemberValuePair.K_ANNOTATION:
        appendAnnotation(buffer, (IAnnotation) value);
        break;
    case IMemberValuePair.K_CLASS:
        buffer.append(value);
        buffer.append(".class");
        break;
    case IMemberValuePair.K_QUALIFIED_NAME:
        buffer.append(value);
        break;
    case IMemberValuePair.K_SIMPLE_NAME:
        buffer.append(value);
        break;
    case IMemberValuePair.K_UNKNOWN:
        appendAnnotationMemberValue(buffer, value, getValueKind(value));
        break;
    default:
        buffer.append(
                "<Unknown value: (" + (value == null ? "" : value.getClass().getName()) + ") " + value + ">");
        break;
    }
}

Example usage for org.eclipse.jdt.core IMemberValuePair K_CLASS

Introduction

Prototype

Document

Usage