/** @see Binder#bind(Key) */ protected <T> LinkedBindingBuilder<T> bind(Key<T> key) { return binder().bind(key); }
/** @see Binder#bind(TypeLiteral) */ protected <T> AnnotatedBindingBuilder<T> bind(TypeLiteral<T> typeLiteral) { return binder().bind(typeLiteral); }
/** * @see Binder#requestInjection(Object) * @since 2.0 */ protected void requestInjection(Object instance) { binder().requestInjection(instance); }
/** * @see Binder#convertToTypes * @since 2.0 */ protected void convertToTypes( Matcher<? super TypeLiteral<?>> typeMatcher, TypeConverter converter) { binder().convertToTypes(typeMatcher, converter); }
/** * @see Binder#bindListener(Matcher, ProvisionListener...) * @since 4.0 */ protected void bindListener( Matcher<? super Binding<?>> bindingMatcher, ProvisionListener... listener) { binder().bindListener(bindingMatcher, listener); } }
/** * Adds a dependency from this module to {@code key}. When the injector is created, Guice will * report an error if {@code key} cannot be injected. Note that this requirement may be satisfied * by implicit binding, such as a public no-arguments constructor. * * @since 2.0 */ protected void requireBinding(Key<?> key) { binder().getProvider(key); }
/** * Adds a dependency from this module to {@code type}. When the injector is created, Guice will * report an error if {@code type} cannot be injected. Note that this requirement may be satisfied * by implicit binding, such as a public no-arguments constructor. * * @since 2.0 */ protected void requireBinding(Class<?> type) { binder().getProvider(type); }
/** * @see Binder#getMembersInjector(Class) * @since 2.0 */ protected <T> MembersInjector<T> getMembersInjector(Class<T> type) { return binder().getMembersInjector(type); }
/** * @see Binder#addError(Message) * @since 2.0 */ protected void addError(Message message) { binder().addError(message); }
/** * @see Binder#bindInterceptor(com.google.inject.matcher.Matcher, * com.google.inject.matcher.Matcher, org.aopalliance.intercept.MethodInterceptor[]) */ protected void bindInterceptor( Matcher<? super Class<?>> classMatcher, Matcher<? super Method> methodMatcher, org.aopalliance.intercept.MethodInterceptor... interceptors) { binder().bindInterceptor(classMatcher, methodMatcher, interceptors); } /*end[AOP]*/
/** * @see Binder#getMembersInjector(TypeLiteral) * @since 2.0 */ protected <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> type) { return binder().getMembersInjector(type); }
/** * @see Binder#getProvider(Key) * @since 2.0 */ protected <T> Provider<T> getProvider(Key<T> key) { return binder().getProvider(key); }
/** * @see Binder#getProvider(Class) * @since 2.0 */ protected <T> Provider<T> getProvider(Class<T> type) { return binder().getProvider(type); }
/** * @see Binder#currentStage() * @since 2.0 */ protected Stage currentStage() { return binder().currentStage(); }
/** * @see Binder#bindListener(com.google.inject.matcher.Matcher, com.google.inject.spi.TypeListener) * @since 2.0 */ protected void bindListener(Matcher<? super TypeLiteral<?>> typeMatcher, TypeListener listener) { binder().bindListener(typeMatcher, listener); }
/** @see Binder#install(Module) */ protected void install(Module module) { binder().install(module); }
/** @see Binder#bindScope(Class, Scope) */ protected void bindScope(Class<? extends Annotation> scopeAnnotation, Scope scope) { binder().bindScope(scopeAnnotation, scope); }
/** @see Binder#requestStaticInjection(Class[]) */ protected void requestStaticInjection(Class<?>... types) { binder().requestStaticInjection(types); }
/** @see Binder#bindConstant() */ protected AnnotatedConstantBindingBuilder bindConstant() { return binder().bindConstant(); }
/** @see Binder#addError(Throwable) */ protected void addError(Throwable t) { binder().addError(t); }