@Override public <R, P> R accept(ElementVisitor<R, P> v, P p) { return delegate.accept(v, p); }
@Override default <R, P> R accept(final ElementVisitor<R, P> v, final P p) { return getDelegate().accept(v, p); }
/** Returns the class name for {@code element}. */ public static ClassName get(TypeElement element) { checkNotNull(element, "element == null"); String simpleName = element.getSimpleName().toString(); return element.getEnclosingElement().accept(new SimpleElementVisitor8<ClassName, Void>() { @Override public ClassName visitPackage(PackageElement packageElement, Void p) { return new ClassName(packageElement.getQualifiedName().toString(), null, simpleName); } @Override public ClassName visitType(TypeElement enclosingClass, Void p) { return ClassName.get(enclosingClass).nestedClass(simpleName); } @Override public ClassName visitUnknown(Element unknown, Void p) { return get("", simpleName); } @Override public ClassName defaultAction(Element enclosingElement, Void p) { throw new IllegalArgumentException("Unexpected type nesting: " + element); } }, null); }
@Override public Boolean visitTypeAsClass(TypeElement typeElement, Void aVoid) { List<? extends Element> enclosedElements = typeElement.getEnclosedElements(); for ( Element enclosedElement : enclosedElements ) { if ( enclosedElement.accept( this, aVoid ) ) { return Boolean.TRUE; } } return Boolean.FALSE; }
private ExecutableElement getValidationAppliesToMethod(Element annotation) { for ( Element e : annotation.getEnclosedElements() ) { ExecutableElement method = e.accept( new ElementKindVisitor8<ExecutableElement, Void>() { @Override public ExecutableElement visitExecutableAsMethod(ExecutableElement e, Void p) { if ( e.getSimpleName().contentEquals( "validationAppliesTo" ) ) { return e; } return null; } }, null ); if ( method != null ) { return method; } } return null; }
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { cm = new JCodeModel(); for (TypeElement annotation : annotations) { for(javax.lang.model.element.Element d : roundEnv.getElementsAnnotatedWith(annotation)) { d.accept(visitor, null); } try { cm.build(new FilerCodeWriter(processingEnv.getFiler())); } catch (IOException e) { throw new Error(e); } } return true; }
d.accept(new SimpleElementVisitor6<Void, Void>() { @Override public Void visitVariable(VariableElement e, Void p) {
Boolean isValidationAppliesToMethod = e.accept( new ElementKindVisitor8<Boolean, Void>() { @Override public Boolean visitExecutableAsMethod(ExecutableElement e, Void p) {
/** * Processes an element by calling {@code e.accept(this, p)}; * this method may be overridden by subclasses. * * @param e the element to scan * @param p a scanner-specified parameter * @return the result of visiting {@code e}. */ public R scan(Element e, P p) { return e.accept(this, p); }
/** * Processes an element by calling {@code e.accept(this, p)}; * this method may be overridden by subclasses. * @return the result of visiting {@code e}. */ public R scan(Element e, P p) { return e.accept(this, p); }
@Override protected PackageElement defaultAction( final Element e, final Void p) { return e .getEnclosingElement() .accept(getPackage, null); }
@Override public Boolean visitDeclared(DeclaredType t, Void aVoid) { return t.asElement().accept(IS_THROWABLE_ELEMENT, null); } };
@Override public StringBuilder visitExecutable(ExecutableElement e, Boolean p) { if (p != Boolean.TRUE || e.getEnclosingElement() == null) { return DEFAULT_VALUE.append(e.getSimpleName()); } else { return e.getEnclosingElement().accept(this, p). append("."). append(e.getSimpleName()); } }
private StringBuilder enclosingTypeAndMemberName(Element element) { StringBuilder name = new StringBuilder(element.getEnclosingElement().accept(this, null)); if (!element.getSimpleName().contentEquals("<init>")) { name.append('.').append(element.getSimpleName()); } return name; } };
@Override public T apply( Element element) { //visit the given element to determine its type, feed it into the appropriate //ASTElementFactory method and return the result return element.accept(elementConverterFactory.buildTypeConverter(astTypeClass), null); } }
@Override public String format(DependencyRequest request) { return request .requestElement() .map(element -> element.accept(formatVisitor, request)) .orElse(""); }
@Override public Set<Element> scan(Element e, DeclaredType p) { java.util.List<? extends AnnotationMirror> annotationMirrors = processingEnv.getElementUtils().getAllAnnotationMirrors(e); for (AnnotationMirror annotationMirror : annotationMirrors) { if (annotationMirror.getAnnotationType().equals(p)) annotatedElements.add(e); } e.accept(this, p); return annotatedElements; }
@Override public StringBuilder visitVariable(VariableElement e, Boolean p) { if (p != Boolean.TRUE || e.getEnclosingElement() == null) { return DEFAULT_VALUE.append(e.getSimpleName()); } else { return e.getEnclosingElement().accept(this, p). append("."). append(e.getSimpleName()); } }
@Override public <R, P> R accept(ElementVisitor<R, P> v, P p) { for (Element type : getEnclosedElements()) { if (type.getKind().isClass()) { type.accept(v, p); } else { throw new ClassCastException(type.getClass().getName()); } } return null; }