Instantiators.java

/*
 * Grapht, an open source dependency injector.
 * Copyright 2014-2015 various contributors (see CONTRIBUTORS.txt)
 * Copyright 2010-2014 Regents of the University of Minnesota
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
package org.grouplens.grapht;

import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import org.grouplens.grapht.util.LogContext;
import org.grouplens.grapht.util.TypedProvider;
import org.grouplens.grapht.util.Types;
import javax.inject.Provider;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;
import org.grouplens.grapht.util.LogContext;

/**
 * Utilities and methods for building and working with {@link org.grouplens.grapht.Instantiator}s.
 *
 * @author <a href="http://www.grouplens.org">GroupLens Research</a>
 * @since 0.9
 */
public final class Instantiators {
    private static final Logger logger = LoggerFactory.getLogger(Instantiators.class);

    private Instantiators() {}

    /**
     * Create an instantiator that returns an instance.
     * @param inst The instance to return (must be non-null).
     * @return An instantiator that returns {@code inst}.
     */
    public static Instantiator ofInstance(Object inst) {
        Preconditions.checkNotNull(inst, "instance");
        return new InstanceInstantiator(inst);
    }

    /**
     * Create an instantiator that returns a null value.
     * @param type The type of null value to return.
     * @return An instantiator that returns {@code null}.
     */
    public static Instantiator ofNull(Class<?> type) {
        Preconditions.checkNotNull(type, "instance");
        return new InstanceInstantiator(null, type);
    }

    /**
     * Convert a providerInstantiator to an instantiator.  Any exception thrown by the provider - including a
     * runtime exception - is wrapped in an {@link ConstructionException}.
     * @param provider The providerInstantiator to wrap.
     * @return An instantiator wrapping {@code providerInstantiator}.
     */
    public static Instantiator ofProvider(Provider<?> provider) {
        Preconditions.checkNotNull(provider, "provider");
        return new ProviderInstantiator(ofInstance(provider));
    }

    /**
     * Flatten an instnatiator of providers into an instantiator of the provided type.  Any
     * exception thrown by the provider - including a runtime exception - is wrapped in an
     * {@link ConstructionException}.
     * @param pinst The providerInstantiator instantiator to wrap.
     * @return An instantiator wrapping {@code providerInstantiator}.
     */
    public static Instantiator ofProviderInstantiator(Instantiator pinst) {
        Preconditions.checkNotNull(pinst, "provider instantiator");
        Preconditions.checkArgument(Provider.class.isAssignableFrom(pinst.getType()),
                                    "instantiator is not of type Provider");

        return new ProviderInstantiator(pinst);
    }

    /**
     * Convert an instantiator to a provider.
     * @param instantiator The instantiator to convert.
     * @return A provider whose {@link javax.inject.Provider#get()} method invokes the instantiator.
     */
    public static Provider<?> toProvider(Instantiator instantiator) {
        // First try to unpack the instantiator
        if (instantiator instanceof ProviderInstantiator) {
            Instantiator itor = ((ProviderInstantiator) instantiator).providerInstantiator;
            if (itor instanceof InstanceInstantiator) {
                return (Provider) ((InstanceInstantiator) itor).instance;
            }
        }
        // Otherwise, wrap it.

        return new InstantiatorProvider(instantiator);
    }

    /**
     * Memoize an instantiator.
     * @param instantiator The instantiator to memoize.
     * @return An instantiator that memoizes {@code instantiator}.
     */
    public static Instantiator memoize(Instantiator instantiator) {
        Preconditions.checkNotNull(instantiator, "instantiator");
        return new MemoizingInstantiator(instantiator);
    }
    private static final class InstanceInstantiator implements Instantiator {
        private final Object instance;
        private final Class<?> type;

        public InstanceInstantiator(Object inst) {
            this(inst, (Class) inst.getClass());
        }

        public InstanceInstantiator(Object inst, Class<?> typ) {
            instance = inst;
            type = typ;
        }

        @Override
        public Object instantiate() throws ConstructionException {
            return instance;
        }

        @Override
        public Class getType() {
            return type;
        }
    }

    private static class ProviderInstantiator implements Instantiator {
        private final Instantiator providerInstantiator;
        public ProviderInstantiator(Instantiator prov) {
            providerInstantiator = prov;
        }

        @Override
        public Object instantiate() throws ConstructionException {
            Provider<?> provider = (Provider) providerInstantiator.instantiate();
            LogContext mdcContextProvider = LogContext.create();
            logger.trace("invoking provider {}",provider);
            try {
                mdcContextProvider.put("org.grouplens.grapht.currentProvider", provider.toString());
                return provider.get();
            } catch (Throwable th) {
                throw new ConstructionException(getType(), "Error invoking provider " + providerInstantiator, th);
            } finally {
                mdcContextProvider.finish();
            }
        }
        @SuppressWarnings("unchecked")
        @Override
        public Class<?> getType() {
            return Types.getProvidedType(providerInstantiator.getType());
        }
    }


    private static class MemoizingInstantiator implements Instantiator {
        private final Instantiator delegate;
        private volatile boolean instantiated = false;
        private Object instance = null;
        private Throwable error = null;

        public MemoizingInstantiator(Instantiator inst) {
            delegate = inst;
        }

        @Override
        public Object instantiate() throws ConstructionException {
            if (!instantiated) {
                synchronized (this) {
                    if (!instantiated) {
                        try {
                            instance = delegate.instantiate();
                        } catch (Throwable th) {
                            error = th;
                        }
                        instantiated = true;
                    }
                }
            }

            if (error != null) {
                Throwables.propagateIfPossible(error, ConstructionException.class);
                // shouldn't happen, but hey.
                throw Throwables.propagate(error);
            } else {
                return instance;
            }
        }

        @Override
        public Class getType() {
            return delegate.getType();
        }
    }

    private static class InstantiatorProvider implements TypedProvider {
        private final Instantiator instantiator;

        public InstantiatorProvider(Instantiator itor) {
            instantiator = itor;
        }

        @Override
        public Class<?> getProvidedType() {
            return instantiator.getType();
        }

        @Override
        public Object get() {
            try {
                logger.trace("invoking instantiator {}", instantiator);
                return getProvidedType().cast(instantiator.instantiate());
            } catch (ConstructionException ex) {
                throw new RuntimeException(ex);
            }
        }
    }

}