/******************************************************************************* | |
* Copyright (c) 2009 by SAP AG, Walldorf. | |
* All rights reserved. This program and the accompanying materials | |
* are made available under the terms of the Eclipse Public License v1.0 | |
* which accompanies this distribution, and is available at | |
* http://www.eclipse.org/legal/epl-v10.html | |
* | |
* Contributors: | |
* SAP AG - initial API and implementation | |
*******************************************************************************/ | |
package org.eclipse.jst.ws.jaxws.utils.internal.annotations.impl; | |
import static org.eclipse.jst.ws.jaxws.utils.ContractChecker.nullCheckParam; | |
import java.util.Collection; | |
import java.util.HashSet; | |
import java.util.Iterator; | |
import java.util.List; | |
import java.util.Set; | |
import org.eclipse.jdt.core.ICompilationUnit; | |
import org.eclipse.jdt.core.IField; | |
import org.eclipse.jdt.core.IImportDeclaration; | |
import org.eclipse.jdt.core.IJavaElement; | |
import org.eclipse.jdt.core.IMember; | |
import org.eclipse.jdt.core.IMethod; | |
import org.eclipse.jdt.core.IType; | |
import org.eclipse.jdt.core.ITypeParameter; | |
import org.eclipse.jdt.core.JavaModelException; | |
import org.eclipse.jdt.core.dom.ASTNode; | |
import org.eclipse.jdt.core.dom.AbstractTypeDeclaration; | |
import org.eclipse.jdt.core.dom.Annotation; | |
import org.eclipse.jdt.core.dom.ArrayInitializer; | |
import org.eclipse.jdt.core.dom.BodyDeclaration; | |
import org.eclipse.jdt.core.dom.BooleanLiteral; | |
import org.eclipse.jdt.core.dom.CompilationUnit; | |
import org.eclipse.jdt.core.dom.Expression; | |
import org.eclipse.jdt.core.dom.FieldDeclaration; | |
import org.eclipse.jdt.core.dom.IExtendedModifier; | |
import org.eclipse.jdt.core.dom.MarkerAnnotation; | |
import org.eclipse.jdt.core.dom.MemberValuePair; | |
import org.eclipse.jdt.core.dom.MethodDeclaration; | |
import org.eclipse.jdt.core.dom.Name; | |
import org.eclipse.jdt.core.dom.NormalAnnotation; | |
import org.eclipse.jdt.core.dom.NumberLiteral; | |
import org.eclipse.jdt.core.dom.QualifiedName; | |
import org.eclipse.jdt.core.dom.QualifiedType; | |
import org.eclipse.jdt.core.dom.SimpleType; | |
import org.eclipse.jdt.core.dom.SingleMemberAnnotation; | |
import org.eclipse.jdt.core.dom.SingleVariableDeclaration; | |
import org.eclipse.jdt.core.dom.StringLiteral; | |
import org.eclipse.jdt.core.dom.Type; | |
import org.eclipse.jdt.core.dom.TypeDeclaration; | |
import org.eclipse.jdt.core.dom.TypeLiteral; | |
import org.eclipse.jst.ws.jaxws.utils.ContractChecker; | |
import org.eclipse.jst.ws.jaxws.utils.annotations.AnnotationFactory; | |
import org.eclipse.jst.ws.jaxws.utils.annotations.IAnnotation; | |
import org.eclipse.jst.ws.jaxws.utils.annotations.IAnnotationInspector; | |
import org.eclipse.jst.ws.jaxws.utils.annotations.ILocator; | |
import org.eclipse.jst.ws.jaxws.utils.annotations.IParamValuePair; | |
import org.eclipse.jst.ws.jaxws.utils.annotations.IValue; | |
import org.eclipse.jst.ws.jaxws.utils.clazz.ASTUtils; | |
/** | |
* Class, which is made to load and return annotations from a given IJavaElemet. | |
* | |
* @author Plamen Pavlov | |
*/ | |
public class AnnotationInspectorImpl implements IAnnotationInspector | |
{ | |
private IType iType; | |
private CompilationUnit cUnit; | |
public AnnotationInspectorImpl(final IType type) | |
{ | |
ContractChecker.nullCheckParam(type, "type"); //$NON-NLS-1$ | |
this.iType = type; | |
} | |
public IAnnotation<IMethod> inspectMethod(final IMethod method, final String annotationQName) throws JavaModelException | |
{ | |
ContractChecker.nullCheckParam(method, "method"); //$NON-NLS-1$ | |
ContractChecker.nullCheckParam(annotationQName, "annotationQName"); //$NON-NLS-1$ | |
if(!(method instanceof IMethod)) | |
{ | |
throw new IllegalArgumentException("method argument is not of correct Type!"); //$NON-NLS-1$ | |
} | |
if(annotationQName.trim().equals("")) //$NON-NLS-1$ | |
{ | |
throw new IllegalArgumentException("annotationQName argument is not with propper value!"); //$NON-NLS-1$ | |
} | |
return getSpecificAnnotationFromMember(method, method.getParent().getElementName(), annotationQName); | |
} | |
public Collection<IAnnotation<IMethod>> inspectMethod(IMethod method) throws JavaModelException | |
{ | |
ContractChecker.nullCheckParam(method, "method"); //$NON-NLS-1$ | |
if(!(method instanceof IMethod)) | |
{ | |
throw new IllegalArgumentException("method argument is not of correct Type!"); //$NON-NLS-1$ | |
} | |
return getFromMember(method, method.getParent().getElementName()); | |
} | |
public IAnnotation<IField> inspectField(final IField field, final String annotationQName) throws JavaModelException | |
{ | |
nullCheckParam(field, "field"); //$NON-NLS-1$ | |
nullCheckParam(annotationQName, "annotationQName"); //$NON-NLS-1$ | |
if(!(field instanceof IField)) | |
{ | |
throw new IllegalArgumentException("field argument is not of correct Type!"); //$NON-NLS-1$ | |
} | |
if(annotationQName.trim().equals("")) //$NON-NLS-1$ | |
{ | |
throw new IllegalArgumentException("annotationQName argument is not with propper value!"); //$NON-NLS-1$ | |
} | |
final String className = field.getParent().getElementName(); | |
return getSpecificAnnotationFromMember(field, className, annotationQName); | |
} | |
public Collection<IAnnotation<IField>> inspectField(IField field) throws JavaModelException | |
{ | |
if (field == null) | |
{ | |
throw new NullPointerException("field should not be null!"); //$NON-NLS-1$ | |
} | |
if(!(field instanceof IField)) | |
{ | |
throw new IllegalArgumentException("field argument is not of correct Type!"); //$NON-NLS-1$ | |
} | |
final String className = field.getParent().getElementName(); | |
return getFromMember(field, className); | |
} | |
public IAnnotation<ITypeParameter> inspectParam(final ITypeParameter param, final String annotationQName) throws JavaModelException | |
{ | |
nullCheckParam(param, "param"); //$NON-NLS-1$ | |
nullCheckParam(annotationQName, "annotationQName"); //$NON-NLS-1$ | |
if(!(param instanceof ITypeParameter)) | |
{ | |
throw new IllegalArgumentException("param argument is not of correct Type!"); //$NON-NLS-1$ | |
} | |
if(annotationQName.trim().equals("")) //$NON-NLS-1$ | |
{ | |
throw new IllegalArgumentException("annotationQName argument is not with propper value!"); //$NON-NLS-1$ | |
} | |
final String className = getClassNameFromParam(param); | |
return getSpecificAnnotationFromMember(param, className, annotationQName); | |
} | |
public Collection<IAnnotation<ITypeParameter>> inspectParam(ITypeParameter param) throws JavaModelException | |
{ | |
if (param == null) | |
{ | |
throw new NullPointerException("param should not be null!"); //$NON-NLS-1$ | |
} | |
if(!(param instanceof ITypeParameter)) | |
{ | |
throw new IllegalArgumentException("param argument is not of correct Type!"); //$NON-NLS-1$ | |
} | |
return getFromMember(param, getClassNameFromParam(param)); | |
} | |
public IAnnotation<IType> inspectType(final String annotationQName) throws JavaModelException | |
{ | |
nullCheckParam(annotationQName, "annotationQName"); //$NON-NLS-1$ | |
if (annotationQName.trim().equals("")) //$NON-NLS-1$ | |
{ | |
throw new IllegalArgumentException("annotationQName argument is not with propper value!"); //$NON-NLS-1$ | |
} | |
return getSpecificAnnotationFromMember(iType, iType.getElementName(), annotationQName); | |
} | |
public Collection<IAnnotation<IType>> inspectType() throws JavaModelException | |
{ | |
return getFromMember(iType, iType.getElementName()); | |
} | |
// # implementation | |
private String getClassNameFromParam(final ITypeParameter param) throws JavaModelException | |
{ | |
if(param.getDeclaringMember() instanceof IMethod) | |
{ | |
return param.getDeclaringMember().getParent().getElementName(); | |
} | |
return param.getDeclaringMember().getElementName(); | |
} | |
protected <T extends IJavaElement> Set<IAnnotation<T>> getFromMember(T type, String className) throws JavaModelException | |
{ | |
if (!isSupportedJavaElement(type)) { | |
throw new IllegalArgumentException("passed argument is not of correct type."); //$NON-NLS-1$ | |
} | |
ICompilationUnit cUnit = null; | |
if(type instanceof IMember) { | |
cUnit = ((IMember)type).getCompilationUnit(); | |
} | |
else { | |
cUnit = ((ITypeParameter)type).getDeclaringMember().getCompilationUnit(); | |
} | |
if (cUnit == null) { | |
return new HashSet<IAnnotation<T>>(); | |
} | |
final CompilationUnit unit = getCompilationUnit(); | |
final AbstractTypeDeclaration typeDeclaration = ASTUtils.getInstance().getTypeDeclaration(className, unit); | |
switch(type.getElementType()) | |
{ | |
case IJavaElement.TYPE: | |
return getAnnotations(type, typeDeclaration); | |
case IJavaElement.FIELD: | |
FieldDeclaration fieldDeclaration = ASTUtils.getInstance().getFieldDeclaration((IField) type, (TypeDeclaration)typeDeclaration); | |
return getAnnotations(type, fieldDeclaration); | |
case IJavaElement.METHOD: | |
MethodDeclaration methodDeclaration = ASTUtils.getInstance().getMethodDeclaration((IMethod) type, (TypeDeclaration)typeDeclaration); | |
return getAnnotations(type, methodDeclaration); | |
case IJavaElement.TYPE_PARAMETER: | |
methodDeclaration = ASTUtils.getInstance().getMethodDeclaration((IMethod)((ITypeParameter) type).getParent(), (TypeDeclaration)typeDeclaration); | |
return getParamAnnotations(type, methodDeclaration); | |
} | |
return new HashSet<IAnnotation<T>>(); | |
} | |
@SuppressWarnings("unchecked") | |
private <T extends IJavaElement> Set<IAnnotation<T>> getAnnotations(T iMember, BodyDeclaration bodyDeclaration) throws JavaModelException | |
{ | |
if (bodyDeclaration != null) | |
{ | |
List list = bodyDeclaration.modifiers(); | |
return extractAnnotations(iMember, list); | |
} | |
return new HashSet<IAnnotation<T>>(); | |
} | |
@SuppressWarnings("unchecked") | |
private <T extends IJavaElement> Set<IAnnotation<T>> getParamAnnotations(T iMember, MethodDeclaration methodDeclaration) throws JavaModelException | |
{ | |
if (methodDeclaration != null) | |
{ | |
for (Object param : methodDeclaration.parameters()) | |
{ | |
if (param instanceof SingleVariableDeclaration && | |
((ITypeParameter)iMember).getElementName().toString().equals(((SingleVariableDeclaration)param).getName().toString())) | |
{ | |
List list = ((SingleVariableDeclaration) param).modifiers(); | |
return extractAnnotations(iMember, list); | |
} | |
} | |
} | |
return new HashSet<IAnnotation<T>>(); | |
} | |
@SuppressWarnings("unchecked") | |
private <T extends IJavaElement> Set<IAnnotation<T>> extractAnnotations(T iMember, List list) throws JavaModelException | |
{ | |
Iterator iter = list.iterator(); | |
Set<IValue> values = new HashSet<IValue>(); | |
while (iter.hasNext()) | |
{ | |
IExtendedModifier element = (IExtendedModifier) iter.next(); | |
if (element.isAnnotation()) | |
{ | |
values.add(convertExpression((Expression) element)); | |
} | |
} | |
Set<IAnnotation<T>> expressions = new HashSet<IAnnotation<T>>(); | |
for (IValue value : values) | |
{ | |
AnnotationImpl<T> ann = (AnnotationImpl<T>)value; | |
ann.setAppliedElementWithoutSave(iMember); | |
expressions.add(ann); | |
} | |
return expressions; | |
} | |
@SuppressWarnings("unchecked") | |
private <T extends IJavaElement> IAnnotation<T> extractSpecificAnnotation(T iMember, List list, IType type, String annotationQName) throws JavaModelException | |
{ | |
Iterator iter = list.iterator(); | |
Set<IValue> values = new HashSet<IValue>(); | |
while (iter.hasNext()) | |
{ | |
IExtendedModifier element = (IExtendedModifier) iter.next(); | |
if (element.isAnnotation()) | |
{ | |
final Name typeName = ((Annotation)element).getTypeName(); | |
if (annotationQName.endsWith(typeName.getFullyQualifiedName())) { | |
values.add(convertExpression((Expression) element)); | |
} | |
} | |
} | |
for (IValue value : values) | |
{ | |
AnnotationImpl<T> tmpAnnotation = (AnnotationImpl<T>)value; | |
if(checkSpecificAnnotattion(tmpAnnotation, type, annotationQName)) | |
{ | |
AnnotationImpl<T> result = new AnnotationImpl<T>(annotationQName, tmpAnnotation.getParamValuePairs()); | |
result.setAppliedElementWithoutSave(iMember); | |
result.setLocator(tmpAnnotation.getLocator()); | |
return result; | |
} | |
} | |
return null; | |
} | |
private <T extends IJavaElement> boolean checkSpecificAnnotattion(final AnnotationImpl<T> annotation, final IType type, final String annotationQName) throws JavaModelException | |
{ | |
if(annotation.getAnnotationName().equals(annotationQName) || | |
(type.getPackageFragment().getElementName() + "." + annotation.getAnnotationName()).equals(annotationQName)) //$NON-NLS-1$ | |
{ | |
return true; | |
} | |
ICompilationUnit cUnit = type.getCompilationUnit(); | |
IImportDeclaration[] imports = cUnit.getImports(); | |
for (IImportDeclaration importDeclaration : imports) | |
{ | |
if(annotationQName.endsWith(annotation.getAnnotationName()) && importDeclaration.getElementName().equals(annotationQName)) | |
{ | |
return true; | |
} | |
} | |
for (IImportDeclaration importDeclaration : imports) | |
{ | |
if(importDeclaration.getElementName().endsWith("*")) //$NON-NLS-1$ | |
{ | |
String importStr = importDeclaration.getElementName().substring(0, importDeclaration.getElementName().length() - 1); | |
if(annotationQName.endsWith(annotation.getAnnotationName()) && annotationQName.indexOf(importStr) == 0) | |
{ | |
return true; | |
} | |
} | |
} | |
return false; | |
} | |
@SuppressWarnings("unchecked") | |
private IValue convertExpression(Expression element) throws JavaModelException | |
{ | |
switch (element.getNodeType()) | |
{ | |
case ASTNode.MARKER_ANNOTATION: | |
{ | |
MarkerAnnotation ma = (MarkerAnnotation) element; | |
AnnotationImpl annotation = new AnnotationImpl(getFullyQualifiedAnnotationName(ma), new HashSet<IParamValuePair>()); | |
annotation.setLocator(createLocator(ma)); | |
return annotation; | |
} | |
case ASTNode.SINGLE_MEMBER_ANNOTATION: | |
{ | |
final SingleMemberAnnotation sma = (SingleMemberAnnotation) element; | |
final Set<IParamValuePair> values = new HashSet<IParamValuePair>(); | |
final IValue value = convertExpression(sma.getValue()); | |
if (value!=null) { | |
values.add(AnnotationFactory.createParamValuePairValue("value", value)); //$NON-NLS-1$ | |
} | |
AnnotationImpl annotation = new AnnotationImpl(getFullyQualifiedAnnotationName(sma), values); | |
annotation.setLocator(createLocator(sma)); | |
return annotation; | |
} | |
case ASTNode.NORMAL_ANNOTATION: | |
{ | |
return getNormalAnnotationValue((NormalAnnotation) element); | |
} | |
case ASTNode.ARRAY_INITIALIZER: | |
{ | |
ArrayInitializer arr = (ArrayInitializer) element; | |
List<Expression> list = arr.expressions(); | |
Iterator<Expression> iter = list.iterator(); | |
Set<IValue> result = new HashSet<IValue>(); | |
while (iter.hasNext()) | |
{ | |
Expression expr = (Expression) iter.next(); | |
result.add(convertExpression(expr)); | |
} | |
return new ArrayValueImpl(result); | |
} | |
case ASTNode.NULL_LITERAL: | |
{ | |
// return AnnotationFactory.createNullValue(); | |
break; | |
} | |
case ASTNode.SIMPLE_NAME: | |
{ | |
break;//return new StringValueImpl(((SimpleName)element).getIdentifier()); | |
} | |
case ASTNode.TYPE_LITERAL: | |
{ | |
return getTypeLiteralValue((TypeLiteral) element); | |
} | |
case ASTNode.QUALIFIED_NAME: | |
{ | |
QualifiedName qn = (QualifiedName) element; | |
QualifiedNameValueImpl qnValue = new QualifiedNameValueImpl(qn.getFullyQualifiedName()); | |
qnValue.setLocator(createLocator(qn)); | |
return qnValue; | |
} | |
case ASTNode.BOOLEAN_LITERAL: | |
{ | |
BooleanLiteral bl = (BooleanLiteral) element; | |
BooleanValueImpl bValue = new BooleanValueImpl(bl.booleanValue()); | |
bValue.setLocator(createLocator(bl)); | |
return bValue; | |
} | |
case ASTNode.CHARACTER_LITERAL: | |
{ | |
// CharacterLiteral cl = (CharacterLiteral) element; | |
// TODO Finish with this return new CharacterValue(cl.charValue()); | |
break; | |
} | |
case ASTNode.NUMBER_LITERAL: | |
{ | |
NumberLiteral nl = (NumberLiteral) element; | |
IntegerValueImpl intValue = new IntegerValueImpl(nl.getToken()); | |
intValue.setLocator(createLocator(nl)); | |
return intValue; | |
} | |
case ASTNode.STRING_LITERAL: | |
{ | |
StringLiteral sl = (StringLiteral) element; | |
StringValueImpl strValue = new StringValueImpl(sl.getLiteralValue()); | |
strValue.setLocator(createLocator(sl)); | |
return strValue; | |
} | |
} | |
return null; | |
} | |
private IValue getTypeLiteralValue(TypeLiteral tl) throws JavaModelException | |
{ | |
Type type = tl.getType(); | |
Name name = null; | |
if (type.isQualifiedType()) | |
{ | |
name = ((QualifiedType) type).getName(); | |
} else | |
{ | |
if (type.isSimpleType()) | |
{ | |
name = ((SimpleType) type).getName(); | |
} | |
} | |
if (name != null) | |
{ | |
CompilationUnit cu = getCompilationUnit(tl); | |
if (cu != null) | |
{ | |
String fullyQualifiedName = name.getFullyQualifiedName(); | |
if (type.isSimpleType()) | |
{ | |
fullyQualifiedName = resolveType((ICompilationUnit) cu.getJavaElement(), fullyQualifiedName); | |
} | |
ClassValueImpl cValue = new ClassValueImpl(fullyQualifiedName); | |
cValue.setLocator(createLocator(tl)); | |
return cValue; | |
} | |
} | |
return null; | |
} | |
@SuppressWarnings("unchecked") | |
private IValue getNormalAnnotationValue(NormalAnnotation na) throws JavaModelException | |
{ | |
List<MemberValuePair> l = na.values(); | |
Iterator<MemberValuePair> iter = l.iterator(); | |
Set<IParamValuePair> result = new HashSet<IParamValuePair>(); | |
while (iter.hasNext()) | |
{ | |
MemberValuePair mvp = (MemberValuePair) iter.next(); | |
IValue mvpval = convertExpression(mvp.getValue()); | |
ParamValuePairImpl pair = new ParamValuePairImpl(mvp.getName().getIdentifier(), mvpval); | |
pair.setLocator(createLocator(mvp)); | |
result.add(pair); | |
} | |
AnnotationImpl annotation = new AnnotationImpl(getFullyQualifiedAnnotationName(na), result); | |
annotation.setLocator(createLocator(na)); | |
return annotation; | |
} | |
private String getFullyQualifiedAnnotationName(Annotation anno) throws JavaModelException | |
{ | |
Name typeName = anno.getTypeName(); | |
String fullyQualifiedName = typeName.getFullyQualifiedName(); | |
if (typeName.isSimpleName()) | |
{ | |
CompilationUnit cu = getCompilationUnit(anno); | |
fullyQualifiedName = resolveType((ICompilationUnit) cu.getJavaElement(), fullyQualifiedName); | |
} | |
return fullyQualifiedName; | |
} | |
private CompilationUnit getCompilationUnit(Expression element) | |
{ | |
ASTNode cu = element; | |
while (cu != null && !(cu instanceof CompilationUnit)) | |
{ | |
cu = cu.getParent(); | |
} | |
return (CompilationUnit) cu; | |
} | |
private String resolveType(ICompilationUnit icu, String fullyQualifiedName) throws JavaModelException | |
{ | |
String localFullyQualifiedName = fullyQualifiedName; | |
IType[] allTypes = icu.getAllTypes(); | |
if (allTypes == null) | |
{ | |
return localFullyQualifiedName; | |
} | |
for (int i = 0; i < allTypes.length; i++) | |
{ | |
String[][] resolvedType = allTypes[i].resolveType(localFullyQualifiedName); | |
if (resolvedType != null && resolvedType.length > 0) | |
{ | |
StringBuffer buf = new StringBuffer(); | |
for (int j = 0; j < resolvedType[0].length; j++) | |
{ | |
buf = appendDot(j, buf); | |
buf.append(resolvedType[0][j]); | |
} | |
localFullyQualifiedName = buf.toString(); | |
break; | |
} | |
} | |
return localFullyQualifiedName; | |
} | |
private StringBuffer appendDot(int index, StringBuffer buff) | |
{ | |
StringBuffer result = buff; | |
if (index != 0) | |
{ | |
result.append('.'); | |
} | |
return result; | |
} | |
protected <T extends IJavaElement> IAnnotation<T> getSpecificAnnotationFromMember(final T type, final String className, final String annotationQName) throws JavaModelException | |
{ | |
if (!isSupportedJavaElement(type)) | |
{ | |
throw new IllegalArgumentException("passed argument is not of correct type."); //$NON-NLS-1$ | |
} | |
ICompilationUnit cUnit = null; | |
if (type instanceof IMember) { | |
cUnit = ((IMember)type).getCompilationUnit(); | |
} | |
else { | |
cUnit = ((ITypeParameter)type).getDeclaringMember().getCompilationUnit(); | |
} | |
if (cUnit == null) { | |
return null; | |
} | |
final CompilationUnit unit = getCompilationUnit(); | |
final AbstractTypeDeclaration typeDeclaration = ASTUtils.getInstance().getTypeDeclaration(className, unit); | |
switch(type.getElementType()) | |
{ | |
case IJavaElement.TYPE: | |
return getSpecificAnnotation(type, typeDeclaration, (IType)type, annotationQName); | |
case IJavaElement.FIELD: | |
IField field = (IField) type; | |
FieldDeclaration fieldDeclaration = ASTUtils.getInstance().getFieldDeclaration(field, (TypeDeclaration)typeDeclaration); | |
return getSpecificAnnotation(type, fieldDeclaration, field.getDeclaringType(), annotationQName); | |
case IJavaElement.METHOD: | |
IMethod method = (IMethod) type; | |
MethodDeclaration methodDeclaration = ASTUtils.getInstance().getMethodDeclaration(method, (TypeDeclaration)typeDeclaration); | |
return getSpecificAnnotation(type, methodDeclaration, method.getDeclaringType(), annotationQName); | |
case IJavaElement.TYPE_PARAMETER: | |
method = (IMethod)((ITypeParameter) type).getParent(); | |
methodDeclaration = ASTUtils.getInstance().getMethodDeclaration(method, (TypeDeclaration)typeDeclaration); | |
return getSpecificParamAnnotation(type, methodDeclaration, method.getDeclaringType(), annotationQName); | |
} | |
return null; | |
} | |
private <T extends IJavaElement> IAnnotation<T> getSpecificAnnotation(final T iMember, final BodyDeclaration bodyDeclaration, final IType type, final String annotationQName) throws JavaModelException | |
{ | |
if (bodyDeclaration != null) | |
{ | |
@SuppressWarnings("unchecked") | |
final List list = bodyDeclaration.modifiers(); | |
return extractSpecificAnnotation(iMember, list, type, annotationQName); | |
} | |
return null; | |
} | |
private <T extends IJavaElement> IAnnotation<T> getSpecificParamAnnotation(T iMember, MethodDeclaration methodDeclaration, final IType type, final String annotationQName) throws JavaModelException | |
{ | |
if (methodDeclaration != null) | |
{ | |
for (Object param : methodDeclaration.parameters()) | |
{ | |
if (param instanceof SingleVariableDeclaration && | |
((ITypeParameter)iMember).getElementName().toString().equals(((SingleVariableDeclaration)param).getName().toString())) | |
{ | |
@SuppressWarnings("unchecked") | |
final List list = ((SingleVariableDeclaration) param).modifiers(); | |
return extractSpecificAnnotation(iMember, list, type, annotationQName); | |
} | |
} | |
} | |
return null; | |
} | |
private boolean isSupportedJavaElement(final IJavaElement javaElement) | |
{ | |
return javaElement.getElementType()==IJavaElement.METHOD || | |
javaElement.getElementType()==IJavaElement.TYPE || | |
javaElement.getElementType()==IJavaElement.FIELD || | |
javaElement.getElementType()==IJavaElement.TYPE_PARAMETER; | |
} | |
private CompilationUnit getCompilationUnit() | |
{ | |
if (cUnit==null) { | |
cUnit = ASTUtils.getInstance().createCompilationUnit(iType.getCompilationUnit(), null); | |
} | |
return cUnit; | |
} | |
private ILocator createLocator(final ASTNode node) | |
{ | |
final int lineNumber = getCompilationUnit().getLineNumber(node.getStartPosition()); | |
return new LocatorImpl(lineNumber, node.getStartPosition(), node.getLength()); | |
} | |
} |