com.google.inject.internal.ProvidedByInternalFactory Maven / Gradle / Ivy

Go to download
package com.google.inject.internal;

import com.google.inject.Key;
import com.google.inject.ProvidedBy;
import com.google.inject.internal.InjectorImpl.JitLimitation;
import com.google.inject.spi.Dependency;
import javax.inject.Provider;

/**
 * An {@link InternalFactory} for {@literal @}{@link ProvidedBy} bindings.
 */
class ProvidedByInternalFactory extends ProviderInternalFactory
        implements DelayedInitialize {

    private final Class rawType;
    private final Class> providerType;
    private final Key> providerKey;
    private BindingImpl> providerBinding;
    private ProvisionListenerStackCallback provisionCallback;

    ProvidedByInternalFactory(
            Class rawType,
            Class> providerType,
            Key> providerKey) {
        super(providerKey);
        this.rawType = rawType;
        this.providerType = providerType;
        this.providerKey = providerKey;
    }

    void setProvisionListenerCallback(ProvisionListenerStackCallback listener) {
        provisionCallback = listener;
    }

    @Override
    public void initialize(InjectorImpl injector, Errors errors) throws ErrorsException {
        providerBinding =
                injector.getBindingOrThrow(providerKey, errors, JitLimitation.NEW_OR_EXISTING_JIT);
    }

    @Override
    public T get(InternalContext context, Dependency dependency, boolean linked)
            throws InternalProvisionException {
        BindingImpl> localProviderBinding = providerBinding;
        if (localProviderBinding == null) {
            throw new IllegalStateException("not initialized");
        }
        Key> localProviderKey = providerKey;
        context.pushState(localProviderKey, localProviderBinding.getSource());

        try {
            Provider provider =
                    localProviderBinding.getInternalFactory().get(context, dependency, true);
            return circularGet(provider, context, dependency, provisionCallback);
        } catch (InternalProvisionException ipe) {
            throw ipe.addSource(localProviderKey);
        } finally {
            context.popState();
        }
    }

    @Override
    protected T provision(javax.inject.Provider provider,
                          Dependency dependency,
                          ConstructionContext constructionContext)
            throws InternalProvisionException {
        try {
            Object o = super.provision(provider, dependency, constructionContext);
            if (o != null && !rawType.isInstance(o)) {
                throw InternalProvisionException.subtypeNotProvided(providerType, rawType);
            }
            @SuppressWarnings("unchecked") // protected by isInstance() check above
            T t = (T) o;
            return t;
        } catch (RuntimeException e) {
            throw InternalProvisionException.errorInProvider(e).addSource(source);
        }
    }
}