FluentFunctions.FluentTriFunction (cyclops-react 1.0.1 API)

java.lang.Object
- com.aol.cyclops.control.FluentFunctions.FluentTriFunction<T1,T2,T3,R>

All Implemented Interfaces:: TriFunction<T1,T2,T3,R>

Enclosing class:: FluentFunctions

public static class FluentFunctions.FluentTriFunction<T1,T2,T3,R>
extends java.lang.Object
implements TriFunction<T1,T2,T3,R>

Constructor Summary

Constructors
Constructor and Description

FluentTriFunction(TriFunction<T1,T2,T3,R> fn)

Constructors
Constructor and Description
`FluentTriFunction(TriFunction<T1,T2,T3,R> fn)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`after(QuadConsumer<T1,T2,T3,R> action)` Apply after advice to this TriFunction
`<R2> FluentFunctions.FluentTriFunction<T1,T2,T3,R2>`	`andThen(java.util.function.Function<? super R,? extends R2> after)` Compose this TriFunction with the provided function into a single TriFunction.
`R`	`apply(T1 t1, T2 t2, T3 t3)`
`FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`around(java.util.function.Function<FluentFunctions.Advice3<T1,T2,T3,R>,R> around)` Apply around advic to this TriFunction
`java.util.concurrent.CompletableFuture<FluentFunctions.FluentTriFunction<T1,T2,T3,R>>`	`async(java.util.concurrent.Executor ex)` Move this function into an asynchronous context
`FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`before(TriConsumer<T1,T2,T3> action)` Apply before advice to this TriFunction
`FluentFunctions.FluentFunction<T1,java.util.function.Function<T2,java.util.function.Function<T3,R>>>`	`curry()` Curry this BiFunction, that is convert it from a TriFunction that accepts thre input parameters to a 'chain' of three Functions that accept a single parameter
`ReactiveSeq<R>`	`generate(T1 input1, T2 input2, T3 input3)` Generate an infinite Stream by applying the input parameters to this function repeatedly
`ReactiveSeq<R>`	`iterate(T1 seed1, T2 seed2, T3 seed3, java.util.function.Function<R,org.jooq.lambda.tuple.Tuple3<T1,T2,T3>> mapToType)` Generate an infinite Stream from the provided seed values and mapping function.
`FluentFunctions.FluentTriFunction<java.util.Optional<T1>,java.util.Optional<T2>,java.util.Optional<T3>,java.util.Optional<R>>`	`lift()`
`FluentFunctions.FluentTriFunction<T1,T2,T3,java.util.concurrent.CompletableFuture<R>>`	`liftAsync(java.util.concurrent.Executor ex)` Convert this TriFunction into one that executes asynchronously and returns a CompleteableFuture with the result
`FluentFunctions.FluentTriFunction<AnyM<T1>,AnyM<T2>,AnyM<T3>,AnyM<R>>`	`liftM()`
`<X extends java.lang.Throwable> FluentFunctions.FluentTriFunction<T1,T2,T3,Try<R,X>>`	`liftTry(java.lang.Class<X>... classes)`
`FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`log(java.util.function.Consumer<java.lang.String> logger, java.util.function.Consumer<java.lang.Throwable> error)` A TriFunction that logs it's success or error states to the provided Consumers
`<R1> FluentFunctions.FluentTriFunction<T1,T2,T3,R1>`	`matches(java.util.function.Function<Matchable.CheckValue1<R,R1>,Matchable.CheckValue1<R,R1>> case1, java.util.function.Supplier<? extends R1> otherwise)` A TriFunction that triggers an event if the result matches the case provided, or generates a new value from the supplier provided if not
`FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`memoize()`
`FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`memoize(Cacheable<R> cache)` This methods creates a caching version of this BiFunction, caching is implemented via the Cacheable wrapper, that can be used to wrap any concrete cache implementation E.g.
`FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`name(java.lang.String name)`
`FluentFunctions.FluentBiFunction<T2,T3,R>`	`partiallyApply(T1 param)` Partially apply the provided parameter as the first parameter to this TriFunction to generate a Function (single input value)
`FluentFunctions.FluentFunction<T3,R>`	`partiallyApply(T1 param1, T2 param2)` Partially apply the provided parameters to this BiFunction to generate a Function (single input)
`FluentFunctions.FluentSupplier<R>`	`partiallyApply(T1 param1, T2 param2, T3 param3)` Partially apply the provided parameters to this TriFunction to generate a Supplier (that takes no inputs)
`FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`println()`
`<X extends java.lang.Throwable> FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`recover(java.lang.Class<X> type, TriFunction<T1,T2,T3,R> onError)` A TriFunction that can recover from the specified exception types, using the provided recovery Function
`FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`retry(int times, int backoffStartTime)` A TriFunction capable of retrying on failure using an exponential backoff strategy
`FluentFunctions.FluentTriFunction<T1,T2,T3,R>`	`visitEvent(java.util.function.Consumer<R> eventConsumer, java.util.function.Consumer<java.lang.Throwable> errorConsumer)` Visit the result of this TriFunction once it has been executed, if the Function executes successfully the result will be passes to the eventConsumer, if there is an error it will be passed to the errorConsumer

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

Methods inherited from interface com.aol.cyclops.util.function.TriFunction
apply, apply, function3

Constructor Detail

FluentTriFunction

public FluentTriFunction(TriFunction<T1,T2,T3,R> fn)

Method Detail

apply

public R apply(T1 t1,
               T2 t2,
               T3 t3)

Specified by:: apply in interface TriFunction<T1,T2,T3,R>

before
```
public FluentFunctions.FluentTriFunction<T1,T2,T3,R> before(TriConsumer<T1,T2,T3> action)
```
Apply before advice to this TriFunction

Parameters:

action - TriConsumer to recieve the input parameters to TriFunction

Returns:

TriFunction with before advice attached

after
```
public FluentFunctions.FluentTriFunction<T1,T2,T3,R> after(QuadConsumer<T1,T2,T3,R> action)
```
Apply after advice to this TriFunction

Parameters:

action - QuadConsumer to recieve the input parameters and result from this TriFunction

Returns:

TriFunction with after advice attached

around

public FluentFunctions.FluentTriFunction<T1,T2,T3,R> around(java.util.function.Function<FluentFunctions.Advice3<T1,T2,T3,R>,R> around)

Apply around advic to this TriFunction

  
 
 FluentFunctions.of((a,b,c)->a+b+c)
                          .around(advice->advice.proceed1(advice.param1+1))
                          .println()
                          .apply(10,1,0)
                          
              //12

Parameters:: around - Function that gives controlling access to this Function via the Advice inout parameter
Returns:: TriFunction with around advice attached

partiallyApply
```
public FluentFunctions.FluentBiFunction<T2,T3,R> partiallyApply(T1 param)
```
Partially apply the provided parameter as the first parameter to this TriFunction to generate a Function (single input value)

Parameters:

param - Input parameter to Partially Applied

Returns:

A BiFunction generated from the BiFunction with the first parameter already applied

partiallyApply
```
public FluentFunctions.FluentFunction<T3,R> partiallyApply(T1 param1,
                                                           T2 param2)
```
Partially apply the provided parameters to this BiFunction to generate a Function (single input)

Parameters:

param1 - First Input parameter

param2 - Second Input parameter

Returns:

Function generated from the partial application of the provided input parameters to this TriFunction

partiallyApply

public FluentFunctions.FluentSupplier<R> partiallyApply(T1 param1,
                                                        T2 param2,
                                                        T3 param3)

Partially apply the provided parameters to this TriFunction to generate a Supplier (that takes no inputs)

Parameters:: param1 - First Input parameter; param2 - Second Input parameter; param3 - Third Input parameter
Returns:: Supplier generated from the partial application of the provided input parameters to this TriFunction

curry

public FluentFunctions.FluentFunction<T1,java.util.function.Function<T2,java.util.function.Function<T3,R>>> curry()

Curry this BiFunction, that is convert it from a TriFunction that accepts thre input parameters to a 'chain' of three Functions that accept a single parameter

  
 public int add(Integer a,Integer b, Integer c ){
               return a+b;
           }
 
      FluentFunctions.of(this::add)
                               .curry()
                               .apply(1)
                               .apply(2)
                               .apply(3);
                               
                //6

Returns:: Curried function

memoize
```
public FluentFunctions.FluentTriFunction<T1,T2,T3,R> memoize()
```
Returns:

Function that logs it's result or error to the console

memoize

public FluentFunctions.FluentTriFunction<T1,T2,T3,R> memoize(Cacheable<R> cache)

This methods creates a caching version of this BiFunction, caching is implemented via the Cacheable wrapper, that can be used to wrap any concrete cache implementation E.g. to use a Guava cache for memoization

  
 
 Cache<Object, Integer> cache = CacheBuilder.newBuilder()
                   .maximumSize(1000)
                   .expireAfterWrite(10, TimeUnit.MINUTES)
                   .build();
        
                   called=0;
            TriFunction<Integer,Integer,Integer> fn = FluentFunctions.of(this::add)
                                                                     .name("myFunction")
                                                                     .memoize((key,f)->cache.get(key,()->f.apply(key)));
        
            fn.apply(10,1,4);
            fn.apply(10,1,4);
            fn.apply(10,1,4);
        
            assertThat(called,equalTo(1));

Parameters:: cache - Cache implementation wrapper
Returns:: A caching (memoizing) version of this BiFunction, outputs for all inputs will be cached (unless ejected from the cache)

name
```
public FluentFunctions.FluentTriFunction<T1,T2,T3,R> name(java.lang.String name)
```
Parameters:

name - To give this TriFunction

Returns:

A TriFunction with a name (useful for logging purposes)

log

public FluentFunctions.FluentTriFunction<T1,T2,T3,R> log(java.util.function.Consumer<java.lang.String> logger,
                                                         java.util.function.Consumer<java.lang.Throwable> error)

A TriFunction that logs it's success or error states to the provided Consumers

Parameters:: logger - Success logger; error - Failure logger
Returns:: TriFunction that logs it's state

visitEvent
```
public FluentFunctions.FluentTriFunction<T1,T2,T3,R> visitEvent(java.util.function.Consumer<R> eventConsumer,
                                                                java.util.function.Consumer<java.lang.Throwable> errorConsumer)
```
Visit the result of this TriFunction once it has been executed, if the Function executes successfully the result will be passes to the eventConsumer, if there is an error it will be passed to the errorConsumer

Parameters:

eventConsumer - Consumer to recieve result on successful execution

errorConsumer - Consumer to recieve error on failure

Returns:

TriFunction with event vistor attached.

println
```
public FluentFunctions.FluentTriFunction<T1,T2,T3,R> println()
```
Returns:

TriFunction that logs it's result or error to the console

recover

public <X extends java.lang.Throwable> FluentFunctions.FluentTriFunction<T1,T2,T3,R> recover(java.lang.Class<X> type,
                                                                                             TriFunction<T1,T2,T3,R> onError)

A TriFunction that can recover from the specified exception types, using the provided recovery Function

Parameters:: type - Recoverable exception types; onError - Recovery BiFunction
Returns:: TriFunction capable of error recovery

retry
```
public FluentFunctions.FluentTriFunction<T1,T2,T3,R> retry(int times,
                                                           int backoffStartTime)
```
A TriFunction capable of retrying on failure using an exponential backoff strategy

Parameters:

times - Number of times to retry

backoffStartTime - Wait time before first retry

Returns:

TriFunction with a retry strategy

matches
```
public <R1> FluentFunctions.FluentTriFunction<T1,T2,T3,R1> matches(java.util.function.Function<Matchable.CheckValue1<R,R1>,Matchable.CheckValue1<R,R1>> case1,
                                                                   java.util.function.Supplier<? extends R1> otherwise)
```
A TriFunction that triggers an event if the result matches the case provided, or generates a new value from the supplier provided if not

Parameters:

case1 - Case against which the value returned by this Function will be compared

otherwise - Supplier to generate an alterantive value if this value does not match the provided case

Returns:

TriFunction that matches it's value against the supplied case

iterate

public ReactiveSeq<R> iterate(T1 seed1,
                              T2 seed2,
                              T3 seed3,
                              java.util.function.Function<R,org.jooq.lambda.tuple.Tuple3<T1,T2,T3>> mapToType)

Generate an infinite Stream from the provided seed values and mapping function. The supplied mapping function is inverted taking an input of type R and returning three outputs T1, T2 (in a Tuple)

  
   FluentFunctions.of(this::add)  
                           .iterate(1,2,3,(i)->Tuple.tuple(i,i,i))
                           .limit(2) 
                           .printOut();
                           
                           
              //6
                18

Parameters:: seed1 - Initial input parameter 1; seed2 - Initial input parameter 2; seed3 - Initial input parameter 3; mapToType - Reversed mapping function
Returns:: Infinite Stream

generate
```
public ReactiveSeq<R> generate(T1 input1,
                               T2 input2,
                               T3 input3)
```
Generate an infinite Stream by applying the input parameters to this function repeatedly

Parameters:

input1 - First input parameter

input2 - Second input parameter

input3 - Third input parameter

Returns:

Infinite Stream

lift

public FluentFunctions.FluentTriFunction<java.util.Optional<T1>,java.util.Optional<T2>,java.util.Optional<T3>,java.util.Optional<R>> lift()

Returns:: A TriFunction that accepts and returns Optionals

liftTry

public <X extends java.lang.Throwable> FluentFunctions.FluentTriFunction<T1,T2,T3,Try<R,X>> liftTry(java.lang.Class<X>... classes)

Parameters:: classes - Classes to catch exceptions for
Returns:: TriFunction that returns it's result in a Try

liftM
```
public FluentFunctions.FluentTriFunction<AnyM<T1>,AnyM<T2>,AnyM<T3>,AnyM<R>> liftM()
```
Returns:

Lift this TriFunction into one that accepts and returns generic monad types (AnyM)

liftAsync
```
public FluentFunctions.FluentTriFunction<T1,T2,T3,java.util.concurrent.CompletableFuture<R>> liftAsync(java.util.concurrent.Executor ex)
```
Convert this TriFunction into one that executes asynchronously and returns a CompleteableFuture with the result

Parameters:

ex - Executor to execute this TriFunction on

Returns:

TriFunction that executes Asynchronous

async
```
public java.util.concurrent.CompletableFuture<FluentFunctions.FluentTriFunction<T1,T2,T3,R>> async(java.util.concurrent.Executor ex)
```
Move this function into an asynchronous context

Parameters:

ex - Executor to manage operations on this function on

Returns:

A CompletableFuture that contains this function

andThen
```
public <R2> FluentFunctions.FluentTriFunction<T1,T2,T3,R2> andThen(java.util.function.Function<? super R,? extends R2> after)
```
Compose this TriFunction with the provided function into a single TriFunction. This TriFunction would be executed first and the result passed to the provided Function and applied there.

Parameters:

after - Function to execute after this one in a chain

Returns:

TriFunction that executes this TriFunction and the provided Function in a chain

Class FluentFunctions.FluentTriFunction<T1,T2,T3,R>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops.util.function.TriFunction

Constructor Detail

FluentTriFunction

Method Detail

apply

before

after

around

partiallyApply

partiallyApply

partiallyApply

curry

memoize

memoize

name

log

visitEvent

println

recover

retry

matches

iterate

generate

lift

liftTry

liftM

liftAsync

async

andThen