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,
                                      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:

  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