void writeAll(Iterable<? extends Element> elements) { for (Element element : elements) { element.acceptVisitor(this); } } }
private static Module extractScanners(Iterable<Element> elements) { final List<ModuleAnnotatedMethodScannerBinding> scanners = Lists.newArrayList(); ElementVisitor<Void> visitor = new DefaultElementVisitor<Void>() { @Override public Void visit(ModuleAnnotatedMethodScannerBinding binding) { scanners.add(binding); return null; } }; for (Element element : elements) { element.acceptVisitor(visitor); } return new AbstractModule() { @Override protected void configure() { for (ModuleAnnotatedMethodScannerBinding scanner : scanners) { scanner.applyTo(binder()); } } }; } }
public void process(InjectorImpl injector, List<Element> elements) { Errors errorsAnyElement = this.errors; this.injector = injector; try { for (Iterator<Element> i = elements.iterator(); i.hasNext(); ) { Element element = i.next(); this.errors = errorsAnyElement.withSource(element.getSource()); Boolean allDone = element.acceptVisitor(this); if (allDone) { i.remove(); } } } finally { this.errors = errorsAnyElement; this.injector = null; } }
void writeAll(Iterable<? extends Element> elements) { for (Element element : elements) { element.acceptVisitor(this); } } }
private void visitElements(List<Element> elements) { for (Element element : elements) { element.acceptVisitor(this); } }
private void visitElements(List<Element> elements) { for (Element element : elements) { element.acceptVisitor(this); } }
void writeAll(Iterable<? extends Element> elements) { for (Element element : elements) { element.acceptVisitor(this); } } }
void writeAll(Iterable<? extends Element> elements) { for (Element element : elements) { element.acceptVisitor(this); } } }
void writeAll(Iterable<? extends Element> elements) { for (Element element : elements) { element.acceptVisitor(this); } } }
void writeAll(Iterable<? extends Element> elements) { for (Element element : elements) { element.acceptVisitor(this); } } }
void writeAll(Iterable<? extends Element> elements) { for (Element element : elements) { element.acceptVisitor(this); } } }
private Set<Key<?>> collectBindedClasses(List<Element> elements) { final Set<Key<?>> bindedClasses = new HashSet<>(); for (Element e : elements) { e.acceptVisitor(new DefaultElementVisitor<Void>() { @Override public <T> Void visit(Binding<T> binding) { bindedClasses.add(binding.getKey()); return null; } }); } return bindedClasses; }
private Set<Key<?>> collectBindedClasses(List<Element> elements) { final Set<Key<?>> bindedClasses = new HashSet<>(); for (Element e : elements) { e.acceptVisitor(new DefaultElementVisitor<Void>() { @Override public <T> Void visit(Binding<T> binding) { bindedClasses.add(binding.getKey()); return null; } }); } return bindedClasses; }
@Override public Void visit(PrivateElements privateElements) { for (Element element : privateElements.getElements()) { element.acceptVisitor(this); } return null; } });
/** * Call the provided visitor for all elements of the current module. * * This call will not modify any bindings * @param visitor */ public <T> InjectorBuilder forEachElement(ElementVisitor<T> visitor) { Elements .getElements(module) .forEach(element -> element.acceptVisitor(visitor)); return this; }
private void visitElements(List<Element> elements) { // We take advantage of the fact that iterating over the PrivateElements should // happen in the same order that the modules were installed. We match each PrivateElements // up with the {@link GinjectorBindings} that were created in the adapter. children = bindings.getChildren().iterator(); for (Element element : elements) { element.acceptVisitor(this); } }
@Override public Collection<Module> call(Collection<Module> modules) { for(Element element : Elements.getElements(Stage.TOOL, modules)) { element.acceptVisitor(new DefaultElementVisitor<Void>() { @Override public Void visit(StaticInjectionRequest request) { LOG.warn("You shouldn't be using static injection at: " + request.getSource()); return null; } }); } return modules; }
/** * Iterate through all elements of the current module and pass the output of the * ElementVisitor to the provided consumer. 'null' responses from the visitor are ignored. * * This call will not modify any bindings * @param visitor */ public <T> InjectorBuilder forEachElement(ElementVisitor<T> visitor, Consumer<T> consumer) { Elements .getElements(module) .forEach(element -> Optional.ofNullable(element.acceptVisitor(visitor)).ifPresent(consumer)); return this; }
private Module createModule() { List<Element> allElements = new LinkedList<>(); for (List<Element> moduleElements : modules.values()) { allElements.addAll(moduleElements); } ElementCollector collector = new ElementCollector(); for (ListIterator<Element> it = allElements.listIterator(allElements.size()); it.hasPrevious(); ) { it.previous().acceptVisitor(collector); } return Elements.getModule(collector.elements); }
public void configure( final Binder binder ) { final ElementMerger merger = new ElementMerger( binder ); for ( final Module m : modules ) { for ( final Element e : Elements.getElements( m ) ) { e.acceptVisitor( merger ); } } } }