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

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

import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import com.google.inject.Key;
import com.google.inject.MembersInjector;
import com.google.inject.Provider;
import com.google.inject.TypeLiteral;
import com.google.inject.spi.InjectionListener;
import com.google.inject.spi.Message;
import com.google.inject.spi.TypeEncounter;

import java.util.List;

import static com.google.common.base.Preconditions.checkState;

final class EncounterImpl implements TypeEncounter {

    private final Errors errors;
    private final Lookups lookups;
    private List> membersInjectors; // lazy
    private List> injectionListeners; // lazy
    private boolean valid = true;

    EncounterImpl(Errors errors, Lookups lookups) {
        this.errors = errors;
        this.lookups = lookups;
    }

    void invalidate() {
        valid = false;
    }

    ImmutableSet> getMembersInjectors() {
        return membersInjectors == null
                ? ImmutableSet.>of()
                : ImmutableSet.copyOf(membersInjectors);
    }

    ImmutableSet> getInjectionListeners() {
        return injectionListeners == null
                ? ImmutableSet.>of()
                : ImmutableSet.copyOf(injectionListeners);
    }

    @Override
    public void register(MembersInjector membersInjector) {
        checkState(valid, "Encounters may not be used after hear() returns.");

        if (membersInjectors == null) {
            membersInjectors = Lists.newArrayList();
        }

        membersInjectors.add(membersInjector);
    }

    @Override
    public void register(InjectionListener injectionListener) {
        checkState(valid, "Encounters may not be used after hear() returns.");

        if (injectionListeners == null) {
            injectionListeners = Lists.newArrayList();
        }

        injectionListeners.add(injectionListener);
    }

    @Override
    public void addError(String message, Object... arguments) {
        checkState(valid, "Encounters may not be used after hear() returns.");
        errors.addMessage(message, arguments);
    }

    @Override
    public void addError(Throwable t) {
        checkState(valid, "Encounters may not be used after hear() returns.");
        errors.errorInUserCode(t, "An exception was caught and reported. Message: %s", t.getMessage());
    }

    @Override
    public void addError(Message message) {
        checkState(valid, "Encounters may not be used after hear() returns.");
        errors.addMessage(message);
    }

    @Override
    public  Provider getProvider(Key key) {
        checkState(valid, "Encounters may not be used after hear() returns.");
        return lookups.getProvider(key);
    }

    @Override
    public  Provider getProvider(Class type) {
        return getProvider(Key.get(type));
    }

    @Override
    public  MembersInjector getMembersInjector(TypeLiteral typeLiteral) {
        checkState(valid, "Encounters may not be used after hear() returns.");
        return lookups.getMembersInjector(typeLiteral);
    }

    @Override
    public  MembersInjector getMembersInjector(Class type) {
        return getMembersInjector(TypeLiteral.get(type));
    }
}