com.aol.cyclops.control

Class FluentFunctions.FluentFunction<T,R>

java.lang.Object

com.aol.cyclops.control.FluentFunctions.FluentFunction<T,R>

All Implemented Interfaces:

Reader<T,R>, java.util.function.Function<T,R>

Enclosing class:

FluentFunctions

public static class FluentFunctions.FluentFunction<T,R>
extends java.lang.Object
implements java.util.function.Function<T,R>, Reader<T,R>

Constructor Summary

Constructors

Constructor and Description
FluentFunction(java.util.function.Function<T,R> fn)

Method Summary

Modifier and Type	Method and Description
FluentFunctions.FluentFunction<T,R>	after(java.util.function.BiConsumer<T,R> action)
R	apply(T t)
FluentFunctions.FluentFunction<T,R>	around(java.util.function.Function<FluentFunctions.Advice1<T,R>,R> around)
java.util.concurrent.CompletableFuture<FluentFunctions.FluentFunction<T,R>>	async(java.util.concurrent.Executor ex)
FluentFunctions.FluentFunction<T,R>	before(java.util.function.Consumer<T> action)
<R1> FluentFunctions.FluentFunction<T,R1>	flatMap(java.util.function.Function<? super R,? extends Reader<T,R1>> f)
ReactiveSeq<R>	generate(T input)
ReactiveSeq<R>	iterate(T seed, java.util.function.Function<R,T> mapToType) Generate an infinite Stream that iterates from the specified seed using the currently wrapped function e.g.
FluentFunctions.FluentFunction<java.util.Optional<T>,java.util.Optional<R>>	lift()
FluentFunctions.FluentFunction<T,java.util.concurrent.CompletableFuture<R>>	liftAsync(java.util.concurrent.Executor ex)
FluentFunctions.FluentFunction<AnyM<T>,AnyM<R>>	liftM()
<X extends java.lang.Throwable> FluentFunctions.FluentFunction<T,Try<R,X>>	liftTry(java.lang.Class<X>... classes)
FluentFunctions.FluentFunction<T,R>	log(java.util.function.Consumer<java.lang.String> logger, java.util.function.Consumer<java.lang.Throwable> error)
<R1> FluentFunctions.FluentFunction<T,R1>	map(java.util.function.Function<? super R,? extends R1> f2)
<R1> FluentFunctions.FluentFunction<T,R1>	matches(java.util.function.Function<Matchable.CheckValues<R,R1>,Matchable.CheckValues<R,R1>> case1, java.util.function.Supplier<? extends R1> otherwise)
FluentFunctions.FluentFunction<T,R>	memoize()
FluentFunctions.FluentFunction<T,R>	memoize(Cacheable<R> cache)
FluentFunctions.FluentFunction<T,R>	name(java.lang.String name)
FluentFunctions.FluentSupplier<R>	partiallyApply(T param)
FluentFunctions.FluentFunction<T,R>	println()
<X extends java.lang.Throwable> FluentFunctions.FluentFunction<T,R>	recover(java.lang.Class<X> type, java.util.function.Function<T,R> onError)
FluentFunctions.FluentFunction<T,R>	retry(int times, int backoffStartTime)

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.control.Reader

anyM

Methods inherited from interface java.util.function.Function

andThen, compose, identity

Constructor Detail

FluentFunction

public FluentFunction(java.util.function.Function<T,R> fn)

Method Detail

apply

public R apply(T t)

Specified by:

apply in interface java.util.function.Function<T,R>

map

public <R1> FluentFunctions.FluentFunction<T,R1> map(java.util.function.Function<? super R,? extends R1> f2)

Specified by:

map in interface Reader<T,R>

flatMap

public <R1> FluentFunctions.FluentFunction<T,R1> flatMap(java.util.function.Function<? super R,? extends Reader<T,R1>> f)

Specified by:

flatMap in interface Reader<T,R>

before

public FluentFunctions.FluentFunction<T,R> before(java.util.function.Consumer<T> action)

after

public FluentFunctions.FluentFunction<T,R> after(java.util.function.BiConsumer<T,R> action)

around

public FluentFunctions.FluentFunction<T,R> around(java.util.function.Function<FluentFunctions.Advice1<T,R>,R> around)

partiallyApply

public FluentFunctions.FluentSupplier<R> partiallyApply(T param)

memoize

public FluentFunctions.FluentFunction<T,R> memoize()

memoize

public FluentFunctions.FluentFunction<T,R> memoize(Cacheable<R> cache)

name

public FluentFunctions.FluentFunction<T,R> name(java.lang.String name)

log

public FluentFunctions.FluentFunction<T,R> log(java.util.function.Consumer<java.lang.String> logger,
                                               java.util.function.Consumer<java.lang.Throwable> error)

println

public FluentFunctions.FluentFunction<T,R> println()

recover

public <X extends java.lang.Throwable> FluentFunctions.FluentFunction<T,R> recover(java.lang.Class<X> type,
                                                                                   java.util.function.Function<T,R> onError)

retry

public FluentFunctions.FluentFunction<T,R> retry(int times,
                                                 int backoffStartTime)

matches

public <R1> FluentFunctions.FluentFunction<T,R1> matches(java.util.function.Function<Matchable.CheckValues<R,R1>,Matchable.CheckValues<R,R1>> case1,
                                                         java.util.function.Supplier<? extends R1> otherwise)

iterate

public ReactiveSeq<R> iterate(T seed,
                              java.util.function.Function<R,T> mapToType)

Generate an infinite Stream that iterates from the specified seed using the currently wrapped function e.g.

  
 FluentFunctions.of(this::addOne)	
						.iterate(95281,i->i)
						.forEach(System.out::println);
 
 
 //95282
		   //95283
		   //95284
		   //95285
		   //95286
 //etc
 
 

Parameters:

seed - initial value

mapToType - Convert from supplied functions return type to Stream input type

Returns:

Infinite Stream

generate

public ReactiveSeq<R> generate(T input)

lift

public FluentFunctions.FluentFunction<java.util.Optional<T>,java.util.Optional<R>> lift()

liftTry

public <X extends java.lang.Throwable> FluentFunctions.FluentFunction<T,Try<R,X>> liftTry(java.lang.Class<X>... classes)

liftM

public FluentFunctions.FluentFunction<AnyM<T>,AnyM<R>> liftM()

liftAsync

public FluentFunctions.FluentFunction<T,java.util.concurrent.CompletableFuture<R>> liftAsync(java.util.concurrent.Executor ex)

async

public java.util.concurrent.CompletableFuture<FluentFunctions.FluentFunction<T,R>> async(java.util.concurrent.Executor ex)