| /* |
| * Copyright (C) 2007 The Guava Authors |
| * |
| * 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.common.base; |
| |
| import com.google.common.annotations.Beta; |
| import com.google.common.annotations.GwtCompatible; |
| import com.google.common.annotations.VisibleForTesting; |
| |
| import java.io.Serializable; |
| import java.util.concurrent.TimeUnit; |
| |
| import javax.annotation.Nullable; |
| |
| /** |
| * Useful suppliers. |
| * |
| * <p>All methods return serializable suppliers as long as they're given |
| * serializable parameters. |
| * |
| * @author Laurence Gonsalves |
| * @author Harry Heymann |
| * @since 2.0 (imported from Google Collections Library) |
| */ |
| @GwtCompatible |
| public final class Suppliers { |
| private Suppliers() {} |
| |
| /** |
| * Returns a new supplier which is the composition of the provided function |
| * and supplier. In other words, the new supplier's value will be computed by |
| * retrieving the value from {@code supplier}, and then applying |
| * {@code function} to that value. Note that the resulting supplier will not |
| * call {@code supplier} or invoke {@code function} until it is called. |
| */ |
| public static <F, T> Supplier<T> compose( |
| Function<? super F, T> function, Supplier<F> supplier) { |
| Preconditions.checkNotNull(function); |
| Preconditions.checkNotNull(supplier); |
| return new SupplierComposition<F, T>(function, supplier); |
| } |
| |
| private static class SupplierComposition<F, T> |
| implements Supplier<T>, Serializable { |
| final Function<? super F, T> function; |
| final Supplier<F> supplier; |
| |
| SupplierComposition(Function<? super F, T> function, Supplier<F> supplier) { |
| this.function = function; |
| this.supplier = supplier; |
| } |
| |
| @Override public T get() { |
| return function.apply(supplier.get()); |
| } |
| |
| @Override public boolean equals(@Nullable Object obj) { |
| if (obj instanceof SupplierComposition) { |
| SupplierComposition<?, ?> that = (SupplierComposition<?, ?>) obj; |
| return function.equals(that.function) && supplier.equals(that.supplier); |
| } |
| return false; |
| } |
| |
| @Override public int hashCode() { |
| return Objects.hashCode(function, supplier); |
| } |
| |
| @Override public String toString() { |
| return "Suppliers.compose(" + function + ", " + supplier + ")"; |
| } |
| |
| private static final long serialVersionUID = 0; |
| } |
| |
| /** |
| * Returns a supplier which caches the instance retrieved during the first |
| * call to {@code get()} and returns that value on subsequent calls to |
| * {@code get()}. See: |
| * <a href="http://en.wikipedia.org/wiki/Memoization">memoization</a> |
| * |
| * <p>The returned supplier is thread-safe. The supplier's serialized form |
| * does not contain the cached value, which will be recalculated when {@code |
| * get()} is called on the reserialized instance. |
| * |
| * <p>If {@code delegate} is an instance created by an earlier call to {@code |
| * memoize}, it is returned directly. |
| */ |
| public static <T> Supplier<T> memoize(Supplier<T> delegate) { |
| return (delegate instanceof MemoizingSupplier) |
| ? delegate |
| : new MemoizingSupplier<T>(Preconditions.checkNotNull(delegate)); |
| } |
| |
| @VisibleForTesting |
| static class MemoizingSupplier<T> implements Supplier<T>, Serializable { |
| final Supplier<T> delegate; |
| transient volatile boolean initialized; |
| // "value" does not need to be volatile; visibility piggy-backs |
| // on volatile read of "initialized". |
| transient T value; |
| |
| MemoizingSupplier(Supplier<T> delegate) { |
| this.delegate = delegate; |
| } |
| |
| @Override public T get() { |
| // A 2-field variant of Double Checked Locking. |
| if (!initialized) { |
| synchronized (this) { |
| if (!initialized) { |
| T t = delegate.get(); |
| value = t; |
| initialized = true; |
| return t; |
| } |
| } |
| } |
| return value; |
| } |
| |
| @Override public String toString() { |
| return "Suppliers.memoize(" + delegate + ")"; |
| } |
| |
| private static final long serialVersionUID = 0; |
| } |
| |
| /** |
| * Returns a supplier that caches the instance supplied by the delegate and |
| * removes the cached value after the specified time has passed. Subsequent |
| * calls to {@code get()} return the cached value if the expiration time has |
| * not passed. After the expiration time, a new value is retrieved, cached, |
| * and returned. See: |
| * <a href="http://en.wikipedia.org/wiki/Memoization">memoization</a> |
| * |
| * <p>The returned supplier is thread-safe. The supplier's serialized form |
| * does not contain the cached value, which will be recalculated when {@code |
| * get()} is called on the reserialized instance. |
| * |
| * @param duration the length of time after a value is created that it |
| * should stop being returned by subsequent {@code get()} calls |
| * @param unit the unit that {@code duration} is expressed in |
| * @throws IllegalArgumentException if {@code duration} is not positive |
| * @since 2.0 |
| */ |
| public static <T> Supplier<T> memoizeWithExpiration( |
| Supplier<T> delegate, long duration, TimeUnit unit) { |
| return new ExpiringMemoizingSupplier<T>(delegate, duration, unit); |
| } |
| |
| @VisibleForTesting static class ExpiringMemoizingSupplier<T> |
| implements Supplier<T>, Serializable { |
| final Supplier<T> delegate; |
| final long durationNanos; |
| transient volatile T value; |
| // The special value 0 means "not yet initialized". |
| transient volatile long expirationNanos; |
| |
| ExpiringMemoizingSupplier( |
| Supplier<T> delegate, long duration, TimeUnit unit) { |
| this.delegate = Preconditions.checkNotNull(delegate); |
| this.durationNanos = unit.toNanos(duration); |
| Preconditions.checkArgument(duration > 0); |
| } |
| |
| @Override public T get() { |
| // Another variant of Double Checked Locking. |
| // |
| // We use two volatile reads. We could reduce this to one by |
| // putting our fields into a holder class, but (at least on x86) |
| // the extra memory consumption and indirection are more |
| // expensive than the extra volatile reads. |
| long nanos = expirationNanos; |
| long now = Platform.systemNanoTime(); |
| if (nanos == 0 || now - nanos >= 0) { |
| synchronized (this) { |
| if (nanos == expirationNanos) { // recheck for lost race |
| T t = delegate.get(); |
| value = t; |
| nanos = now + durationNanos; |
| // In the very unlikely event that nanos is 0, set it to 1; |
| // no one will notice 1 ns of tardiness. |
| expirationNanos = (nanos == 0) ? 1 : nanos; |
| return t; |
| } |
| } |
| } |
| return value; |
| } |
| |
| @Override public String toString() { |
| // This is a little strange if the unit the user provided was not NANOS, |
| // but we don't want to store the unit just for toString |
| return "Suppliers.memoizeWithExpiration(" + delegate + ", " + |
| durationNanos + ", NANOS)"; |
| } |
| |
| private static final long serialVersionUID = 0; |
| } |
| |
| /** |
| * Returns a supplier that always supplies {@code instance}. |
| */ |
| public static <T> Supplier<T> ofInstance(@Nullable T instance) { |
| return new SupplierOfInstance<T>(instance); |
| } |
| |
| private static class SupplierOfInstance<T> |
| implements Supplier<T>, Serializable { |
| final T instance; |
| |
| SupplierOfInstance(@Nullable T instance) { |
| this.instance = instance; |
| } |
| |
| @Override public T get() { |
| return instance; |
| } |
| |
| @Override public boolean equals(@Nullable Object obj) { |
| if (obj instanceof SupplierOfInstance) { |
| SupplierOfInstance<?> that = (SupplierOfInstance<?>) obj; |
| return Objects.equal(instance, that.instance); |
| } |
| return false; |
| } |
| |
| @Override public int hashCode() { |
| return Objects.hashCode(instance); |
| } |
| |
| @Override public String toString() { |
| return "Suppliers.ofInstance(" + instance + ")"; |
| } |
| |
| private static final long serialVersionUID = 0; |
| } |
| |
| /** |
| * Returns a supplier whose {@code get()} method synchronizes on |
| * {@code delegate} before calling it, making it thread-safe. |
| */ |
| public static <T> Supplier<T> synchronizedSupplier(Supplier<T> delegate) { |
| return new ThreadSafeSupplier<T>(Preconditions.checkNotNull(delegate)); |
| } |
| |
| private static class ThreadSafeSupplier<T> |
| implements Supplier<T>, Serializable { |
| final Supplier<T> delegate; |
| |
| ThreadSafeSupplier(Supplier<T> delegate) { |
| this.delegate = delegate; |
| } |
| |
| @Override public T get() { |
| synchronized (delegate) { |
| return delegate.get(); |
| } |
| } |
| |
| @Override public String toString() { |
| return "Suppliers.synchronizedSupplier(" + delegate + ")"; |
| } |
| |
| private static final long serialVersionUID = 0; |
| } |
| |
| /** |
| * Returns a function that accepts a supplier and returns the result of |
| * invoking {@link Supplier#get} on that supplier. |
| * |
| * @since 8.0 |
| */ |
| @Beta |
| public static <T> Function<Supplier<T>, T> supplierFunction() { |
| @SuppressWarnings("unchecked") // implementation is "fully variant" |
| SupplierFunction<T> sf = (SupplierFunction<T>) SupplierFunctionImpl.INSTANCE; |
| return sf; |
| } |
| |
| private interface SupplierFunction<T> extends Function<Supplier<T>, T> {} |
| |
| private enum SupplierFunctionImpl implements SupplierFunction<Object> { |
| INSTANCE; |
| |
| // Note: This makes T a "pass-through type" |
| @Override public Object apply(Supplier<Object> input) { |
| return input.get(); |
| } |
| |
| @Override public String toString() { |
| return "Suppliers.supplierFunction()"; |
| } |
| } |
| } |