Java IExtendedModifier.isAnnotation方法代码示例

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
/**
 * Return an Annotation instance used on this body declaration
 */
public static Annotation getAnnotation(String annotationName,
		BodyDeclaration bodyDeclaration) {
	List<?> modifiers = bodyDeclaration.modifiers();

	// Test if this MethodDeclaration contains modifiers
	if (modifiers != null) {
		Iterator<?> modifiersIterator = modifiers.iterator();

		while (modifiersIterator.hasNext()) {
			IExtendedModifier modifier = (IExtendedModifier) modifiersIterator
					.next();

			if (modifier.isAnnotation()) {
				Annotation a = (Annotation) modifier;
				String annotationType = a.getTypeName().toString();

				if (annotationType.endsWith(annotationName)) {
					return a;
				}
			}
		}
	}

	return null;
}
 

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
private static Annotation findAnnotation(final List<IExtendedModifier> modifiers, final String className) {
	for (final IExtendedModifier modifier : modifiers) {
		if (modifier.isAnnotation()) {
			final Annotation anno = (Annotation) modifier;
			final String fqn = anno.resolveTypeBinding().getQualifiedName();
			if (className.equals(fqn)) {
				return anno;
			}
		}
	}
	return null;
}
 

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
public void copyAllAnnotations(ASTNode otherDecl, TextEditGroup editGroup) {
  ListRewrite modifierList = evaluateListRewrite(fModifierRewrite.getASTRewrite(), otherDecl);
  List<IExtendedModifier> originalList = modifierList.getOriginalList();

  for (Iterator<IExtendedModifier> iterator = originalList.iterator(); iterator.hasNext(); ) {
    IExtendedModifier modifier = iterator.next();
    if (modifier.isAnnotation()) {
      fModifierRewrite.insertLast(
          fModifierRewrite.getASTRewrite().createCopyTarget((Annotation) modifier), editGroup);
    }
  }
}
 

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
/**
 * @return the annotation node if it is present on the declaration or null
 */
public static Annotation obtainAnnotation(BodyDeclaration declaration, Class<?> annotationClass) {
	for (Object mod : declaration.modifiers()) {
		IExtendedModifier modifier = (IExtendedModifier) mod;
		if (modifier.isAnnotation()) {
			Annotation annotation = (Annotation) modifier;
			if (identicalAnnotations(annotation, annotationClass)) {
				return annotation;
			}
		}
	}
	return null;
}
 

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
public static boolean hasOverrideAnnotation(final MethodDeclaration node) {
	final List modifiers = node.modifiers();
	for (final Object mod : modifiers) {
		final IExtendedModifier modifier = (IExtendedModifier) mod;
		if (modifier.isAnnotation()) {
			final Annotation annotation = (Annotation) modifier;
			if (annotation.getTypeName().toString().equals("Override")) {
				return true;
			}
		}
	}
	return false;
}
 

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
@Override
		public void fieldCreated(CompilationUnitRewrite cuRewrite, FieldDeclaration field, ParameterInfo pi) {
			FieldInfo fieldInfo= getFieldInfo(pi.getOldName());
			FieldDeclaration parent= (FieldDeclaration) fieldInfo.declaration.getParent();
			List<IExtendedModifier> modifiers= parent.modifiers();
			ListRewrite listRewrite= cuRewrite.getASTRewrite().getListRewrite(field, FieldDeclaration.MODIFIERS2_PROPERTY);
			for (Iterator<IExtendedModifier> iterator= modifiers.iterator(); iterator.hasNext();) {
				IExtendedModifier mod= iterator.next();
				//Temporarily disabled until initialization of final fields is handled correctly
//				if (mod.isModifier()) {
//					Modifier modifier= (Modifier) mod;
//					if (modifier.isFinal())
//						listRewrite.insertLast(moveNode(cuRewrite, modifier), null);
//				}
				if (mod.isAnnotation()) {
					listRewrite.insertFirst(moveNode(cuRewrite, (ASTNode) mod), null);
				}
			}
			if (fieldInfo.initializer != null && fieldInfo.hasFieldReference()) {
				List<VariableDeclarationFragment> fragments= field.fragments();
				for (Iterator<VariableDeclarationFragment> iterator= fragments.iterator(); iterator.hasNext();) {
					VariableDeclarationFragment vdf= iterator.next();
					vdf.setInitializer((Expression) moveNode(cuRewrite, fieldInfo.initializer));
				}
			}
			if (parent.getJavadoc() != null) {
				field.setJavadoc((Javadoc) moveNode(cuRewrite, parent.getJavadoc()));
			}
		}
 

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
public void copyAllAnnotations(ASTNode otherDecl, TextEditGroup editGroup) {
	ListRewrite modifierList= evaluateListRewrite(fModifierRewrite.getASTRewrite(), otherDecl);
	List<IExtendedModifier> originalList= modifierList.getOriginalList();

	for (Iterator<IExtendedModifier> iterator= originalList.iterator(); iterator.hasNext();) {
		IExtendedModifier modifier= iterator.next();
		if (modifier.isAnnotation()) {
			fModifierRewrite.insertLast(fModifierRewrite.getASTRewrite().createCopyTarget((Annotation) modifier), editGroup);
		}
	}
}
 

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
private boolean hasParamAnnotation(List<IExtendedModifier> modifiers)
{
	for (IExtendedModifier modifier : modifiers)
	{
		if (modifier.isAnnotation()
			&& "Param".equals(((Annotation)modifier).getTypeName().getFullyQualifiedName()))
		{
			return true;
		}
	}
	return false;
}
 

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
/**
 * Fill informations in the MoDisco {@code BodyDeclaration} node from the
 * JDT {@code BodyDeclaration} node.
 * 
 * @param node
 *            the JDT {@code BodyDeclaration} node
 * @param element
 *            the MoDisco {@code BodyDeclaration} node
 */
private void endVisitBD(final org.eclipse.jdt.core.dom.BodyDeclaration node,
		final BodyDeclaration element) {

	// visibility modifiers
	Modifier modiscoModifier = this.factory.createModifier();
	element.setModifier(modiscoModifier);
	modiscoModifier.setBodyDeclaration(element);

	for (Object modifierNode : node.modifiers()) {
		if (((IExtendedModifier) modifierNode).isModifier()) {
			manageModifier((org.eclipse.jdt.core.dom.Modifier) modifierNode, modiscoModifier);
		}
	}

	// annotation modifiers
	for (Iterator<?> anIt = node.modifiers().iterator(); anIt.hasNext();) {
		IExtendedModifier aModifier = (IExtendedModifier) anIt.next();
		if (aModifier.isAnnotation()) {
			Annotation annotation = (Annotation) this.binding.get(aModifier);
			if (annotation != null) {
				element.getAnnotations().add(annotation);
			}
		}
	}
	// Start position adjustment : for jdt visitor
	// a body starts at its javadoc, it is not consistent with others prefix
	// comments
	if (node.getJavadoc() != null) {
		Javadoc javadoc = (Javadoc) this.binding.get(node.getJavadoc());
		element.getComments().add(javadoc);
	}
}
 

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
/**
 * Return an Annotation object of a BodyDeclaration object
 */
public static Annotation getAnnotation(BodyDeclaration bd, String annotationFullyQualifiedName) {
	List<?> modifiers = bd.modifiers();
	Annotation result = null;

	// Test if this BodyDeclaration contains modifiers
	if (modifiers != null) {
		Iterator<?> modifiersIterator = bd.modifiers().iterator();

		// For each modifier, search for @annotationType marker
		// annotation
		while ((result == null) && modifiersIterator.hasNext()) {
			IExtendedModifier modifier = (IExtendedModifier) modifiersIterator.next();

			if (modifier.isAnnotation()) {
				Annotation a = (Annotation) modifier;

				// Test if the name of the annotation is a simple name or a
				// fully qualified name
				String annotationName = (a.getTypeName().isSimpleName()) ? annotationFullyQualifiedName
						.substring(annotationFullyQualifiedName.lastIndexOf('.') + 1)
						: annotationFullyQualifiedName;

				if (a.getTypeName().getFullyQualifiedName().equals(annotationName)) {
					result = a;
				}
			}
		}
	}

	return result;
}
 

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
/**
 * Creates the necessary changes to create the delegate method with the
 * original method body.
 *
 * @param document
 *            the buffer containing the source of the source compilation
 *            unit
 * @param declaration
 *            the method declaration to use as source
 * @param rewrite
 *            the ast rewrite to use for the copy of the method body
 * @param rewrites
 *            the compilation unit rewrites
 * @param adjustments
 *            the map of elements to visibility adjustments
 * @param status
 *            the refactoring status
 * @param monitor
 *            the progress monitor to display progress
 * @throws CoreException
 *             if an error occurs
 */
protected void createMethodCopy(IDocument document, MethodDeclaration declaration, ASTRewrite rewrite, Map<ICompilationUnit, CompilationUnitRewrite> rewrites, Map<IMember, IncomingMemberVisibilityAdjustment> adjustments, RefactoringStatus status, IProgressMonitor monitor) throws CoreException {
	Assert.isNotNull(document);
	Assert.isNotNull(declaration);
	Assert.isNotNull(rewrite);
	Assert.isNotNull(rewrites);
	Assert.isNotNull(adjustments);
	Assert.isNotNull(status);
	Assert.isNotNull(monitor);
	final CompilationUnitRewrite rewriter= getCompilationUnitRewrite(rewrites, getTargetType().getCompilationUnit());
	try {
		rewrite.set(declaration, MethodDeclaration.NAME_PROPERTY, rewrite.getAST().newSimpleName(fMethodName), null);
		boolean same= false;
		final IMethodBinding binding= declaration.resolveBinding();
		if (binding != null) {
			final ITypeBinding declaring= binding.getDeclaringClass();
			if (declaring != null && Bindings.equals(declaring.getPackage(), fTarget.getType().getPackage()))
				same= true;
			final Modifier.ModifierKeyword keyword= same ? null : Modifier.ModifierKeyword.PUBLIC_KEYWORD;
			ModifierRewrite modifierRewrite= ModifierRewrite.create(rewrite, declaration);
			if (JdtFlags.isDefaultMethod(binding) && getTargetType().isClass()) {
				// Remove 'default' modifier and add 'public' visibility
				modifierRewrite.setVisibility(Modifier.PUBLIC, null);
				modifierRewrite.setModifiers(Modifier.NONE, Modifier.DEFAULT, null);
			} else if (!JdtFlags.isDefaultMethod(binding) && getTargetType().isInterface()) {
				// Remove visibility modifiers and add 'default'
				modifierRewrite.setModifiers(Modifier.DEFAULT, Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE, null);
			} else if (MemberVisibilityAdjustor.hasLowerVisibility(binding.getModifiers(), same ? Modifier.NONE : keyword == null ? Modifier.NONE : keyword.toFlagValue())
					&& MemberVisibilityAdjustor.needsVisibilityAdjustments(fMethod, keyword, adjustments)) {
				final MemberVisibilityAdjustor.IncomingMemberVisibilityAdjustment adjustment= new MemberVisibilityAdjustor.IncomingMemberVisibilityAdjustment(fMethod, keyword, RefactoringStatus.createStatus(RefactoringStatus.WARNING, Messages.format(RefactoringCoreMessages.MemberVisibilityAdjustor_change_visibility_method_warning, new String[] { MemberVisibilityAdjustor.getLabel(fMethod), MemberVisibilityAdjustor.getLabel(keyword) }), JavaStatusContext.create(fMethod), null, RefactoringStatusEntry.NO_CODE, null));
				modifierRewrite.setVisibility(keyword == null ? Modifier.NONE : keyword.toFlagValue(), null);
				adjustment.setNeedsRewriting(false);
				adjustments.put(fMethod, adjustment);
			}
		}
		for (IExtendedModifier modifier : (List<IExtendedModifier>) declaration.modifiers()) {
			if (modifier.isAnnotation()) {
				Annotation annotation= (Annotation) modifier;
				ITypeBinding typeBinding= annotation.resolveTypeBinding();
				if (typeBinding != null && typeBinding.getQualifiedName().equals("java.lang.Override")) { //$NON-NLS-1$
					rewrite.remove(annotation, null);
				}
			}
		}
		createMethodArguments(rewrites, rewrite, declaration, adjustments, status);
		createMethodTypeParameters(rewrite, declaration, status);
		createMethodComment(rewrite, declaration);
		createMethodBody(rewriter, rewrite, declaration);
	} finally {
		if (fMethod.getCompilationUnit().equals(getTargetType().getCompilationUnit()))
			rewriter.clearImportRewrites();
	}
}
 

import org.eclipse.jdt.core.dom.IExtendedModifier; //导入方法依赖的package包/类
/**
 * Return true if {@code modifier} is a modelizable modifier. A modelizable
 * modifier is one of abstract, static, private, protected, public, final or
 * transient. Other modifiers are not modelizable (it's technical modifiers
 * like synchronized,...).
 * 
 * @param modifier
 *            The modifier to test
 * @return true if {@code modifier} is a modelizable modifier, false
 *         otherwise.
 */
protected boolean isAModelizableModifier(BodyDeclaration existingFragment, IExtendedModifier modifier) {
	/* An annotation modifier is not processed by this method. */
	if (modifier.isAnnotation()) {
		return false;
	}

	Modifier m = (Modifier) modifier;
	return (m.isStatic() || m.isAbstract() || m.isPrivate() || m.isProtected() || m.isPublic() || m.isTransient() || m
			.isFinal());
}