org.elasticsearch.common.inject.InjectorImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of elasticsearch Show documentation
Show all versions of elasticsearch Show documentation
Elasticsearch subproject :server
/**
* Copyright (C) 2006 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.elasticsearch.common.inject;
import org.elasticsearch.common.collect.ImmutableList;
import org.elasticsearch.common.collect.ImmutableSet;
import org.elasticsearch.common.collect.Lists;
import org.elasticsearch.common.collect.Maps;
import org.elasticsearch.common.inject.internal.*;
import org.elasticsearch.common.inject.spi.BindingTargetVisitor;
import org.elasticsearch.common.inject.spi.ConvertedConstantBinding;
import org.elasticsearch.common.inject.spi.Dependency;
import org.elasticsearch.common.inject.spi.InjectionPoint;
import org.elasticsearch.common.inject.spi.ProviderBinding;
import org.elasticsearch.common.inject.spi.ProviderKeyBinding;
import org.elasticsearch.common.inject.util.Providers;
import java.lang.annotation.Annotation;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.elasticsearch.common.inject.internal.Annotations.*;
/**
* Default {@link Injector} implementation.
*
* @author [email protected] (Bob Lee)
* @see InjectorBuilder
*/
class InjectorImpl implements Injector, Lookups {
final State state;
final InjectorImpl parent;
final BindingsMultimap bindingsMultimap = new BindingsMultimap();
final Initializer initializer;
/**
* Just-in-time binding cache. Guarded by state.lock()
*/
Map, BindingImpl> jitBindings = Maps.newHashMap();
Lookups lookups = new DeferredLookups(this);
InjectorImpl(@Nullable InjectorImpl parent, State state, Initializer initializer) {
this.parent = parent;
this.state = state;
this.initializer = initializer;
if (parent != null) {
localContext = parent.localContext;
} else {
localContext = new ThreadLocal() {
protected Object[] initialValue() {
return new Object[1];
}
};
}
}
/**
* Indexes bindings by type.
*/
void index() {
for (Binding binding : state.getExplicitBindingsThisLevel().values()) {
index(binding);
}
}
void index(Binding binding) {
bindingsMultimap.put(binding.getKey().getTypeLiteral(), binding);
}
public List> findBindingsByType(TypeLiteral type) {
return bindingsMultimap.getAll(type);
}
/**
* Returns the binding for {@code key}
*/
public BindingImpl getBinding(Key key) {
Errors errors = new Errors(key);
try {
BindingImpl result = getBindingOrThrow(key, errors);
errors.throwConfigurationExceptionIfErrorsExist();
return result;
} catch (ErrorsException e) {
throw new ConfigurationException(errors.merge(e.getErrors()).getMessages());
}
}
/**
* Gets a binding implementation. First, it check to see if the parent has a binding. If the
* parent has a binding and the binding is scoped, it will use that binding. Otherwise, this
* checks for an explicit binding. If no explicit binding is found, it looks for a just-in-time
* binding.
*/
public BindingImpl getBindingOrThrow(Key key, Errors errors)
throws ErrorsException {
// Check explicit bindings, i.e. bindings created by modules.
BindingImpl binding = state.getExplicitBinding(key);
if (binding != null) {
return binding;
}
// Look for an on-demand binding.
return getJustInTimeBinding(key, errors);
}
public Binding getBinding(Class type) {
return getBinding(Key.get(type));
}
public Injector getParent() {
return parent;
}
public Injector createChildInjector(Iterable modules) {
return new InjectorBuilder()
.parentInjector(this)
.addModules(modules)
.build();
}
public Injector createChildInjector(Module... modules) {
return createChildInjector(ImmutableList.of(modules));
}
/**
* Returns a just-in-time binding for {@code key}, creating it if necessary.
*
* @throws ErrorsException if the binding could not be created.
*/
private BindingImpl getJustInTimeBinding(Key key, Errors errors)
throws ErrorsException {
synchronized (state.lock()) {
// first try to find a JIT binding that we've already created
for (InjectorImpl injector = this; injector != null; injector = injector.parent) {
@SuppressWarnings("unchecked") // we only store bindings that match their key
BindingImpl binding = (BindingImpl) injector.jitBindings.get(key);
if (binding != null) {
return binding;
}
}
return createJustInTimeBindingRecursive(key, errors);
}
}
/**
* Returns true if the key type is Provider (but not a subclass of Provider).
*/
static boolean isProvider(Key key) {
return key.getTypeLiteral().getRawType().equals(Provider.class);
}
/**
* Returns true if the key type is MembersInjector (but not a subclass of MembersInjector).
*/
static boolean isMembersInjector(Key key) {
return key.getTypeLiteral().getRawType().equals(MembersInjector.class)
&& !key.hasAnnotationType();
}
private BindingImpl> createMembersInjectorBinding(
Key> key, Errors errors) throws ErrorsException {
Type membersInjectorType = key.getTypeLiteral().getType();
if (!(membersInjectorType instanceof ParameterizedType)) {
throw errors.cannotInjectRawMembersInjector().toException();
}
@SuppressWarnings("unchecked") // safe because T came from Key>
TypeLiteral instanceType = (TypeLiteral) TypeLiteral.get(
((ParameterizedType) membersInjectorType).getActualTypeArguments()[0]);
MembersInjector membersInjector = membersInjectorStore.get(instanceType, errors);
InternalFactory> factory = new ConstantFactory>(
Initializables.of(membersInjector));
return new InstanceBindingImpl>(this, key, SourceProvider.UNKNOWN_SOURCE,
factory, ImmutableSet.of(), membersInjector);
}
/**
* Creates a synthetic binding to {@code Provider}, i.e. a binding to the provider from
* {@code Binding}.
*/
private BindingImpl> createProviderBinding(Key> key, Errors errors)
throws ErrorsException {
Type providerType = key.getTypeLiteral().getType();
// If the Provider has no type parameter (raw Provider)...
if (!(providerType instanceof ParameterizedType)) {
throw errors.cannotInjectRawProvider().toException();
}
Type entryType = ((ParameterizedType) providerType).getActualTypeArguments()[0];
@SuppressWarnings("unchecked") // safe because T came from Key>
Key providedKey = (Key) key.ofType(entryType);
BindingImpl delegate = getBindingOrThrow(providedKey, errors);
return new ProviderBindingImpl(this, key, delegate);
}
static class ProviderBindingImpl extends BindingImpl>
implements ProviderBinding> {
final BindingImpl providedBinding;
ProviderBindingImpl(InjectorImpl injector, Key> key, Binding providedBinding) {
super(injector, key, providedBinding.getSource(), createInternalFactory(providedBinding),
Scoping.UNSCOPED);
this.providedBinding = (BindingImpl) providedBinding;
}
static InternalFactory> createInternalFactory(Binding providedBinding) {
final Provider provider = providedBinding.getProvider();
return new InternalFactory>() {
public Provider get(Errors errors, InternalContext context, Dependency dependency) {
return provider;
}
};
}
public Key getProvidedKey() {
return providedBinding.getKey();
}
public V acceptTargetVisitor(BindingTargetVisitor, V> visitor) {
return visitor.visit(this);
}
public void applyTo(Binder binder) {
throw new UnsupportedOperationException("This element represents a synthetic binding.");
}
@Override public String toString() {
return new ToStringBuilder(ProviderKeyBinding.class)
.add("key", getKey())
.add("providedKey", getProvidedKey())
.toString();
}
}
/**
* Converts a constant string binding to the required type.
*
* @return the binding if it could be resolved, or null if the binding doesn't exist
* @throws org.elasticsearch.common.inject.internal.ErrorsException
* if there was an error resolving the binding
*/
private BindingImpl convertConstantStringBinding(Key key, Errors errors)
throws ErrorsException {
// Find a constant string binding.
Key stringKey = key.ofType(String.class);
BindingImpl stringBinding = state.getExplicitBinding(stringKey);
if (stringBinding == null || !stringBinding.isConstant()) {
return null;
}
String stringValue = stringBinding.getProvider().get();
Object source = stringBinding.getSource();
// Find a matching type converter.
TypeLiteral type = key.getTypeLiteral();
MatcherAndConverter matchingConverter = state.getConverter(stringValue, type, errors, source);
if (matchingConverter == null) {
// No converter can handle the given type.
return null;
}
// Try to convert the string. A failed conversion results in an error.
try {
@SuppressWarnings("unchecked") // This cast is safe because we double check below.
T converted = (T) matchingConverter.getTypeConverter().convert(stringValue, type);
if (converted == null) {
throw errors.converterReturnedNull(stringValue, source, type, matchingConverter)
.toException();
}
if (!type.getRawType().isInstance(converted)) {
throw errors.conversionTypeError(stringValue, source, type, matchingConverter, converted)
.toException();
}
return new ConvertedConstantBindingImpl(this, key, converted, stringBinding);
} catch (ErrorsException e) {
throw e;
} catch (RuntimeException e) {
throw errors.conversionError(stringValue, source, type, matchingConverter, e)
.toException();
}
}
private static class ConvertedConstantBindingImpl
extends BindingImpl implements ConvertedConstantBinding {
final T value;
final Provider provider;
final Binding originalBinding;
ConvertedConstantBindingImpl(
Injector injector, Key key, T value, Binding originalBinding) {
super(injector, key, originalBinding.getSource(),
new ConstantFactory(Initializables.of(value)), Scoping.UNSCOPED);
this.value = value;
provider = Providers.of(value);
this.originalBinding = originalBinding;
}
@Override public Provider getProvider() {
return provider;
}
public V acceptTargetVisitor(BindingTargetVisitor visitor) {
return visitor.visit(this);
}
public T getValue() {
return value;
}
public Key getSourceKey() {
return originalBinding.getKey();
}
public Set> getDependencies() {
return ImmutableSet.>of(Dependency.get(getSourceKey()));
}
public void applyTo(Binder binder) {
throw new UnsupportedOperationException("This element represents a synthetic binding.");
}
@Override public String toString() {
return new ToStringBuilder(ConvertedConstantBinding.class)
.add("key", getKey())
.add("sourceKey", getSourceKey())
.add("value", value)
.toString();
}
}
void initializeBinding(BindingImpl binding, Errors errors) throws ErrorsException {
// Put the partially constructed binding in the map a little early. This enables us to handle
// circular dependencies. Example: FooImpl -> BarImpl -> FooImpl.
// Note: We don't need to synchronize on state.lock() during injector creation.
// TODO: for the above example, remove the binding for BarImpl if the binding for FooImpl fails
if (binding instanceof ConstructorBindingImpl) {
Key key = binding.getKey();
jitBindings.put(key, binding);
boolean successful = false;
try {
((ConstructorBindingImpl) binding).initialize(this, errors);
successful = true;
} finally {
if (!successful) {
jitBindings.remove(key);
}
}
}
}
/**
* Creates a binding for an injectable type with the given scope. Looks for a scope on the type if
* none is specified.
*/
BindingImpl createUnitializedBinding(Key key, Scoping scoping, Object source,
Errors errors) throws ErrorsException {
Class rawType = key.getTypeLiteral().getRawType();
// Don't try to inject arrays, or enums.
if (rawType.isArray() || rawType.isEnum()) {
throw errors.missingImplementation(key).toException();
}
// Handle TypeLiteral by binding the inner type
if (rawType == TypeLiteral.class) {
@SuppressWarnings("unchecked") // we have to fudge the inner type as Object
BindingImpl binding = (BindingImpl) createTypeLiteralBinding(
(Key>) key, errors);
return binding;
}
// Handle @ImplementedBy
ImplementedBy implementedBy = rawType.getAnnotation(ImplementedBy.class);
if (implementedBy != null) {
Annotations.checkForMisplacedScopeAnnotations(rawType, source, errors);
return createImplementedByBinding(key, scoping, implementedBy, errors);
}
// Handle @ProvidedBy.
ProvidedBy providedBy = rawType.getAnnotation(ProvidedBy.class);
if (providedBy != null) {
Annotations.checkForMisplacedScopeAnnotations(rawType, source, errors);
return createProvidedByBinding(key, scoping, providedBy, errors);
}
// We can't inject abstract classes.
// TODO: Method interceptors could actually enable us to implement
// abstract types. Should we remove this restriction?
if (Modifier.isAbstract(rawType.getModifiers())) {
throw errors.missingImplementation(key).toException();
}
// Error: Inner class.
if (Classes.isInnerClass(rawType)) {
throw errors.cannotInjectInnerClass(rawType).toException();
}
if (!scoping.isExplicitlyScoped()) {
Class scopeAnnotation = findScopeAnnotation(errors, rawType);
if (scopeAnnotation != null) {
scoping = Scopes.makeInjectable(Scoping.forAnnotation(scopeAnnotation),
this, errors.withSource(rawType));
}
}
return ConstructorBindingImpl.create(this, key, source, scoping);
}
/**
* Converts a binding for a {@code Key>} to the value {@code TypeLiteral}. It's
* a bit awkward because we have to pull out the inner type in the type literal.
*/
private BindingImpl> createTypeLiteralBinding(
Key> key, Errors errors) throws ErrorsException {
Type typeLiteralType = key.getTypeLiteral().getType();
if (!(typeLiteralType instanceof ParameterizedType)) {
throw errors.cannotInjectRawTypeLiteral().toException();
}
ParameterizedType parameterizedType = (ParameterizedType) typeLiteralType;
Type innerType = parameterizedType.getActualTypeArguments()[0];
// this is unforunate. We don't support building TypeLiterals for type variable like 'T'. If
// this proves problematic, we can probably fix TypeLiteral to support type variables
if (!(innerType instanceof Class)
&& !(innerType instanceof GenericArrayType)
&& !(innerType instanceof ParameterizedType)) {
throw errors.cannotInjectTypeLiteralOf(innerType).toException();
}
@SuppressWarnings("unchecked") // by definition, innerType == T, so this is safe
TypeLiteral value = (TypeLiteral) TypeLiteral.get(innerType);
InternalFactory> factory = new ConstantFactory>(
Initializables.of(value));
return new InstanceBindingImpl>(this, key, SourceProvider.UNKNOWN_SOURCE,
factory, ImmutableSet.of(), value);
}
/**
* Creates a binding for a type annotated with @ProvidedBy.
*/
BindingImpl createProvidedByBinding(Key key, Scoping scoping,
ProvidedBy providedBy, Errors errors) throws ErrorsException {
final Class rawType = key.getTypeLiteral().getRawType();
final Class> providerType = providedBy.value();
// Make sure it's not the same type. TODO: Can we check for deeper loops?
if (providerType == rawType) {
throw errors.recursiveProviderType().toException();
}
// Assume the provider provides an appropriate type. We double check at runtime.
@SuppressWarnings("unchecked")
final Key> providerKey
= (Key>) Key.get(providerType);
final BindingImpl> providerBinding
= getBindingOrThrow(providerKey, errors);
InternalFactory internalFactory = new InternalFactory() {
public T get(Errors errors, InternalContext context, Dependency dependency)
throws ErrorsException {
errors = errors.withSource(providerKey);
Provider provider = providerBinding.getInternalFactory().get(
errors, context, dependency);
try {
Object o = provider.get();
if (o != null && !rawType.isInstance(o)) {
throw errors.subtypeNotProvided(providerType, rawType).toException();
}
@SuppressWarnings("unchecked") // protected by isInstance() check above
T t = (T) o;
return t;
} catch (RuntimeException e) {
throw errors.errorInProvider(e).toException();
}
}
};
return new LinkedProviderBindingImpl(
this,
key,
rawType /* source */,
Scopes.scope(key, this, internalFactory, scoping),
scoping,
providerKey);
}
/**
* Creates a binding for a type annotated with @ImplementedBy.
*/
BindingImpl createImplementedByBinding(Key key, Scoping scoping,
ImplementedBy implementedBy, Errors errors)
throws ErrorsException {
Class rawType = key.getTypeLiteral().getRawType();
Class implementationType = implementedBy.value();
// Make sure it's not the same type. TODO: Can we check for deeper cycles?
if (implementationType == rawType) {
throw errors.recursiveImplementationType().toException();
}
// Make sure implementationType extends type.
if (!rawType.isAssignableFrom(implementationType)) {
throw errors.notASubtype(implementationType, rawType).toException();
}
@SuppressWarnings("unchecked") // After the preceding check, this cast is safe.
Class subclass = (Class) implementationType;
// Look up the target binding.
final Key targetKey = Key.get(subclass);
final BindingImpl targetBinding = getBindingOrThrow(targetKey, errors);
InternalFactory internalFactory = new InternalFactory() {
public T get(Errors errors, InternalContext context, Dependency dependency)
throws ErrorsException {
return targetBinding.getInternalFactory().get(
errors.withSource(targetKey), context, dependency);
}
};
return new LinkedBindingImpl(
this,
key,
rawType /* source */,
Scopes.scope(key, this, internalFactory, scoping),
scoping,
targetKey);
}
/**
* Attempts to create a just-in-time binding for {@code key} in the root injector, falling back to
* other ancestor injectors until this injector is tried.
*/
private BindingImpl createJustInTimeBindingRecursive(Key key, Errors errors)
throws ErrorsException {
// ask the parent to create the JIT binding
if (parent != null) {
try {
return parent.createJustInTimeBindingRecursive(key, new Errors());
} catch (ErrorsException ignored) {
}
}
if (state.isBlacklisted(key)) {
throw errors.childBindingAlreadySet(key).toException();
}
BindingImpl binding = createJustInTimeBinding(key, errors);
state.parent().blacklist(key);
jitBindings.put(key, binding);
return binding;
}
/**
* Returns a new just-in-time binding created by resolving {@code key}. The strategies used to
* create just-in-time bindings are:
*
* - Internalizing Providers. If the requested binding is for {@code Provider
}, we delegate
* to the binding for {@code T}.
* - Converting constants.
*
- ImplementedBy and ProvidedBy annotations. Only for unannotated keys.
*
- The constructor of the raw type. Only for unannotated keys.
*
*
* @throws org.elasticsearch.common.inject.internal.ErrorsException
* if the binding cannot be created.
*/
BindingImpl createJustInTimeBinding(Key key, Errors errors) throws ErrorsException {
if (state.isBlacklisted(key)) {
throw errors.childBindingAlreadySet(key).toException();
}
// Handle cases where T is a Provider.
if (isProvider(key)) {
// These casts are safe. We know T extends Provider and that given Key>,
// createProviderBinding() will return BindingImpl>.
@SuppressWarnings("unchecked")
BindingImpl binding = createProviderBinding((Key) key, errors);
return binding;
}
// Handle cases where T is a MembersInjector
if (isMembersInjector(key)) {
// These casts are safe. T extends MembersInjector and that given Key>,
// createMembersInjectorBinding() will return BindingImpl>.
@SuppressWarnings("unchecked")
BindingImpl binding = createMembersInjectorBinding((Key) key, errors);
return binding;
}
// Try to convert a constant string binding to the requested type.
BindingImpl convertedBinding = convertConstantStringBinding(key, errors);
if (convertedBinding != null) {
return convertedBinding;
}
// If the key has an annotation...
if (key.hasAnnotationType()) {
// Look for a binding without annotation attributes or return null.
if (key.hasAttributes()) {
try {
Errors ignored = new Errors();
return getBindingOrThrow(key.withoutAttributes(), ignored);
} catch (ErrorsException ignored) {
// throw with a more appropriate message below
}
}
throw errors.missingImplementation(key).toException();
}
Object source = key.getTypeLiteral().getRawType();
BindingImpl binding = createUnitializedBinding(key, Scoping.UNSCOPED, source, errors);
initializeBinding(binding, errors);
return binding;
}
InternalFactory getInternalFactory(Key key, Errors errors)
throws ErrorsException {
return getBindingOrThrow(key, errors).getInternalFactory();
}
// not test-covered
public Map, Binding> getBindings() {
return state.getExplicitBindingsThisLevel();
}
private static class BindingsMultimap {
final Map, List>> multimap = Maps.newHashMap();
void put(TypeLiteral type, Binding binding) {
List> bindingsForType = multimap.get(type);
if (bindingsForType == null) {
bindingsForType = Lists.newArrayList();
multimap.put(type, bindingsForType);
}
bindingsForType.add(binding);
}
@SuppressWarnings("unchecked") // safe because we only put matching entries into the map
List> getAll(TypeLiteral type) {
List> bindings = multimap.get(type);
return bindings != null
? Collections.>unmodifiableList((List) multimap.get(type))
: ImmutableList.>of();
}
}
/**
* Returns parameter injectors, or {@code null} if there are no parameters.
*/
SingleParameterInjector[] getParametersInjectors(
List> parameters, Errors errors) throws ErrorsException {
if (parameters.isEmpty()) {
return null;
}
int numErrorsBefore = errors.size();
SingleParameterInjector[] result = new SingleParameterInjector[parameters.size()];
int i = 0;
for (Dependency parameter : parameters) {
try {
result[i++] = createParameterInjector(parameter, errors.withSource(parameter));
} catch (ErrorsException rethrownBelow) {
// rethrown below
}
}
errors.throwIfNewErrors(numErrorsBefore);
return result;
}
SingleParameterInjector createParameterInjector(final Dependency dependency,
final Errors errors) throws ErrorsException {
InternalFactory factory = getInternalFactory(dependency.getKey(), errors);
return new SingleParameterInjector(dependency, factory);
}
/**
* Invokes a method.
*/
interface MethodInvoker {
Object invoke(Object target, Object... parameters)
throws IllegalAccessException, InvocationTargetException;
}
/**
* Cached constructor injectors for each type
*/
ConstructorInjectorStore constructors = new ConstructorInjectorStore(this);
/**
* Cached field and method injectors for each type.
*/
MembersInjectorStore membersInjectorStore;
@SuppressWarnings("unchecked") // the members injector type is consistent with instance's type
public void injectMembers(Object instance) {
MembersInjector membersInjector = getMembersInjector(instance.getClass());
membersInjector.injectMembers(instance);
}
public MembersInjector getMembersInjector(TypeLiteral typeLiteral) {
Errors errors = new Errors(typeLiteral);
try {
return membersInjectorStore.get(typeLiteral, errors);
} catch (ErrorsException e) {
throw new ConfigurationException(errors.merge(e.getErrors()).getMessages());
}
}
public MembersInjector getMembersInjector(Class type) {
return getMembersInjector(TypeLiteral.get(type));
}
public Provider getProvider(Class type) {
return getProvider(Key.get(type));
}
Provider getProviderOrThrow(final Key key, Errors errors) throws ErrorsException {
final InternalFactory factory = getInternalFactory(key, errors);
final Dependency dependency = Dependency.get(key);
return new Provider() {
public T get() {
final Errors errors = new Errors(dependency);
try {
T t = callInContext(new ContextualCallable() {
public T call(InternalContext context) throws ErrorsException {
context.setDependency(dependency);
try {
return factory.get(errors, context, dependency);
} finally {
context.setDependency(null);
}
}
});
errors.throwIfNewErrors(0);
return t;
} catch (ErrorsException e) {
throw new ProvisionException(errors.merge(e.getErrors()).getMessages());
}
}
@Override public String toString() {
return factory.toString();
}
};
}
public Provider getProvider(final Key key) {
Errors errors = new Errors(key);
try {
Provider result = getProviderOrThrow(key, errors);
errors.throwIfNewErrors(0);
return result;
} catch (ErrorsException e) {
throw new ConfigurationException(errors.merge(e.getErrors()).getMessages());
}
}
public T getInstance(Key key) {
return getProvider(key).get();
}
public T getInstance(Class type) {
return getProvider(type).get();
}
final ThreadLocal localContext;
/**
* Looks up thread local context. Creates (and removes) a new context if necessary.
*/
T callInContext(ContextualCallable callable) throws ErrorsException {
Object[] reference = localContext.get();
if (reference[0] == null) {
reference[0] = new InternalContext();
try {
return callable.call((InternalContext) reference[0]);
} finally {
// Only clear the context if this call created it.
reference[0] = null;
}
} else {
// Someone else will clean up this context.
return callable.call((InternalContext) reference[0]);
}
}
public String toString() {
return new ToStringBuilder(Injector.class)
.add("bindings", state.getExplicitBindingsThisLevel().values())
.toString();
}
// ES_GUICE: clear caches
public void clearCache() {
state.clearBlacklisted();
constructors = new ConstructorInjectorStore(this);
membersInjectorStore = new MembersInjectorStore(this, state.getTypeListenerBindings());
jitBindings = Maps.newHashMap();
}
}