Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.google.common.base
Class Suppliers

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

    @GwtCompatible
    public final class Suppliers

extends Object

Useful suppliers.

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

Since:
  2.0 (imported from Google Collections Library)
Author:
  Laurence Gonsalves, Harry Heymann

Method Summary
`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, 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 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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2010-2012. All Rights Reserved.