FluentFunctions.FluentSupplier (cyclops-reactor 9.0.0-FINAL API)

java.lang.Object
- cyclops.function.FluentFunctions.FluentSupplier<R>

All Implemented Interfaces:: Fn0<R>, java.util.function.Supplier<R>

Enclosing class:: FluentFunctions

public static class FluentFunctions.FluentSupplier<R>
extends java.lang.Object
implements Fn0<R>

Nested Class Summary
- Nested classes/interfaces inherited from interface cyclops.function.Fn0
  Fn0.FunctionalOperations<R>, Fn0.Instances, Fn0.SupplierKind<R>

Constructor Summary

Constructors
Constructor and Description

FluentSupplier(java.util.function.Supplier<R> fn)

Constructors
Constructor and Description
`FluentSupplier(java.util.function.Supplier<R> fn)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FluentFunctions.FluentSupplier<R>`	`after(java.util.function.Consumer<R> action)` Apply after advice to this Supplier
`FluentFunctions.FluentSupplier<R>`	`around(java.util.function.Function<FluentFunctions.Advice0<R>,R> around)` Apply around advice to this Supplier
`java.util.concurrent.CompletableFuture<FluentFunctions.FluentSupplier<R>>`	`async(java.util.concurrent.Executor ex)`
`FluentFunctions.FluentSupplier<R>`	`before(java.lang.Runnable r)` Apply before advice to this Supplier
`ReactiveSeq<R>`	`generate()`
`R`	`get()`
`FluentFunctions.FluentSupplier<java.util.concurrent.CompletableFuture<R>>`	`liftAsync(java.util.concurrent.Executor ex)`
`<X extends java.lang.Throwable> FluentFunctions.FluentSupplier<Try<R,X>>`	`liftTry(java.lang.Class<X>... classes)`
`FluentFunctions.FluentSupplier<R>`	`log(java.util.function.Consumer<java.lang.String> logger, java.util.function.Consumer<java.lang.Throwable> error)` A supplier that logs it's success or error states to the provided Consumers
`FluentFunctions.FluentSupplier<R>`	`memoize()`
`FluentFunctions.FluentSupplier<R>`	`memoize(Cacheable<R> cache)`
`FluentFunctions.FluentSupplier<R>`	`name(java.lang.String name)`
`FluentFunctions.FluentSupplier<R>`	`println()`
`<X extends java.lang.Throwable> FluentFunctions.FluentSupplier<R>`	`recover(java.lang.Class<X> type, java.util.function.Supplier<R> onError)` A supplier that can recover from the specified exception types, using the provided Supplier
`FluentFunctions.FluentSupplier<R>`	`retry(int times, int backoffStartTime)` A supplier capable of retrying on failure using an exponential backoff strategy

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface cyclops.function.Fn0
andThen, apply, fnTo, functionOps, future, lift, lift, liftF, liftOpt, liftTry, memoizeAsync, memoizeAsync, run, suspend, toEval, λ, λv

- Constructor Detail
  - FluentSupplier
```
public FluentSupplier(java.util.function.Supplier<R> fn)
```
- Method Detail
  - get
```
public R get()
```
    Specified by:
    
    get in interface java.util.function.Supplier<R>
  - before
```
public FluentFunctions.FluentSupplier<R> before(java.lang.Runnable r)
```
    Apply before advice to this Supplier
    
    Parameters:
    
    r - Runnable that represents before advice (AOP)
    
    Returns:
    
    Returns a new Supplier with before advice attached
  - after
```
public FluentFunctions.FluentSupplier<R> after(java.util.function.Consumer<R> action)
```
    Apply after advice to this Supplier
    
    Parameters:
    
    action - Runnable that represents after advice (AOP)
    
    Returns:
    
    Returns a new Supplier with after advice attached
  - around
```
public FluentFunctions.FluentSupplier<R> around(java.util.function.Function<FluentFunctions.Advice0<R>,R> around)
```
    Apply around advice to this Supplier
    
    Parameters:
    
    around - Function that captures input to this Supplier and can optionally pass on the call
    
    Returns:
    
    Supplier with around advice attached
  - memoize
```
public FluentFunctions.FluentSupplier<R> memoize()
```
    Specified by:
    
    memoize in interface Fn0<R>
    
    Returns:
    
    A caching version of this Supplier
  - memoize
```
public FluentFunctions.FluentSupplier<R> memoize(Cacheable<R> cache)
```
    Specified by:
    
    memoize in interface Fn0<R>
    
    Parameters:
    
    cache - A cache implementation wrapper
    
    Returns:
    
    A caching version using the attached cache implemenation wrapper
  - name
```
public FluentFunctions.FluentSupplier<R> name(java.lang.String name)
```
    Parameters:
    
    name - To give this supplier
    
    Returns:
    
    A supplier with a name (useful for logging purposes)
  - println
```
public FluentFunctions.FluentSupplier<R> println()
```
    Returns:
    
    A supplier that prints out it's result or error on failure
  - log
```
public FluentFunctions.FluentSupplier<R> log(java.util.function.Consumer<java.lang.String> logger,
                                             java.util.function.Consumer<java.lang.Throwable> error)
```
    A supplier that logs it's success or error states to the provided Consumers
    
    Parameters:
    
    logger - Success logger
    
    error - Failure logger
    
    Returns:
    
    Supplier that logs it's state
  - recover
```
public <X extends java.lang.Throwable> FluentFunctions.FluentSupplier<R> recover(java.lang.Class<X> type,
                                                                                 java.util.function.Supplier<R> onError)
```
    A supplier that can recover from the specified exception types, using the provided Supplier
    
    Parameters:
    
    type - Recoverable exception types
    
    onError - Supplier to use on error
    
    Returns:
    
    Supplier capable of error recovery
  - retry
```
public FluentFunctions.FluentSupplier<R> retry(int times,
                                               int backoffStartTime)
```
    A supplier capable of retrying on failure using an exponential backoff strategy
    
    Parameters:
    
    times - Number of times to retry
    
    backoffStartTime - Wait time before first retry
    
    Returns:
    
    Supplier with a retry strategy
  - generate
```
public ReactiveSeq<R> generate()
```
    Returns:
    
    A reactiveStream generated from this suppliers Value
  - liftTry
```
public <X extends java.lang.Throwable> FluentFunctions.FluentSupplier<Try<R,X>> liftTry(java.lang.Class<X>... classes)
```
    Parameters:
    
    classes - To catch exceptions for
    
    Returns:
    
    A Supplier that returns it's value wrapped in a Try
  - liftAsync
```
public FluentFunctions.FluentSupplier<java.util.concurrent.CompletableFuture<R>> liftAsync(java.util.concurrent.Executor ex)
```
    Parameters:
    
    ex - Executor to execute this Supplier on
    
    Returns:
    
    A Supplier that returns it's value wrapped in a CompletableFuture, populated asyncrhonously
  - async
```
public java.util.concurrent.CompletableFuture<FluentFunctions.FluentSupplier<R>> async(java.util.concurrent.Executor ex)
```
    Parameters:
    
    ex - Executor to execute this Supplier on
    
    Returns:
    
    The value generated by this Supplier in a CompletableFuture executed Asynchronously

Class FluentFunctions.FluentSupplier<R>

Nested Class Summary

Nested classes/interfaces inherited from interface cyclops.function.Fn0

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface cyclops.function.Fn0

Constructor Detail

FluentSupplier

Method Detail

get

before

after

around

memoize

memoize

name

println

log

recover

retry

generate

liftTry

liftAsync

async