Java IAnnotation.getElementName方法代码示例

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
/**
 * Remove any annotations that we don't want considered.
 *
 * @param annotationSet
 *            The set of annotations to work with.
 * @param type
 *            The type declaring the annotations.
 * @throws JavaModelException
 *             When resolving the annotation FQN fails.
 */
private void removeSpecialAnnotations(Set<IAnnotation> annotationSet, IType type) throws JavaModelException {
	// Special case: don't consider the @Override annotation in the source
	// (the target will never have this) #67.
	annotationSet.removeIf(a -> a.getElementName().equals(Override.class.getName()));
	annotationSet.removeIf(a -> a.getElementName().equals(Override.class.getSimpleName()));

	// also remove nonstandard annotations if necessary.
	if (!this.shouldConsiderNonstandardAnnotationDifferences())
		for (Iterator<IAnnotation> iterator = annotationSet.iterator(); iterator.hasNext();) {
			IAnnotation annotation = iterator.next();

			String annotationName = annotation.getElementName();
			String[][] resolveTyped = type.resolveType(annotationName);

			for (String[] element : resolveTyped) {
				String[] strings = element;

				// first element is the package name.
				if (!strings[0].startsWith("java.lang"))
					iterator.remove();
			}
		}
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
private void appendAnnotation(IAnnotation annotation) throws JavaModelException {
  String name = annotation.getElementName();
  if (!fStubInvisible && name.startsWith("sun.")) // $NON-NLS-1$
  return; // skip Sun-internal annotations

  fBuffer.append('@');
  fBuffer.append(name);
  fBuffer.append('(');

  IMemberValuePair[] memberValuePairs = annotation.getMemberValuePairs();
  for (IMemberValuePair pair : memberValuePairs) {
    fBuffer.append(pair.getMemberName());
    fBuffer.append('=');
    appendAnnotationValue(pair.getValue(), pair.getValueKind());
    fBuffer.append(',');
  }
  if (memberValuePairs.length > 0) fBuffer.deleteCharAt(fBuffer.length() - 1);

  fBuffer.append(')').append('\n');
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
/**
 * Check if a method is test method.
 *
 * @param method method which should be checked
 * @param compilationUnit parent of the method
 * @param testAnnotation java annotation which describes test method in the test framework
 * @return {@code true} if the method is test method
 */
public boolean isTest(IMethod method, ICompilationUnit compilationUnit, String testAnnotation) {
  try {
    IAnnotation[] annotations = method.getAnnotations();
    IAnnotation test = null;
    for (IAnnotation annotation : annotations) {
      String annotationElementName = annotation.getElementName();
      if ("Test".equals(annotationElementName)) {
        test = annotation;
        break;
      }
      if (testAnnotation.equals(annotationElementName)) {
        return true;
      }
    }
    return test != null && isImportOfTestAnnotationExist(compilationUnit, testAnnotation);
  } catch (JavaModelException e) {
    LOG.info("Can't read method's annotations.", e);
    return false;
  }
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
private void appendAnnotation(IAnnotation annotation) throws JavaModelException {
	String name= annotation.getElementName();
	if (!fStubInvisible && name.startsWith("sun.")) //$NON-NLS-1$
		return; // skip Sun-internal annotations 
	
	fBuffer.append('@');
	fBuffer.append(name);
	fBuffer.append('(');
	
	IMemberValuePair[] memberValuePairs= annotation.getMemberValuePairs();
	for (IMemberValuePair pair : memberValuePairs) {
		fBuffer.append(pair.getMemberName());
		fBuffer.append('=');
		appendAnnotationValue(pair.getValue(), pair.getValueKind());
		fBuffer.append(',');
	}
	if (memberValuePairs.length > 0)
		fBuffer.deleteCharAt(fBuffer.length() - 1);
	
	fBuffer.append(')').append('\n');
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
@Override
public boolean matches(IMethod method) throws JavaModelException
{
	for (IAnnotation annotation : method.getAnnotations())
	{
		String annotationName = annotation.getElementName();
		if (MybatipseConstants.ANNOTATION_RESULTS.equals(annotationName))
		{
			IMemberValuePair[] valuePairs = annotation.getMemberValuePairs();
			for (IMemberValuePair valuePair : valuePairs)
			{
				if ("id".equals(valuePair.getMemberName()))
				{
					String resultsId = (String)valuePair.getValue();
					return nameMatches(resultsId, matchString, exactMatch);
				}
			}
		}
	}
	return false;
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
private Set<IPath> getAnnotationTypes(
    final List<IAnnotation> annotations,
    final List<IImport> imports,
    final Path path) {
  final Set<IPath> annotationPaths = new HashSet<>();
  for (final IAnnotation annotation : annotations) {
    final String qualifiedName = annotation.getElementName();
    annotationPaths.add(createTypePath(imports, path, qualifiedName));
  }
  return annotationPaths;
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
private static boolean isDefaultExtensionsAnnotation(IAnnotation annotation) {
  String name = annotation.getElementName();

  // Annotation name can be either simple or qualified, depending on whether
  // the annotation is a binary or source type
  return name.equals(DEFAULT_EXTENSIONS_ANNOTATION_NAME)
      || name.equals(Signature.getSimpleName(DEFAULT_EXTENSIONS_ANNOTATION_NAME));
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
protected boolean isSelect() throws JavaModelException
{
	IAnnotation[] annotations = method.getAnnotations();
	for (IAnnotation annotation : annotations)
	{
		String name = annotation.getElementName();
		if ("Select".equals(name) || "SelectProvider".equals(name))
		{
			return true;
		}
	}
	return false;
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
private static boolean isJUnitStateMethod(IMethod method, JunitVersion junitVersion) throws JavaModelException {
	if (junitVersion == JunitVersion.JUNIT4) {
		IAnnotation[] annotations = method.getAnnotations();
		for (IAnnotation annotation : annotations) {
			String name = annotation.getElementName();
			if (filteredMethodAnnotations .contains(name)) {
				return true;
			}
		}
		return false;
	} else {
		String methodName = method.getElementName();
		return isNoArgMethod(method) && filteredJunit3Methods.contains(methodName);
	}
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
protected void visitAnnotation(final IAnnotation annotation, final Annotation anno)
		throws JavaModelException {
	initializeNode(anno);

	String typeName = annotation.getElementName();
	// typeName is not a signature : java.lang.Deprecated
	String typeSignature = Signature.createTypeSignature(typeName, true);
	anno.setType(getRefOnType(typeSignature));

	for (IMemberValuePair valuePair : annotation.getMemberValuePairs()) {
		AnnotationMemberValuePair element = getFactory().createAnnotationMemberValuePair();
		initializeNode(element);
		anno.getValues().add(element);

		Expression value = manageMemberValuePair(valuePair);
		element.setValue(value);

		// member is a method declared in an annotation
		PendingElement pending = new PendingElement(getFactory());
		pending.setClientNode(element);
		pending.setLinkName("member"); //$NON-NLS-1$
		Binding id = null;
		if (this.typeFinder.isTypeExists(typeName)) {
			ClassBinding parent = JavaModelDelegateBindingFactory.getInstance()
					.getBindingForName(typeSignature, this, true);
			id = new MethodBinding();
			((MethodBinding) id).setDeclaringClass(parent);
			id.setName(valuePair.getMemberName());
		} else {
			id = new Binding();
			id.setName(typeName + "." + valuePair.getMemberName() + "()"); //$NON-NLS-1$ //$NON-NLS-2$
		}
		getGlobalBindings().addPending(pending, id);
	}
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
public List<ICompletionProposal> computeCompletionProposals(
	ContentAssistInvocationContext context, IProgressMonitor monitor)
{
	if (context instanceof JavaContentAssistInvocationContext)
	{
		JavaContentAssistInvocationContext javaContext = (JavaContentAssistInvocationContext)context;
		ICompilationUnit unit = javaContext.getCompilationUnit();
		try
		{
			if (unit == null || !unit.isStructureKnown())
				return Collections.emptyList();
			IType primaryType = unit.findPrimaryType();
			if (primaryType == null || !primaryType.isInterface())
				return Collections.emptyList();

			int offset = javaContext.getInvocationOffset();
			IJavaElement element = unit.getElementAt(offset);
			if (element == null || !(element instanceof IMethod))
				return Collections.emptyList();

			IAnnotation annotation = JavaMapperUtil.getAnnotationAt((IAnnotatable)element, offset);
			if (annotation == null)
				return Collections.emptyList();

			final IJavaProject project = javaContext.getProject();
			final IMethod method = (IMethod)element;
			final String mapperFqn = method.getDeclaringType().getFullyQualifiedName();
			if (isInlineStatementAnnotation(annotation))
			{
				return proposeStatementText(project, unit, offset, annotation, method);
			}
			else
			{
				String elementName = annotation.getElementName();
				if ("ResultMap".equals(elementName))
				{
					return proposeResultMap(project, mapperFqn, offset, annotation);
				}
				else if ("Results".equals(elementName))
				{
					return proposeResults(project, mapperFqn, offset, annotation, method);
				}
				else if ("ConstructorArgs".equals(elementName))
				{
					return proposeConstructorArgs(project, mapperFqn, offset, annotation, method);
				}
				else if ("Options".equals(elementName) || "SelectKey".equals(elementName))
				{
					return proposeKeyProperty(project, mapperFqn, offset, annotation, method);
				}
			}
		}
		catch (JavaModelException e)
		{
			Activator.log(Status.ERROR, "Something went wrong.", e);
		}
	}
	return Collections.emptyList();
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
private boolean isInlineStatementAnnotation(IAnnotation annotation)
{
	String annotationName = annotation.getElementName();
	return inlineStatementAnnotations.contains(annotationName);
}
 

import org.eclipse.jdt.core.IAnnotation; //导入方法依赖的package包/类
private static void parseBinaryMapper(final IJavaProject project, final IType mapperType,
	final MapperInfo mapperInfo) throws JavaModelException
{
	for (IMethod method : mapperType.getMethods())
	{
		if (Flags.isDefaultMethod(method.getFlags()))
			continue;

		String statementAnno = null;
		for (IAnnotation annotation : method.getAnnotations())
		{
			String annoName = annotation.getElementName();
			if (MybatipseConstants.STATEMENT_ANNOTATIONS.contains(annoName))
			{
				statementAnno = annoName;
			}
			else if (MybatipseConstants.ANNOTATION_RESULTS.equals(annoName))
			{
				IMemberValuePair[] valuePairs = annotation.getMemberValuePairs();
				for (IMemberValuePair valuePair : valuePairs)
				{
					if ("id".equals(valuePair.getMemberName()))
					{
						String resultsId = (String)valuePair.getValue();
						if (resultsId != null)
							mapperInfo.addResultMap(resultsId, method);
					}
				}
			}
		}
		mapperInfo.addMethod(method, statementAnno);

		String[] superInterfaces = mapperType.getSuperInterfaceNames();
		for (String superInterface : superInterfaces)
		{
			if (!Object.class.getName().equals(superInterface))
			{
				IType superInterfaceType = project.findType(superInterface.replace('$', '.'));
				parseMapper(project, superInterfaceType, mapperInfo);
			}
		}
	}
}