Refine search
@Override public boolean apply(@Nullable Element input) { if (input == null || input.getKind() != ElementKind.METHOD || !input.getModifiers().contains(Modifier.PUBLIC)) { return false; } boolean isStatic = input.getModifiers().contains(Modifier.STATIC); if (methodType == MethodType.STATIC && !isStatic) { return false; } else if (methodType == MethodType.INSTANCE && isStatic) { return false; } ExecutableElement method = (ExecutableElement) input; return returnType == null || isReturnValueTypeMatching(method, returnType); } }
public boolean isAbstract(Element element) { return element.getModifiers().contains(Modifier.ABSTRACT); }
CachingElement(Element delegate) { this.delegate = delegate; this.kind = delegate.getKind(); this.simpleName = delegate.getSimpleName(); this.modifiers = delegate.getModifiers(); }
/** * Return true if the possibleBuilderMethod matches the * Style#attributeBuilder() and returns a class. * * TODO: may need to make this return true if the return type is an interface too... * * @param possibleBuilderMethod executableElement */ private static boolean isPossibleBuilderMethod(Element possibleBuilderMethod, boolean onValueType, ValueAttribute valueAttribute) { if (possibleBuilderMethod.getKind() == ElementKind.METHOD) { if (!valueAttribute.containingType.names().possibleAttributeBuilder(possibleBuilderMethod.getSimpleName())) { return false; } ExecutableElement candidateMethod = (ExecutableElement) possibleBuilderMethod; TypeKind kind = candidateMethod.getReturnType().getKind(); return possibleBuilderMethod.getModifiers().containsAll( Arrays.asList(Modifier.STATIC, Modifier.PUBLIC)) && candidateMethod.getParameters().isEmpty() && candidateMethod.getReturnType().getKind() == TypeKind.DECLARED && !kind.isPrimitive() && kind != TypeKind.ARRAY; } else if (!onValueType && possibleBuilderMethod.getKind() == ElementKind.CONSTRUCTOR) { if (!valueAttribute.containingType.names().newTokenInAttributeBuilder()) { return false; } ExecutableElement candidateConstructor = (ExecutableElement) possibleBuilderMethod; return candidateConstructor.getModifiers().contains(Modifier.PUBLIC) && candidateConstructor.getTypeParameters().isEmpty(); } return false; }
public VerifierVisitor(Verifier verifier, Element clzElement) { this.verifier = verifier; Collection<ExecutableElement> shared = new ArrayList<>(); for(Element e : clzElement.getEnclosedElements()) { if (e.getKind() == ElementKind.METHOD && e.getModifiers().containsAll(EnumSet.of(Modifier.STATIC, Modifier.PRIVATE))) { shared.add((ExecutableElement)e); } } btraceServiceTm = verifier.getElementUtils().getTypeElement("com.sun.btrace.services.spi.BTraceService").asType(); runtimeServiceTm = verifier.getElementUtils().getTypeElement("com.sun.btrace.services.spi.RuntimeService").asType(); simpleServiceTm = verifier.getElementUtils().getTypeElement("com.sun.btrace.services.spi.SimpleService").asType(); serviceInjectorTm = verifier.getElementUtils().getTypeElement("com.sun.btrace.services.api.Service").asType(); }
private static List<TypeElement> staticTypesIn(Iterable<? extends Element> elements) { List<TypeElement> list = new ArrayList<>(); for (Element element : elements) { if (TYPE_KINDS.contains(element.getKind()) && element.getModifiers().contains(Modifier.STATIC)) { list.add(TypeElement.class.cast(element)); } } return list; }
public boolean isPublic(Element element) { return element.getModifiers().contains(Modifier.PUBLIC); }
public static <T extends Element> ImmutableList<FieldModel> extractFields(T element) { final List<FieldModel> fields = new ArrayList<>(); for (Element enclosedElement : element.getEnclosedElements()) { if (ElementKind.FIELD.equals(enclosedElement.getKind())) { Set<Modifier> modifiers = enclosedElement.getModifiers(); fields.add( new FieldModel( FieldSpec.builder( TypeName.get(enclosedElement.asType()), enclosedElement.getSimpleName().toString(), modifiers.toArray(new Modifier[modifiers.size()])) .build(), enclosedElement)); } } return ImmutableList.copyOf(fields); } }
public boolean isInterfaceDefaultMethod() { return element.getEnclosingElement().getKind() == ElementKind.INTERFACE && !element.getModifiers().contains(Modifier.ABSTRACT); }
public boolean isStatic(Element element) { return element.getModifiers().contains(Modifier.STATIC); }
public static boolean isFinalField(Element element) { return element.getKind().equals(ElementKind.FIELD) && element.getModifiers().contains(Modifier.FINAL); }
public boolean isPrivate(Element element) { return element.getModifiers().contains(Modifier.PRIVATE); }
private void addAllNonPrivateFields(Element element, Elements elements, Types types, JsonObjectHolder objectHolder) { List<? extends Element> enclosedElements = element.getEnclosedElements(); for (Element enclosedElement : enclosedElements) { ElementKind enclosedElementKind = enclosedElement.getKind(); if (enclosedElementKind == ElementKind.FIELD) { Set<Modifier> modifiers = enclosedElement.getModifiers(); if (!modifiers.contains(Modifier.PRIVATE) && !modifiers.contains(Modifier.PROTECTED) && !modifiers.contains(Modifier.TRANSIENT) && !modifiers.contains(Modifier.STATIC)) { createOrUpdateFieldHolder(enclosedElement, elements, types, objectHolder); } } } }
public boolean isFinal(Element element) { return element.getModifiers().contains(Modifier.FINAL); }
/** * Get information about constructors of the original class so we can duplicate them in the * generated class and call through to super with the proper parameters */ protected static List<ConstructorInfo> getClassConstructors(TypeElement classElement) { List<ConstructorInfo> constructors = new ArrayList<>(2); for (Element subElement : classElement.getEnclosedElements()) { if (subElement.getKind() == ElementKind.CONSTRUCTOR && !subElement.getModifiers().contains(Modifier.PRIVATE)) { ExecutableElement constructor = ((ExecutableElement) subElement); List<? extends VariableElement> params = constructor.getParameters(); constructors.add(new ConstructorInfo(subElement.getModifiers(), buildParamSpecs(params), constructor.isVarArgs())); } } return constructors; }
public boolean isSynchronized(Element element) { return element.getModifiers().contains(Modifier.SYNCHRONIZED); }
static boolean checkAbstractValueType(Element element, Collection<String> violations) { boolean ofSupportedKind = false || element.getKind() == ElementKind.INTERFACE || element.getKind() == ElementKind.ANNOTATION_TYPE || element.getKind() == ElementKind.CLASS; || element.getEnclosingElement().getKind() == ElementKind.PACKAGE || element.getModifiers().contains(Modifier.STATIC); boolean nonFinal = !element.getModifiers().contains(Modifier.FINAL); !element.getModifiers().contains(Modifier.PRIVATE) && !element.getModifiers().contains(Modifier.PROTECTED);
public int elementVisibilityModifierToJMod(Element element) { Set<Modifier> modifiers = element.getModifiers(); if (modifiers.contains(Modifier.PUBLIC)) { return JMod.PUBLIC; } else if (modifiers.contains(Modifier.PROTECTED)) { return JMod.PROTECTED; } else if (modifiers.contains(Modifier.PRIVATE)) { return JMod.PRIVATE; } else { return JMod.NONE; } }
private boolean checkAnnotationValid(Element annotatedElement, Class clazz) { if (annotatedElement.getKind() != ElementKind.CLASS) { error(annotatedElement, "%s must be declared on class.", clazz.getSimpleName()); return false; } if (annotatedElement.getModifiers().contains(Modifier.PRIVATE)) { error(annotatedElement, "%s must can not be private.", ((TypeElement) annotatedElement).getQualifiedName()); return false; } return true; }
public static Visibility of(Element element) { if (element.getModifiers().contains(Modifier.PUBLIC)) { return PUBLIC; } if (element.getModifiers().contains(Modifier.PRIVATE)) { return PRIVATE; } return PACKAGE; }