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

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

import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.inject.Binder;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.PrivateBinder;
import com.google.inject.spi.Element;
import com.google.inject.spi.ElementVisitor;
import com.google.inject.spi.PrivateElements;

import java.util.List;
import java.util.Map;
import java.util.Set;

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

public final class PrivateElementsImpl implements PrivateElements {

  /*
   * This class acts as both a value object and as a builder. When getElements() is called, an
   * immutable collection of elements is constructed and the original mutable list is nulled out.
   * Similarly, the exposed keys are made immutable on access.
   */

    private final Object source;

    private List elementsMutable = Lists.newArrayList();
    private List> exposureBuilders = Lists.newArrayList();

    /**
     * lazily instantiated
     */
    private ImmutableList elements;

    /**
     * lazily instantiated
     */
    private ImmutableMap, Object> exposedKeysToSources;
    private Injector injector;

    public PrivateElementsImpl(Object source) {
        this.source = checkNotNull(source, "source");
    }

    @Override
    public Object getSource() {
        return source;
    }

    @Override
    public List getElements() {
        if (elements == null) {
            elements = ImmutableList.copyOf(elementsMutable);
            elementsMutable = null;
        }

        return elements;
    }

    @Override
    public Injector getInjector() {
        return injector;
    }

    void initInjector(Injector injector) {
        checkState(this.injector == null, "injector already initialized");
        this.injector = checkNotNull(injector, "injector");
    }

    @Override
    public Set> getExposedKeys() {
        if (exposedKeysToSources == null) {
            Map, Object> exposedKeysToSourcesMutable = Maps.newLinkedHashMap();
            for (ExposureBuilder exposureBuilder : exposureBuilders) {
                exposedKeysToSourcesMutable.put(exposureBuilder.getKey(), exposureBuilder.getSource());
            }
            exposedKeysToSources = ImmutableMap.copyOf(exposedKeysToSourcesMutable);
            exposureBuilders = null;
        }

        return exposedKeysToSources.keySet();
    }

    @Override
    public  T acceptVisitor(ElementVisitor visitor) {
        return visitor.visit(this);
    }

    public List getElementsMutable() {
        return elementsMutable;
    }

    public void addExposureBuilder(ExposureBuilder exposureBuilder) {
        exposureBuilders.add(exposureBuilder);
    }

    @Override
    public void applyTo(Binder binder) {
        PrivateBinder privateBinder = binder.withSource(source).newPrivateBinder();

        for (Element element : getElements()) {
            element.applyTo(privateBinder);
        }

        getExposedKeys(); // ensure exposedKeysToSources is populated
        for (Map.Entry, Object> entry : exposedKeysToSources.entrySet()) {
            privateBinder.withSource(entry.getValue()).expose(entry.getKey());
        }
    }

    @Override
    public Object getExposedSource(Key key) {
        getExposedKeys(); // ensure exposedKeysToSources is populated
        Object source = exposedKeysToSources.get(key);
        checkArgument(source != null, "%s not exposed by %s.", key, this);
        return source;
    }

    @Override
    public String toString() {
        return MoreObjects.toStringHelper(PrivateElements.class)
                .add("exposedKeys", getExposedKeys())
                .add("source", getSource())
                .toString();
    }
}