private ImageDescriptor decorate(ImageDescriptor descriptor, int modifiers, boolean isField) { int flags= 0; if (Flags.isDeprecated(modifiers)) flags |= JavaElementImageDescriptor.DEPRECATED; if (Flags.isStatic(modifiers)) flags |= JavaElementImageDescriptor.STATIC; if (Flags.isFinal(modifiers)) flags |= JavaElementImageDescriptor.FINAL; if (Flags.isSynchronized(modifiers)) flags |= JavaElementImageDescriptor.SYNCHRONIZED; if (Flags.isAbstract(modifiers)) flags |= JavaElementImageDescriptor.ABSTRACT; if (isField) { if (Flags.isVolatile(modifiers)) flags |= JavaElementImageDescriptor.VOLATILE; if (Flags.isTransient(modifiers)) flags |= JavaElementImageDescriptor.TRANSIENT; } return new JavaElementImageDescriptor(descriptor, flags, JavaElementImageProvider.SMALL_SIZE); }
private static ImageDescriptor getClassImageDescriptor(int flags) { if (Flags.isPublic(flags) || Flags.isProtected(flags) || Flags.isPrivate(flags)) return JavaPluginImages.DESC_OBJS_CLASS; else return JavaPluginImages.DESC_OBJS_CLASS_DEFAULT; }
int kind= proposal.getKind(); if (Flags.isDeprecated(flags)) adornments |= JavaElementImageDescriptor.DEPRECATED; if (Flags.isStatic(flags)) adornments |= JavaElementImageDescriptor.STATIC; if (Flags.isSynchronized(flags)) adornments |= JavaElementImageDescriptor.SYNCHRONIZED; if (kind == CompletionProposal.TYPE_REF && Flags.isAbstract(flags) && !Flags.isInterface(flags)) adornments |= JavaElementImageDescriptor.ABSTRACT; if (Flags.isTransient(flags)) adornments |= JavaElementImageDescriptor.TRANSIENT; if (Flags.isVolatile(flags)) adornments |= JavaElementImageDescriptor.VOLATILE;
private ImageDescriptor getOverlayFromFlags(int flags) { if (Flags.isAnnotation(flags)) { return JavaPluginImages.DESC_OVR_ANNOTATION; } else if (Flags.isEnum(flags)) { return JavaPluginImages.DESC_OVR_ENUM; } else if (Flags.isInterface(flags)) { return JavaPluginImages.DESC_OVR_INTERFACE; } else if (/* is class */ Flags.isAbstract(flags)) { return JavaPluginImages.DESC_OVR_ABSTRACT_CLASS; } return null; }
public static boolean isAbstract(IMember member) throws JavaModelException{ int flags= member.getFlags(); if (!member.isBinary() && isInterfaceOrAnnotationMethod(member)) { return !Flags.isPrivate(flags) && !Flags.isStatic(flags) && !Flags.isDefaultMethod(flags); } return Flags.isAbstract(flags); }
if (Flags.isAbstract(modifiers) && confirmAbstract(member)) flags |= JavaElementImageDescriptor.ABSTRACT; if (Flags.isFinal(modifiers) || isInterfaceField(member)) flags |= JavaElementImageDescriptor.FINAL; if (Flags.isSynchronized(modifiers) && confirmSynchronized(member)) flags |= JavaElementImageDescriptor.SYNCHRONIZED; if (Flags.isStatic(modifiers) || isInterfaceField(member)) flags |= JavaElementImageDescriptor.STATIC; if (Flags.isDeprecated(modifiers)) flags |= JavaElementImageDescriptor.DEPRECATED;
/** * Note: This method is for internal use only. Clients should not call this method. * @param element The element to decorate * @return Resulting decorations (combination of JavaElementImageDescriptor.IMPLEMENTS * and JavaElementImageDescriptor.OVERRIDES) */ public int computeAdornmentFlags(Object element) { if (element instanceof IMethod) { try { IMethod method= (IMethod) element; if (!method.getJavaProject().isOnClasspath(method)) { return 0; } int flags= method.getFlags(); if (!method.isConstructor() && !Flags.isPrivate(flags) && !Flags.isStatic(flags)) { int res= getOverrideIndicators(method); if (res != 0 && Flags.isSynchronized(flags)) { return res | JavaElementImageDescriptor.SYNCHRONIZED; } return res; } } catch (JavaModelException e) { if (!e.isDoesNotExist()) { JavaPlugin.log(e); } } } return 0; }
public static boolean isMethod(IMethod method, boolean onlyPublicMethod) { try { int flags = method.getFlags(); if (onlyPublicMethod && !Flags.isPublic(flags)) { return false; } // 'V' is void signature return !(method.isConstructor() || Flags.isAbstract(flags) || Flags.isStatic(flags) || !"V".equals(method.getReturnType())); } catch (JavaModelException e) { // ignore return false; } }
private boolean isOfKind(TypeNameMatch curr, int typeKinds, boolean is50OrHigher) { int flags= curr.getModifiers(); if (Flags.isAnnotation(flags)) { return is50OrHigher && (typeKinds & TypeKinds.ANNOTATIONS) != 0; } if (Flags.isEnum(flags)) { return is50OrHigher && (typeKinds & TypeKinds.ENUMS) != 0; } if (Flags.isInterface(flags)) { return (typeKinds & TypeKinds.INTERFACES) != 0; } return (typeKinds & TypeKinds.CLASSES) != 0; }
public static boolean isAbstract(IMember member) throws JavaModelException{ int flags= member.getFlags(); if (!member.isBinary() && isInterfaceOrAnnotationMethod(member)) { return !Flags.isStatic(flags) && !Flags.isDefaultMethod(flags); } return Flags.isAbstract(flags); }
public boolean isAbstract() { try { return Flags.isAbstract(this.getJdtMember().getFlags()); } catch (JavaModelException ex) { throw new RuntimeException(ex); } }
public static void findTestImplementorClasses(ITypeHierarchy typeHierarchy, IType testInterface, IRegion region, Set result) throws JavaModelException { IType[] subtypes= typeHierarchy.getAllSubtypes(testInterface); for (int i= 0; i < subtypes.length; i++) { IType type= subtypes[i]; int cachedFlags= typeHierarchy.getCachedFlags(type); if (!Flags.isInterface(cachedFlags) && !Flags.isAbstract(cachedFlags) // do the cheaper tests first && region.contains(type) && CoreTestSearchEngine.isAccessibleClass(type)) { result.add(type); } } }
/** * Hook method that gets called when the modifiers have changed. The method validates * the modifiers and returns the status of the validation. * <p> * Subclasses may extend this method to perform their own validation. * </p> * * @return the status of the validation */ protected IStatus modifiersChanged() { StatusInfo status= new StatusInfo(); int modifiers= getModifiers(); if (Flags.isFinal(modifiers) && Flags.isAbstract(modifiers)) { status.setError(NewWizardMessages.NewTypeWizardPage_error_ModifiersFinalAndAbstract); } return status; }
public static boolean isVarargs(IMethod method) throws JavaModelException{ return Flags.isVarargs(method.getFlags()); }
public static boolean hasSuiteMethod(IType type) throws JavaModelException { IMethod method= type.getMethod("suite", new String[0]); //$NON-NLS-1$ if (!method.exists()) return false; if (!Flags.isStatic(method.getFlags()) || !Flags.isPublic(method.getFlags())) { return false; } if (!Signature.getSimpleName(Signature.toString(method.getReturnType())).equals(JUnitCorePlugin.SIMPLE_TEST_INTERFACE_NAME)) { return false; } return true; }
@Override public boolean visit(EnumDeclaration node) { int flags = node.getModifiers(); if (node.isMemberTypeDeclaration()) { isvisible &= Flags.isPublic(flags); } else { isvisible &= !Flags.isPrivate(flags) && !Flags.isPackageDefault(flags); } fStack.push(new Item(getTypeName(node), node.getModifiers(), isvisible)); return true; }
public static boolean isStatic(IMember member) throws JavaModelException{ if (isNestedInterfaceOrAnnotation(member)) return true; if (member.getElementType() != IJavaElement.METHOD && isInterfaceOrAnnotationMember(member)) return true; if (isEnumConstant(member)) return true; return Flags.isStatic(member.getFlags()); }
/** * According to the spec, "All non-transient instance variables that are not * annotated with the Transient annotation are persistent." */ private static boolean fieldIsPersistable_(IField field) throws JavaModelException { int flags = field.getFlags(); if (Flags.isStatic(flags)) { return false; } if (Flags.isTransient(flags)) { return false; } return true; }
ImageDescriptor createTypeImageDescriptor(CompletionProposal proposal) { final int flags= proposal.getFlags(); boolean isInterfaceOrAnnotation= Flags.isInterface(flags) || Flags.isAnnotation(flags); return decorateImageDescriptor(JavaElementImageProvider.getTypeImageDescriptor(true /* in order to get all visibility decorations */, isInterfaceOrAnnotation, flags, false), proposal); }