com.google.common.base

## Class Suppliers

- java.lang.Object
- - com.google.common.base.Suppliers

-     @CheckReturnValue
      @GwtCompatible
      public final class Suppliers
      extends java.lang.Object

  Useful suppliers.

  All methods return serializable suppliers as long as they're given serializable parameters.

  Since:
    2.0

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <F,T> Supplier<T>` | `compose(Function<? super F,T> function, Supplier<F> supplier)` Returns a new supplier which is the composition of the provided function and supplier.
    `static <T> Supplier<T>` | `memoize(Supplier<T> delegate)` Returns a supplier which caches the instance retrieved during the first call to `get()` and returns that value on subsequent calls to `get()`.
    `static <T> Supplier<T>` | `memoizeWithExpiration(Supplier<T> delegate, long duration, java.util.concurrent.TimeUnit unit)` Returns a supplier that caches the instance supplied by the delegate and removes the cached value after the specified time has passed.
    `static <T> Supplier<T>` | `ofInstance(T instance)` Returns a supplier that always supplies `instance`.
    `static <T> Function<Supplier<T>,T>` | `supplierFunction()` Returns a function that accepts a supplier and returns the result of invoking `Supplier.get()` on that supplier.
    `static <T> Supplier<T>` | `synchronizedSupplier(Supplier<T> delegate)` Returns a supplier whose `get()` method synchronizes on `delegate` before calling it, making it thread-safe.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### compose

          public static <F,T> Supplier<T> compose(Function<? super F,T> function,
                                  Supplier<F> supplier)

      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 `supplier`, and then applying `function` to that value. Note that the resulting supplier will not call `supplier` or invoke `function` until it is called.

    - #### memoize

          public static <T> Supplier<T> memoize(Supplier<T> delegate)

      Returns a supplier which caches the instance retrieved during the first call to `get()` and returns that value on subsequent calls to `get()`. See: memoization

      The returned supplier is thread-safe. The delegate's `get()` method will be invoked at most once. The supplier's serialized form does not contain the cached value, which will be recalculated when `get()` is called on the reserialized instance.

      If `delegate` is an instance created by an earlier call to `memoize`, it is returned directly.

    - #### memoizeWithExpiration

          public static <T> Supplier<T> memoizeWithExpiration(Supplier<T> delegate,
                                              long duration,
                                              java.util.concurrent.TimeUnit unit)

      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 `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: memoization

      The returned supplier is thread-safe. The supplier's serialized form does not contain the cached value, which will be recalculated when `get()` is called on the reserialized instance.

      Parameters:
        `duration` - the length of time after a value is created that it should stop being returned by subsequent `get()` calls
        `unit` - the unit that `duration` is expressed in
      Throws:
        `java.lang.IllegalArgumentException` - if `duration` is not positive
      Since:
        2.0

    - #### ofInstance

          public static <T> Supplier<T> ofInstance(@Nullable
                                   T instance)

      Returns a supplier that always supplies `instance`.

    - #### synchronizedSupplier

          public static <T> Supplier<T> synchronizedSupplier(Supplier<T> delegate)

      Returns a supplier whose `get()` method synchronizes on `delegate` before calling it, making it thread-safe.

    - #### supplierFunction

          @Beta
          public static <T> Function<Supplier<T>,T> supplierFunction()

      Returns a function that accepts a supplier and returns the result of invoking `Supplier.get()` on that supplier.
      Since:
        8.0