com.google.inject.internal.BindingProcessor Maven / Gradle / Ivy
/*
* Copyright (C) 2008 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 com.google.inject.internal;
import com.google.inject.Binder;
import com.google.inject.Binding;
import com.google.inject.Key;
import com.google.inject.Provider;
import com.google.inject.spi.ConstructorBinding;
import com.google.inject.spi.ConvertedConstantBinding;
import com.google.inject.spi.ExposedBinding;
import com.google.inject.spi.InjectionPoint;
import com.google.inject.spi.InstanceBinding;
import com.google.inject.spi.LinkedKeyBinding;
import com.google.inject.spi.PrivateElements;
import com.google.inject.spi.ProviderBinding;
import com.google.inject.spi.ProviderInstanceBinding;
import com.google.inject.spi.ProviderKeyBinding;
import com.google.inject.spi.UntargettedBinding;
import java.util.Set;
/**
* Handles {@link Binder#bind} and {@link Binder#bindConstant} elements.
*
* @author [email protected] (Bob Lee)
* @author [email protected] (Jesse Wilson)
*/
final class BindingProcessor extends AbstractBindingProcessor {
private final Initializer initializer;
BindingProcessor(
Errors errors, Initializer initializer, ProcessedBindingData processedBindingData) {
super(errors, processedBindingData);
this.initializer = initializer;
}
@Override
public Boolean visit(Binding command) {
Class rawType = command.getKey().getTypeLiteral().getRawType();
if (Void.class.equals(rawType)) {
if (command instanceof ProviderInstanceBinding
&& ((ProviderInstanceBinding) command).getUserSuppliedProvider()
instanceof ProviderMethod) {
errors.voidProviderMethod();
} else {
errors.missingConstantValues();
}
return true;
}
if (rawType == Provider.class) {
errors.bindingToProvider();
return true;
}
return command.acceptTargetVisitor(
new Processor((BindingImpl) command) {
@Override
public Boolean visit(ConstructorBinding binding) {
prepareBinding();
try {
ConstructorBindingImpl onInjector =
ConstructorBindingImpl.create(
injector,
key,
binding.getConstructor(),
source,
scoping,
errors,
false,
false);
scheduleInitialization(onInjector);
putBinding(onInjector);
} catch (ErrorsException e) {
errors.merge(e.getErrors());
putBinding(invalidBinding(injector, key, source));
}
return true;
}
@Override
public Boolean visit(InstanceBinding binding) {
prepareBinding();
Set injectionPoints = binding.getInjectionPoints();
T instance = binding.getInstance();
// Note: We cannot use type=`binding.getKey().getTypeLiteral()`, even though it would
// be more accurate, because it's very likely that people do:
// bind(new TypeLiteral() {}).toInstance(someFooBarInstance);
// bind(new TypeLiteral() {}).toInstance(someFooBarInstance);
// ... and if we captured the exact type when passing to requestInjection, then we'd
// fail because the same instance requested injection from two different types.
@SuppressWarnings("unchecked") // safe because processor was constructed w/ it
Binding bindingT = (Binding) binding;
Initializable ref =
initializer.requestInjection(
injector,
/* type= */ null,
instance,
bindingT,
source,
injectionPoints,
errors);
ConstantFactory factory = new ConstantFactory<>(ref);
InternalFactory scopedFactory =
Scoping.scope(key, injector, factory, source, scoping);
putBinding(
new InstanceBindingImpl(
injector, key, source, scopedFactory, injectionPoints, instance));
return true;
}
@Override
public Boolean visit(ProviderInstanceBinding binding) {
prepareBinding();
javax.inject.Provider provider = binding.getUserSuppliedProvider();
if (provider instanceof InternalProviderInstanceBindingImpl.Factory) {
@SuppressWarnings("unchecked")
InternalProviderInstanceBindingImpl.Factory asProviderMethod =
(InternalProviderInstanceBindingImpl.Factory) provider;
return visitInternalProviderInstanceBindingFactory(asProviderMethod);
}
Set injectionPoints = binding.getInjectionPoints();
Initializable> initializable =
initializer.>requestInjection(
injector, /* type= */ null, provider, null, source, injectionPoints, errors);
// always visited with Binding
@SuppressWarnings("unchecked")
InternalFactory factory =
new InternalFactoryToInitializableAdapter(
initializable,
source,
injector.provisionListenerStore.get((ProviderInstanceBinding) binding));
InternalFactory scopedFactory =
Scoping.scope(key, injector, factory, source, scoping);
putBinding(
new ProviderInstanceBindingImpl(
injector, key, source, scopedFactory, scoping, provider, injectionPoints));
return true;
}
@Override
public Boolean visit(ProviderKeyBinding binding) {
prepareBinding();
Key> providerKey =
binding.getProviderKey();
// always visited with Binding
@SuppressWarnings("unchecked")
BoundProviderFactory boundProviderFactory =
new BoundProviderFactory(
injector,
providerKey,
source,
injector.provisionListenerStore.get((ProviderKeyBinding) binding));
processedBindingData.addCreationListener(boundProviderFactory);
InternalFactory scopedFactory =
Scoping.scope(
key,
injector,
(InternalFactory) boundProviderFactory,
source,
scoping);
putBinding(
new LinkedProviderBindingImpl(
injector, key, source, scopedFactory, scoping, providerKey));
return true;
}
@Override
public Boolean visit(LinkedKeyBinding binding) {
prepareBinding();
Key linkedKey = binding.getLinkedKey();
if (key.equals(linkedKey)) {
// TODO: b/168656899 check for transitive recursive binding
errors.recursiveBinding(key, linkedKey);
}
FactoryProxy factory = new FactoryProxy<>(injector, key, linkedKey, source);
processedBindingData.addCreationListener(factory);
InternalFactory scopedFactory =
Scoping.scope(key, injector, factory, source, scoping);
putBinding(
new LinkedBindingImpl(injector, key, source, scopedFactory, scoping, linkedKey));
return true;
}
/** Handle ProviderMethods specially. */
private Boolean visitInternalProviderInstanceBindingFactory(
InternalProviderInstanceBindingImpl.Factory provider) {
InternalProviderInstanceBindingImpl binding =
new InternalProviderInstanceBindingImpl(
injector,
key,
source,
provider,
Scoping.scope(key, injector, provider, source, scoping),
scoping);
switch (binding.getInitializationTiming()) {
case DELAYED:
scheduleDelayedInitialization(binding);
break;
case EAGER:
scheduleInitialization(binding);
break;
default:
throw new AssertionError();
}
putBinding(binding);
return true;
}
@Override
public Boolean visit(UntargettedBinding untargetted) {
return false;
}
@Override
public Boolean visit(ExposedBinding binding) {
throw new IllegalArgumentException("Cannot apply a non-module element");
}
@Override
public Boolean visit(ConvertedConstantBinding binding) {
throw new IllegalArgumentException("Cannot apply a non-module element");
}
@Override
public Boolean visit(ProviderBinding binding) {
throw new IllegalArgumentException("Cannot apply a non-module element");
}
@Override
protected Boolean visitOther(Binding binding) {
throw new IllegalStateException("BindingProcessor should override all visitations");
}
});
}
@Override
public Boolean visit(PrivateElements privateElements) {
for (Key key : privateElements.getExposedKeys()) {
bindExposed(privateElements, key);
}
return false; // leave the private elements for the PrivateElementsProcessor to handle
}
private void bindExposed(PrivateElements privateElements, Key key) {
ExposedKeyFactory exposedKeyFactory = new ExposedKeyFactory<>(key, privateElements);
processedBindingData.addCreationListener(exposedKeyFactory);
putBinding(
new ExposedBindingImpl(
injector,
privateElements.getExposedSource(key),
key,
exposedKeyFactory,
privateElements));
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy