@Override public void addError(Throwable t) { String message = "An exception was caught and reported. Message: " + t.getMessage(); elements.add(new Message(ImmutableList.of((Object) getElementSource()), message, t)); }
@Override public void scanModulesForAnnotatedMethods(ModuleAnnotatedMethodScanner scanner) { scanners.add(scanner); elements.add(new ModuleAnnotatedMethodScannerBinding(getElementSource(), scanner)); }
@Override public PrivateBinder newPrivateBinder() { PrivateElementsImpl privateElements = new PrivateElementsImpl(getElementSource()); RecordingBinder binder = new RecordingBinder(this, privateElements); privateBinders.add(binder); elements.add(privateElements); return binder; }
private <T> AnnotatedElementBuilder exposeInternal(Key<T> key) { if (privateElements == null) { addError( "Cannot expose %s on a standard binder. " + "Exposed bindings are only applicable to private binders.", key); return new AnnotatedElementBuilder() { @Override public void annotatedWith(Class<? extends Annotation> annotationType) {} @Override public void annotatedWith(Annotation annotation) {} }; } ExposureBuilder<T> builder = new ExposureBuilder<T>(this, getElementSource(), MoreTypes.canonicalizeKey(key)); privateElements.addExposureBuilder(builder); return builder; }
@Override public void requireAtInjectOnConstructors() { elements.add(new RequireAtInjectOnConstructorsOption(getElementSource())); }
@Override public void disableCircularProxies() { elements.add(new DisableCircularProxiesOption(getElementSource())); }
@Override public void addError(String message, Object... arguments) { elements.add(new Message(getElementSource(), Errors.format(message, arguments))); }
@Override public void bindScope(Class<? extends Annotation> annotationType, Scope scope) { elements.add(new ScopeBinding(getElementSource(), annotationType, scope)); }
@Override public void bindListener( Matcher<? super Binding<?>> bindingMatcher, ProvisionListener... listeners) { elements.add(new ProvisionListenerBinding(getElementSource(), bindingMatcher, listeners)); }
@Override public <T> MembersInjector<T> getMembersInjector(final TypeLiteral<T> typeLiteral) { final MembersInjectorLookup<T> element = new MembersInjectorLookup<T>( getElementSource(), MoreTypes.canonicalizeForKey(typeLiteral)); elements.add(element); return element.getMembersInjector(); }
@Override public <T> void requestInjection(TypeLiteral<T> type, T instance) { elements.add( new InjectionRequest<T>( getElementSource(), MoreTypes.canonicalizeForKey(type), instance)); }
@Override public void requireExactBindingAnnotations() { elements.add(new RequireExactBindingAnnotationsOption(getElementSource())); }
@Override public <T> Provider<T> getProvider(final Dependency<T> dependency) { final ProviderLookup<T> element = new ProviderLookup<>(getElementSource(), dependency); elements.add(element); return element.getProvider(); }
@Override public void requestStaticInjection(Class<?>... types) { for (Class<?> type : types) { elements.add(new StaticInjectionRequest(getElementSource(), type)); } }
@Override public <T> AnnotatedBindingBuilder<T> bind(Key<T> key) { BindingBuilder<T> builder = new BindingBuilder<T>(this, elements, getElementSource(), MoreTypes.canonicalizeKey(key)); return builder; }
@Override public void requireExplicitBindings() { elements.add(new RequireExplicitBindingsOption(getElementSource())); }
@Override public AnnotatedConstantBindingBuilder bindConstant() { return new ConstantBindingBuilderImpl<Void>(this, elements, getElementSource()); }
@Override public void bindListener(Matcher<? super TypeLiteral<?>> typeMatcher, TypeListener listener) { elements.add(new TypeListenerBinding(getElementSource(), listener, typeMatcher)); }
@Override public void bindInterceptor( Matcher<? super Class<?>> classMatcher, Matcher<? super Method> methodMatcher, org.aopalliance.intercept.MethodInterceptor... interceptors) { elements.add( new InterceptorBinding(getElementSource(), classMatcher, methodMatcher, interceptors)); } /*end[AOP]*/
@Override public void convertToTypes( Matcher<? super TypeLiteral<?>> typeMatcher, TypeConverter converter) { elements.add(new TypeConverterBinding(getElementSource(), typeMatcher, converter)); }