Package com.landawn.abacus.util

Class Fn.Fnn

java.lang.Object

com.landawn.abacus.util.Fn.Fnn

Enclosing class:

Fn

public static final class Fn.Fnn
extends Object

Utility class for exceptional Predicate/Function/Consumer.

Author:

haiyangl

Method Summary

Modifier and Type	Method	Description
static <K, V, E extends Throwable> Throwables.Consumer<Map.Entry<K,V>,E>	acceptByKey(Throwables.Consumer<? super K,E> consumer)
static <K, V, E extends Throwable> Throwables.Consumer<Map.Entry<K,V>,E>	acceptByValue(Throwables.Consumer<? super V,E> consumer)
static <T, E extends Exception> Throwables.Predicate<T,E>	alwaysFalse()
static <T, E extends Exception> Throwables.Predicate<T,E>	alwaysTrue()
static <K, V, R, E extends Throwable> Throwables.Function<Map.Entry<K,V>,R,E>	applyByKey(Throwables.Function<? super K,? extends R,E> func)
static <K, V, R, E extends Throwable> Throwables.Function<Map.Entry<K,V>,R,E>	applyByValue(Throwables.Function<? super V,? extends R,E> func)
static <A, B, T, E extends Throwable> Throwables.Consumer<T,E>	c(A a, B b, Throwables.TriConsumer<A,B,T,E> triConsumer)
static <A, T, E extends Throwable> Throwables.Consumer<T,E>	c(A a, Throwables.BiConsumer<A,T,E> biConsumer)
static <A, T, U, E extends Throwable> Throwables.BiConsumer<T,U,E>	c(A a, Throwables.TriConsumer<A,T,U,E> triConsumer)
static <T, U, E extends Throwable> Throwables.BiConsumer<T,U,E>	c(Throwables.BiConsumer<T,U,E> biConsumer)
static <R, E extends Throwable> Throwables.Callable<R,E>	c(Throwables.Callable<R,E> callable)
static <T, E extends Throwable> Throwables.Consumer<T,E>	c(Throwables.Consumer<T,E> predicate)
static <A, B, C, E extends Throwable> Throwables.TriConsumer<A,B,C,E>	c(Throwables.TriConsumer<A,B,C,E> triConsumer)
static <T, U, E extends Throwable> Throwables.BiFunction<T,U,Void,E>	c2f(Throwables.BiConsumer<T,U,E> biConsumer)
static <T, U, R, E extends Throwable> Throwables.BiFunction<T,U,R,E>	c2f(Throwables.BiConsumer<T,U,E> biConsumer, R valueToReturn)
static <T, E extends Throwable> Throwables.Function<T,Void,E>	c2f(Throwables.Consumer<T,E> consumer)
static <T, R, E extends Throwable> Throwables.Function<T,R,E>	c2f(Throwables.Consumer<T,E> consumer, R valueToReturn)
static <A, B, C, E extends Throwable> Throwables.TriFunction<A,B,C,Void,E>	c2f(Throwables.TriConsumer<A,B,C,E> triConsumer)
static <A, B, C, R, E extends Throwable> Throwables.TriFunction<A,B,C,R,E>	c2f(Throwables.TriConsumer<A,B,C,E> triConsumer, R valueToReturn)
static <R> Callable<R>	c2jc(Throwables.Callable<R,? extends Exception> callable)
static <R, E extends Throwable> Throwables.Runnable<E>	c2r(Throwables.Callable<R,E> callable)
static <A, B, T, E extends Throwable> Throwables.Consumer<T,E>	cc(A a, B b, TriConsumer<A,B,T> triConsumer)
static <A, T, U, E extends Throwable> Throwables.BiConsumer<T,U,E>	cc(A a, TriConsumer<A,T,U> triConsumer)
static <A, T, E extends Throwable> Throwables.Consumer<T,E>	cc(A a, BiConsumer<A,T> biConsumer)
static <T, U, E extends Throwable> Throwables.BiConsumer<T,U,E>	cc(BiConsumer<T,U> biConsumer)
static <R, E extends Throwable> Throwables.Callable<R,E>	cc(Callable<R> callable)
static <T, E extends Throwable> Throwables.Consumer<T,E>	cc(Consumer<T> consumer)
static <A, B, C, E extends Throwable> Throwables.TriConsumer<A,B,C,E>	cc(TriConsumer<A,B,C> triConsumer)
static <T extends AutoCloseable> Throwables.Consumer<T,Exception>	close()
static <T extends AutoCloseable, E extends Exception> Throwables.Consumer<T,E>	closeQuietly()
static <T, E extends Exception> Throwables.Consumer<T,E>	doNothing()
static <E extends Exception> Throwables.Runnable<E>	emptyAction()
static <K, V, E extends Exception> Throwables.BiFunction<K,V,Map.Entry<K,V>,E>	entry()
static <A, B, T, R, E extends Throwable> Throwables.Function<T,R,E>	f(A a, B b, Throwables.TriFunction<A,B,T,R,E> triFunction)
static <A, T, R, E extends Throwable> Throwables.Function<T,R,E>	f(A a, Throwables.BiFunction<A,T,R,E> biFunction)
static <A, T, U, R, E extends Throwable> Throwables.BiFunction<T,U,R,E>	f(A a, Throwables.TriFunction<A,T,U,R,E> triFunction)
static <T, U, R, E extends Throwable> Throwables.BiFunction<T,U,R,E>	f(Throwables.BiFunction<T,U,R,E> biFunction)
static <T, R, E extends Throwable> Throwables.Function<T,R,E>	f(Throwables.Function<T,R,E> predicate)
static <A, B, C, R, E extends Throwable> Throwables.TriFunction<A,B,C,R,E>	f(Throwables.TriFunction<A,B,C,R,E> triFunction)
static <T, U, R, E extends Throwable> Throwables.BiConsumer<T,U,E>	f2c(Throwables.BiFunction<T,U,? extends R,E> func)
static <T, R, E extends Throwable> Throwables.Consumer<T,E>	f2c(Throwables.Function<T,? extends R,E> func)
static <A, B, C, R, E extends Throwable> Throwables.TriConsumer<A,B,C,E>	f2c(Throwables.TriFunction<A,B,C,? extends R,E> func)
static <A, B, T, R, E extends Throwable> Throwables.Function<T,R,E>	ff(A a, B b, TriFunction<A,B,T,R> triFunction)
static <A, T, U, R, E extends Throwable> Throwables.BiFunction<T,U,R,E>	ff(A a, TriFunction<A,T,U,R> triFunction)
static <A, T, R, E extends Throwable> Throwables.Function<T,R,E>	ff(A a, BiFunction<A,T,R> biFunction)
static <T, U, R, E extends Throwable> Throwables.BiFunction<T,U,R,E>	ff(BiFunction<T,U,R> biFunction)
static <T, R, E extends Throwable> Throwables.Function<T,R,E>	ff(Function<T,? extends R> function)
static <A, B, C, R, E extends Throwable> Throwables.TriFunction<A,B,C,R,E>	ff(TriFunction<A,B,C,R> triFunction)
static <T, U, E extends Throwable> Throwables.BiConsumer<T,U,E>	from(BiConsumer<T,U> consumer)
static <T, U, R, E extends Throwable> Throwables.BiFunction<T,U,R,E>	from(BiFunction<T,U,? extends R> function)
static <T, E extends Throwable> Throwables.BinaryOperator<T,E>	from(BinaryOperator<T> op)
static <T, U, E extends Throwable> Throwables.BiPredicate<T,U,E>	from(BiPredicate<T,U> predicate)
static <T, E extends Throwable> Throwables.Consumer<T,E>	from(Consumer<T> consumer)
static <T, R, E extends Throwable> Throwables.Function<T,R,E>	from(Function<T,? extends R> function)
static <T, E extends Throwable> Throwables.IntFunction<T,E>	from(IntFunction<? extends T> func)
static <T, E extends Throwable> Throwables.Predicate<T,E>	from(Predicate<T> predicate)
static <T, E extends Throwable> Throwables.Supplier<T,E>	from(Supplier<T> supplier)
static <T, E extends Throwable> Throwables.UnaryOperator<T,E>	from(UnaryOperator<T> op)
static <T, E extends Exception> Throwables.Function<T,T,E>	identity()
static <T, E extends Exception> Throwables.BinaryOperator<T,E>	ignoringMerger()
static <K, V, E extends Exception> Throwables.Function<Map.Entry<K,V>,Map.Entry<V,K>,E>	inverse()
static <T, E extends Exception> Throwables.Predicate<T,E>	isNull()
static <T extends CharSequence, E extends Exception> Throwables.Predicate<T,E>	isNullOrEmpty()
static <T, E extends Exception> Throwables.Predicate<T[],E>	isNullOrEmptyA()
static <T extends Collection, E extends Exception> Throwables.Predicate<T,E>	isNullOrEmptyC()
static <T extends Map, E extends Exception> Throwables.Predicate<T,E>	isNullOrEmptyM()
static <R> Throwables.Callable<R,Exception>	jc2c(Callable<R> callable)
static <E extends Throwable> Throwables.Runnable<E>	jr2r(Runnable runnable)
static <K, V, E extends Exception> Throwables.Function<Map.Entry<K,V>,K,E>	key()
static <T extends Comparable<? super T>, E extends Throwable> Throwables.BinaryOperator<T,E>	max()
static <T, E extends Throwable> Throwables.BinaryOperator<T,E>	max(Comparator<? super T> comparator)
static <T, E extends Throwable> Throwables.BinaryOperator<T,E>	maxBy(Function<? super T,? extends Comparable> keyMapper)
static <K extends Comparable<? super K>, V, E extends Throwable> Throwables.BinaryOperator<Map.Entry<K,V>,E>	maxByKey()
static <K, V extends Comparable<? super V>, E extends Throwable> Throwables.BinaryOperator<Map.Entry<K,V>,E>	maxByValue()
static <T, E extends Throwable> Throwables.LazyInitializer<T,E>	memoize(Throwables.Supplier<T,E> supplier)	Returns a Supplier which returns a single instance created by calling the specified supplier.get().
static <T extends Comparable<? super T>, E extends Throwable> Throwables.BinaryOperator<T,E>	min()
static <T, E extends Throwable> Throwables.BinaryOperator<T,E>	min(Comparator<? super T> comparator)
static <T, E extends Throwable> Throwables.BinaryOperator<T,E>	minBy(Function<? super T,? extends Comparable> keyMapper)
static <K extends Comparable<? super K>, V, E extends Throwable> Throwables.BinaryOperator<Map.Entry<K,V>,E>	minByKey()
static <K, V extends Comparable<? super V>, E extends Throwable> Throwables.BinaryOperator<Map.Entry<K,V>,E>	minByValue()
static <T, U, E extends Throwable> Throwables.BiPredicate<T,U,E>	not(Throwables.BiPredicate<T,U,E> biPredicate)
static <T, E extends Throwable> Throwables.Predicate<T,E>	not(Throwables.Predicate<T,E> predicate)
static <A, B, C, E extends Throwable> Throwables.TriPredicate<A,B,C,E>	not(Throwables.TriPredicate<A,B,C,E> triPredicate)
static <T, E extends Exception> Throwables.Predicate<T,E>	notNull()
static <T extends CharSequence, E extends Exception> Throwables.Predicate<T,E>	notNullOrEmpty()
static <T, E extends Exception> Throwables.Predicate<T[],E>	notNullOrEmptyA()
static <T extends Collection, E extends Exception> Throwables.Predicate<T,E>	notNullOrEmptyC()
static <T extends Map, E extends Exception> Throwables.Predicate<T,E>	notNullOrEmptyM()
static <A, B, T, E extends Throwable> Throwables.Predicate<T,E>	p(A a, B b, Throwables.TriPredicate<A,B,T,E> triPredicate)
static <A, T, E extends Throwable> Throwables.Predicate<T,E>	p(A a, Throwables.BiPredicate<A,T,E> biPredicate)
static <A, T, U, E extends Throwable> Throwables.BiPredicate<T,U,E>	p(A a, Throwables.TriPredicate<A,T,U,E> triPredicate)
static <T, U, E extends Throwable> Throwables.BiPredicate<T,U,E>	p(Throwables.BiPredicate<T,U,E> biPredicate)
static <T, E extends Throwable> Throwables.Predicate<T,E>	p(Throwables.Predicate<T,E> predicate)
static <A, B, C, E extends Throwable> Throwables.TriPredicate<A,B,C,E>	p(Throwables.TriPredicate<A,B,C,E> triPredicate)
static <L, R, E extends Exception> Throwables.BiFunction<L,R,Pair<L,R>,E>	pair()
static <A, B, T, E extends Throwable> Throwables.Predicate<T,E>	pp(A a, B b, TriPredicate<A,B,T> triPredicate)
static <A, T, U, E extends Throwable> Throwables.BiPredicate<T,U,E>	pp(A a, TriPredicate<A,T,U> triPredicate)
static <A, T, E extends Throwable> Throwables.Predicate<T,E>	pp(A a, BiPredicate<A,T> biPredicate)
static <T, U, E extends Throwable> Throwables.BiPredicate<T,U,E>	pp(BiPredicate<T,U> biPredicate)
static <T, E extends Throwable> Throwables.Predicate<T,E>	pp(Predicate<T> predicate)
static <A, B, C, E extends Throwable> Throwables.TriPredicate<A,B,C,E>	pp(TriPredicate<A,B,C> triPredicate)
static <T, E extends Exception> Throwables.Consumer<T,E>	println()
static <T, U, E extends Exception> Throwables.BiConsumer<T,U,E>	println(String separator)
static <E extends Throwable> Throwables.Runnable<E>	r(Throwables.Runnable<E> runnable)
static <E extends Throwable> Throwables.Callable<Void,E>	r2c(Throwables.Runnable<E> runnable)
static <R, E extends Throwable> Throwables.Callable<R,E>	r2c(Throwables.Runnable<E> runnable, R valueToReturn)
static <E extends Throwable> Runnable	r2jr(Throwables.Runnable<E> runnable)
static <T, E extends Exception> Throwables.Consumer<T,E>	rateLimiter(double permitsPerSecond)	Returns a stateful Consumer.
static <T, E extends Exception> Throwables.Consumer<T,E>	rateLimiter(RateLimiter rateLimiter)	Returns a stateful Consumer.
static <T, E extends Exception> Throwables.BinaryOperator<T,E>	replacingMerger()
static <E extends Throwable> Throwables.Runnable<E>	rr(Runnable runnable)
static <A, T, E extends Throwable> Throwables.Consumer<T,E>	sc(Object mutex, A a, Throwables.BiConsumer<A,T,E> biConsumer)	Synchronized Consumer.
static <T, U, E extends Throwable> Throwables.BiConsumer<T,U,E>	sc(Object mutex, Throwables.BiConsumer<T,U,E> biConsumer)	Synchronized BiConsumer.
static <T, E extends Throwable> Throwables.Consumer<T,E>	sc(Object mutex, Throwables.Consumer<T,E> consumer)	Synchronized Consumer.
static <T, E extends Throwable> Throwables.BinaryOperator<T,E>	selectFirst()
static <T, E extends Throwable> Throwables.BinaryOperator<T,E>	selectSecond()
static <A, T, R, E extends Throwable> Throwables.Function<T,R,E>	sf(Object mutex, A a, Throwables.BiFunction<A,T,R,E> biFunction)	Synchronized Function.
static <T, U, R, E extends Throwable> Throwables.BiFunction<T,U,R,E>	sf(Object mutex, Throwables.BiFunction<T,U,R,E> biFunction)	Synchronized BiFunction.
static <T, R, E extends Throwable> Throwables.Function<T,R,E>	sf(Object mutex, Throwables.Function<T,? extends R,E> function)	Synchronized Function.
static <T, E extends Exception> Throwables.Consumer<T,E>	sleep(long millis)
static <T, E extends Exception> Throwables.Consumer<T,E>	sleepUninterruptibly(long millis)
static <A, B, T, E extends Throwable> Throwables.Predicate<T,E>	sp(Object mutex, A a, B b, Throwables.TriPredicate<A,B,T,E> triPredicate)	Synchronized Predicate.
static <A, T, E extends Throwable> Throwables.Predicate<T,E>	sp(Object mutex, A a, Throwables.BiPredicate<A,T,E> biPredicate)	Synchronized Predicate.
static <T, U, E extends Throwable> Throwables.BiPredicate<T,U,E>	sp(Object mutex, Throwables.BiPredicate<T,U,E> biPredicate)	Synchronized BiPredicate.
static <T, E extends Throwable> Throwables.Predicate<T,E>	sp(Object mutex, Throwables.Predicate<T,E> predicate)	Synchronized Predicate.
static <K, V, E extends Throwable> Throwables.Predicate<Map.Entry<K,V>,E>	testByKey(Throwables.Predicate<? super K,E> predicate)
static <K, V, E extends Throwable> Throwables.Predicate<Map.Entry<K,V>,E>	testByValue(Throwables.Predicate<? super V,E> predicate)
static <T> Throwables.Consumer<T,Exception>	throwException(String errorMessage)
static <T, E extends Exception> Throwables.Consumer<T,E>	throwException(Supplier<? extends E> excpetionSupplier)
static <T, E extends Exception> Throwables.BinaryOperator<T,E>	throwingMerger()
static <T> Throwables.Consumer<T,IOException>	throwIOException(String errorMessage)
static <T> Throwables.Consumer<T,RuntimeException>	throwRuntimeException(String errorMessage)
static <L, M, R, E extends Exception> Throwables.TriFunction<L,M,R,Triple<L,M,R>,E>	triple()
static <T, E extends Exception> Throwables.Function<T,Tuple.Tuple1<T>,E>	tuple1()
static <T, U, E extends Exception> Throwables.BiFunction<T,U,Tuple.Tuple2<T,U>,E>	tuple2()
static <A, B, C, E extends Exception> Throwables.TriFunction<A,B,C,Tuple.Tuple3<A,B,C>,E>	tuple3()
static <K, V, E extends Exception> Throwables.Function<Map.Entry<K,V>,V,E>	value()

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details

memoize

public static <T,
E extends Throwable>
Throwables.LazyInitializer<T,E> memoize(Throwables.Supplier<T,E> supplier)

Returns a Supplier which returns a single instance created by calling the specified supplier.get().

Type Parameters:

T -

E -

Parameters:

supplier -

Returns:

identity

public static <T,
E extends Exception>
Throwables.Function<T,T,E> identity()

Type Parameters:

T -

E -

Returns:

alwaysTrue

public static <T,
E extends Exception>
Throwables.Predicate<T,E> alwaysTrue()

Type Parameters:

T -

E -

Returns:

alwaysFalse

public static <T,
E extends Exception>
Throwables.Predicate<T,E> alwaysFalse()

Type Parameters:

T -

E -

Returns:

key

public static <K,
V,
E extends Exception>
Throwables.Function<Map.Entry<K,V>,K,E> key()

Type Parameters:

K -

V -

E -

Returns:

value

public static <K,
V,
E extends Exception>
Throwables.Function<Map.Entry<K,V>,V,E> value()

Type Parameters:

K -

V -

E -

Returns:

inverse

public static <K,
V,
E extends Exception>
Throwables.Function<Map.Entry<K,V>,Map.Entry<V,K>,E> inverse()

Type Parameters:

K -

V -

E -

Returns:

entry

public static <K,
V,
E extends Exception>
Throwables.BiFunction<K,V,Map.Entry<K,V>,E> entry()

Type Parameters:

K -

V -

E -

Returns:

pair

public static <L,
R,
E extends Exception>
Throwables.BiFunction<L,R,Pair<L,R>,E> pair()

Type Parameters:

L -

R -

E -

Returns:

triple

public static <L,
M,
R,
E extends Exception>
Throwables.TriFunction<L,M,R,Triple<L,M,R>,E> triple()

Type Parameters:

L -

M -

R -

E -

Returns:

tuple1

public static <T,
E extends Exception>
Throwables.Function<T,Tuple.Tuple1<T>,E> tuple1()

Type Parameters:

T -

E -

Returns:

tuple2

public static <T,
U,
E extends Exception>
Throwables.BiFunction<T,U,Tuple.Tuple2<T,U>,E> tuple2()

Type Parameters:

T -

U -

E -

Returns:

tuple3

public static <A,
B,
C,
E extends Exception>
Throwables.TriFunction<A,B,C,Tuple.Tuple3<A,B,C>,E> tuple3()

Type Parameters:

A -

B -

C -

E -

Returns:

emptyAction

public static <E extends Exception>
Throwables.Runnable<E> emptyAction()

Type Parameters:

E -

Returns:

doNothing

public static <T,
E extends Exception>
Throwables.Consumer<T,E> doNothing()

Type Parameters:

T -

E -

Returns:

throwRuntimeException

public static <T>
Throwables.Consumer<T,RuntimeException> throwRuntimeException(String errorMessage)

Type Parameters:

T -

Parameters:

errorMessage -

Returns:

throwIOException

public static <T>
Throwables.Consumer<T,IOException> throwIOException(String errorMessage)

Type Parameters:

T -

Parameters:

errorMessage -

Returns:

throwException

public static <T> Throwables.Consumer<T,Exception> throwException(String errorMessage)

Type Parameters:

T -

Parameters:

errorMessage -

Returns:

throwException

public static <T,
E extends Exception>
Throwables.Consumer<T,E> throwException(Supplier<? extends E> excpetionSupplier)

Type Parameters:

T -

E -

Parameters:

excpetionSupplier -

Returns:

sleep

public static <T,
E extends Exception>
Throwables.Consumer<T,E> sleep(long millis)

Type Parameters:

T -

E -

Parameters:

millis -

Returns:

sleepUninterruptibly

public static <T,
E extends Exception>
Throwables.Consumer<T,E> sleepUninterruptibly(long millis)

Type Parameters:

T -

E -

Parameters:

millis -

Returns:

rateLimiter

@Stateful
public static <T,
E extends Exception>
Throwables.Consumer<T,E> rateLimiter(double permitsPerSecond)

Returns a stateful Consumer. Don't save or cache for reuse

Type Parameters:

T -

E -

Parameters:

permitsPerSecond -

Returns:

See Also:

• RateLimiter.acquire()
• RateLimiter.create(double)

rateLimiter

@Stateful
public static <T,
E extends Exception>
Throwables.Consumer<T,E> rateLimiter(RateLimiter rateLimiter)

Returns a stateful Consumer. Don't save or cache for reuse

Type Parameters:

T -

E -

Parameters:

rateLimiter -

Returns:

See Also:

• RateLimiter.acquire()

close

public static <T extends AutoCloseable>
Throwables.Consumer<T,Exception> close()

Type Parameters:

T -

Returns:

closeQuietly

public static <T extends AutoCloseable,
E extends Exception>
Throwables.Consumer<T,E> closeQuietly()

Type Parameters:

T -

E -

Returns:

println

public static <T,
E extends Exception>
Throwables.Consumer<T,E> println()

Type Parameters:

T -

E -

Returns:

println

public static <T,
U,
E extends Exception>
Throwables.BiConsumer<T,U,E> println(String separator)

Type Parameters:

T -

U -

E -

Parameters:

separator -

Returns:

notNull

@Beta
public static <T,
E extends Exception>
Throwables.Predicate<T,E> notNull()

Type Parameters:

T -

E -

Returns:

notNullOrEmpty

public static <T extends CharSequence,
E extends Exception>
Throwables.Predicate<T,E> notNullOrEmpty()

Type Parameters:

T -

E -

Returns:

notNullOrEmptyA

@Beta
public static <T,
E extends Exception>
Throwables.Predicate<T[],E> notNullOrEmptyA()

Type Parameters:

T -

E -

Returns:

notNullOrEmptyC

@Beta
public static <T extends Collection,
E extends Exception>
Throwables.Predicate<T,E> notNullOrEmptyC()

Type Parameters:

T -

E -

Returns:

notNullOrEmptyM

@Beta
public static <T extends Map,
E extends Exception>
Throwables.Predicate<T,E> notNullOrEmptyM()

Type Parameters:

T -

E -

Returns:

isNull

@Beta
public static <T,
E extends Exception>
Throwables.Predicate<T,E> isNull()

Type Parameters:

T -

E -

Returns:

isNullOrEmpty

public static <T extends CharSequence,
E extends Exception>
Throwables.Predicate<T,E> isNullOrEmpty()

Type Parameters:

T -

E -

Returns:

isNullOrEmptyA

@Beta
public static <T,
E extends Exception>
Throwables.Predicate<T[],E> isNullOrEmptyA()

Type Parameters:

T -

E -

Returns:

isNullOrEmptyC

@Beta
public static <T extends Collection,
E extends Exception>
Throwables.Predicate<T,E> isNullOrEmptyC()

Type Parameters:

T -

E -

Returns:

isNullOrEmptyM

@Beta
public static <T extends Map,
E extends Exception>
Throwables.Predicate<T,E> isNullOrEmptyM()

Type Parameters:

T -

E -

Returns:

throwingMerger

public static <T,
E extends Exception>
Throwables.BinaryOperator<T,E> throwingMerger()

Type Parameters:

T -

E -

Returns:

ignoringMerger

public static <T,
E extends Exception>
Throwables.BinaryOperator<T,E> ignoringMerger()

Type Parameters:

T -

E -

Returns:

replacingMerger

public static <T,
E extends Exception>
Throwables.BinaryOperator<T,E> replacingMerger()

Type Parameters:

T -

E -

Returns:

testByKey

public static <K,
V,
E extends Throwable>
Throwables.Predicate<Map.Entry<K,V>,E> testByKey(Throwables.Predicate<? super K,E> predicate)

Type Parameters:

K -

V -

E -

Parameters:

predicate -

Returns:

testByValue

public static <K,
V,
E extends Throwable>
Throwables.Predicate<Map.Entry<K,V>,E> testByValue(Throwables.Predicate<? super V,E> predicate)

Type Parameters:

K -

V -

E -

Parameters:

predicate -

Returns:

acceptByKey

public static <K,
V,
E extends Throwable>
Throwables.Consumer<Map.Entry<K,V>,E> acceptByKey(Throwables.Consumer<? super K,E> consumer)

Type Parameters:

K -

V -

E -

Parameters:

consumer -

Returns:

acceptByValue

public static <K,
V,
E extends Throwable>
Throwables.Consumer<Map.Entry<K,V>,E> acceptByValue(Throwables.Consumer<? super V,E> consumer)

Type Parameters:

K -

V -

E -

Parameters:

consumer -

Returns:

applyByKey

public static <K,
V,
R,
E extends Throwable>
Throwables.Function<Map.Entry<K,V>,R,E> applyByKey(Throwables.Function<? super K,? extends R,E> func)

Type Parameters:

K -

V -

R -

E -

Parameters:

func -

Returns:

applyByValue

public static <K,
V,
R,
E extends Throwable>
Throwables.Function<Map.Entry<K,V>,R,E> applyByValue(Throwables.Function<? super V,? extends R,E> func)

Type Parameters:

K -

V -

R -

E -

Parameters:

func -

Returns:

selectFirst

public static <T,
E extends Throwable>
Throwables.BinaryOperator<T,E> selectFirst()

Type Parameters:

T -

E -

Returns:

selectSecond

public static <T,
E extends Throwable>
Throwables.BinaryOperator<T,E> selectSecond()

Type Parameters:

T -

E -

Returns:

min

public static <T extends Comparable<? super T>,
E extends Throwable>
Throwables.BinaryOperator<T,E> min()

Type Parameters:

T -

E -

Returns:

min

public static <T,
E extends Throwable>
Throwables.BinaryOperator<T,E> min(Comparator<? super T> comparator)

Type Parameters:

T -

E -

Parameters:

comparator -

Returns:

minBy

public static <T,
E extends Throwable>
Throwables.BinaryOperator<T,E> minBy(Function<? super T,? extends Comparable> keyMapper)

Type Parameters:

T -

E -

Parameters:

keyMapper -

Returns:

minByKey

public static <K extends Comparable<? super K>,
V,
E extends Throwable>
Throwables.BinaryOperator<Map.Entry<K,V>,E> minByKey()

Type Parameters:

K -

V -

E -

Returns:

minByValue

public static <K,
V extends Comparable<? super V>,
E extends Throwable>
Throwables.BinaryOperator<Map.Entry<K,V>,E> minByValue()

Type Parameters:

K -

V -

E -

Returns:

max

public static <T extends Comparable<? super T>,
E extends Throwable>
Throwables.BinaryOperator<T,E> max()

Type Parameters:

T -

E -

Returns:

max

public static <T,
E extends Throwable>
Throwables.BinaryOperator<T,E> max(Comparator<? super T> comparator)

Type Parameters:

T -

E -

Parameters:

comparator -

Returns:

maxBy

public static <T,
E extends Throwable>
Throwables.BinaryOperator<T,E> maxBy(Function<? super T,? extends Comparable> keyMapper)

Type Parameters:

T -

E -

Parameters:

keyMapper -

Returns:

maxByKey

public static <K extends Comparable<? super K>,
V,
E extends Throwable>
Throwables.BinaryOperator<Map.Entry<K,V>,E> maxByKey()

Type Parameters:

K -

V -

E -

Returns:

maxByValue

public static <K,
V extends Comparable<? super V>,
E extends Throwable>
Throwables.BinaryOperator<Map.Entry<K,V>,E> maxByValue()

Type Parameters:

K -

V -

E -

Returns:

not

public static <T,
E extends Throwable>
Throwables.Predicate<T,E> not(Throwables.Predicate<T,E> predicate)

Type Parameters:

T -

E -

Parameters:

predicate -

Returns:

not

public static <T,
U,
E extends Throwable>
Throwables.BiPredicate<T,U,E> not(Throwables.BiPredicate<T,U,E> biPredicate)

Type Parameters:

T -

U -

E -

Parameters:

biPredicate -

Returns:

not

public static <A,
B,
C,
E extends Throwable>
Throwables.TriPredicate<A,B,C,E> not(Throwables.TriPredicate<A,B,C,E> triPredicate)

Type Parameters:

A -

B -

C -

E -

Parameters:

triPredicate -

Returns:

from

@Beta
public static <T,
E extends Throwable>
Throwables.Supplier<T,E> from(Supplier<T> supplier)

Type Parameters:

T -

E -

Parameters:

supplier -

Returns:

from

@Beta
public static <T,
E extends Throwable>
Throwables.IntFunction<T,E> from(IntFunction<? extends T> func)

Type Parameters:

T -

E -

Parameters:

func -

Returns:

from

@Beta
public static <T,
E extends Throwable>
Throwables.Predicate<T,E> from(Predicate<T> predicate)

Type Parameters:

T -

E -

Parameters:

predicate -

Returns:

from

@Beta
public static <T,
U,
E extends Throwable>
Throwables.BiPredicate<T,U,E> from(BiPredicate<T,U> predicate)

Type Parameters:

T -

U -

E -

Parameters:

predicate -

Returns:

from

@Beta
public static <T,
E extends Throwable>
Throwables.Consumer<T,E> from(Consumer<T> consumer)

Type Parameters:

T -

E -

Parameters:

consumer -

Returns:

from

@Beta
public static <T,
U,
E extends Throwable>
Throwables.BiConsumer<T,U,E> from(BiConsumer<T,U> consumer)

Type Parameters:

T -

U -

E -

Parameters:

consumer -

Returns:

from

@Beta
public static <T,
R,
E extends Throwable>
Throwables.Function<T,R,E> from(Function<T,? extends R> function)

Type Parameters:

T -

R -

E -

Parameters:

function -

Returns:

from

@Beta
public static <T,
U,
R,
E extends Throwable>
Throwables.BiFunction<T,U,R,E> from(BiFunction<T,U,? extends R> function)

Type Parameters:

T -

U -

R -

E -

Parameters:

function -

Returns:

from

@Beta
public static <T,
E extends Throwable>
Throwables.UnaryOperator<T,E> from(UnaryOperator<T> op)

Type Parameters:

T -

E -

Parameters:

op -

Returns:

from

@Beta
public static <T,
E extends Throwable>
Throwables.BinaryOperator<T,E> from(BinaryOperator<T> op)

Type Parameters:

T -

E -

Parameters:

op -

Returns:

p

@Beta
public static <T,
E extends Throwable>
Throwables.Predicate<T,E> p(Throwables.Predicate<T,E> predicate)

Type Parameters:

T -

E -

Parameters:

predicate -

Returns:

p

@Beta
public static <A,
T,
E extends Throwable>
Throwables.Predicate<T,E> p(A a,
 Throwables.BiPredicate<A,T,E> biPredicate)

Type Parameters:

A -

T -

E -

Parameters:

a -

biPredicate -

Returns:

p

@Beta
public static <A,
B,
T,
E extends Throwable>
Throwables.Predicate<T,E> p(A a,
 B b,
 Throwables.TriPredicate<A,B,T,E> triPredicate)

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

triPredicate -

Returns:

p

@Beta
public static <T,
U,
E extends Throwable>
Throwables.BiPredicate<T,U,E> p(Throwables.BiPredicate<T,U,E> biPredicate)

Type Parameters:

T -

U -

E -

Parameters:

biPredicate -

Returns:

p

@Beta
public static <A,
T,
U,
E extends Throwable>
Throwables.BiPredicate<T,U,E> p(A a,
 Throwables.TriPredicate<A,T,U,E> triPredicate)

Type Parameters:

A -

T -

U -

E -

Parameters:

a -

triPredicate -

Returns:

p

@Beta
public static <A,
B,
C,
E extends Throwable>
Throwables.TriPredicate<A,B,C,E> p(Throwables.TriPredicate<A,B,C,E> triPredicate)

Type Parameters:

A -

B -

C -

E -

Parameters:

triPredicate -

Returns:

c

@Beta
public static <T,
E extends Throwable>
Throwables.Consumer<T,E> c(Throwables.Consumer<T,E> predicate)

Type Parameters:

T -

E -

Parameters:

predicate -

Returns:

c

@Beta
public static <A,
T,
E extends Throwable>
Throwables.Consumer<T,E> c(A a,
 Throwables.BiConsumer<A,T,E> biConsumer)

Type Parameters:

A -

T -

E -

Parameters:

a -

biConsumer -

Returns:

c

@Beta
public static <A,
B,
T,
E extends Throwable>
Throwables.Consumer<T,E> c(A a,
 B b,
 Throwables.TriConsumer<A,B,T,E> triConsumer)

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

triConsumer -

Returns:

c

@Beta
public static <T,
U,
E extends Throwable>
Throwables.BiConsumer<T,U,E> c(Throwables.BiConsumer<T,U,E> biConsumer)

Type Parameters:

T -

U -

E -

Parameters:

biConsumer -

Returns:

c

@Beta
public static <A,
T,
U,
E extends Throwable>
Throwables.BiConsumer<T,U,E> c(A a,
 Throwables.TriConsumer<A,T,U,E> triConsumer)

Type Parameters:

A -

T -

U -

E -

Parameters:

a -

triConsumer -

Returns:

c

@Beta
public static <A,
B,
C,
E extends Throwable>
Throwables.TriConsumer<A,B,C,E> c(Throwables.TriConsumer<A,B,C,E> triConsumer)

Type Parameters:

A -

B -

C -

E -

Parameters:

triConsumer -

Returns:

f

@Beta
public static <T,
R,
E extends Throwable>
Throwables.Function<T,R,E> f(Throwables.Function<T,R,E> predicate)

Type Parameters:

T -

R -

E -

Parameters:

predicate -

Returns:

f

@Beta
public static <A,
T,
R,
E extends Throwable>
Throwables.Function<T,R,E> f(A a,
 Throwables.BiFunction<A,T,R,E> biFunction)

Type Parameters:

A -

T -

R -

E -

Parameters:

a -

biFunction -

Returns:

f

@Beta
public static <A,
B,
T,
R,
E extends Throwable>
Throwables.Function<T,R,E> f(A a,
 B b,
 Throwables.TriFunction<A,B,T,R,E> triFunction)

Type Parameters:

A -

B -

T -

R -

E -

Parameters:

a -

b -

triFunction -

Returns:

f

@Beta
public static <T,
U,
R,
E extends Throwable>
Throwables.BiFunction<T,U,R,E> f(Throwables.BiFunction<T,U,R,E> biFunction)

Type Parameters:

T -

U -

R -

E -

Parameters:

biFunction -

Returns:

f

@Beta
public static <A,
T,
U,
R,
E extends Throwable>
Throwables.BiFunction<T,U,R,E> f(A a,
 Throwables.TriFunction<A,T,U,R,E> triFunction)

Type Parameters:

A -

T -

U -

R -

E -

Parameters:

a -

triFunction -

Returns:

f

@Beta
public static <A,
B,
C,
R,
E extends Throwable>
Throwables.TriFunction<A,B,C,R,E> f(Throwables.TriFunction<A,B,C,R,E> triFunction)

Type Parameters:

A -

B -

C -

R -

E -

Parameters:

triFunction -

Returns:

pp

@Beta
public static <T,
E extends Throwable>
Throwables.Predicate<T,E> pp(Predicate<T> predicate)

Type Parameters:

T -

E -

Parameters:

predicate -

Returns:

pp

@Beta
public static <A,
T,
E extends Throwable>
Throwables.Predicate<T,E> pp(A a,
 BiPredicate<A,T> biPredicate)

Type Parameters:

A -

T -

E -

Parameters:

a -

biPredicate -

Returns:

pp

@Beta
public static <A,
B,
T,
E extends Throwable>
Throwables.Predicate<T,E> pp(A a,
 B b,
 TriPredicate<A,B,T> triPredicate)

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

triPredicate -

Returns:

pp

@Beta
public static <T,
U,
E extends Throwable>
Throwables.BiPredicate<T,U,E> pp(BiPredicate<T,U> biPredicate)

Type Parameters:

T -

U -

E -

Parameters:

biPredicate -

Returns:

pp

@Beta
public static <A,
T,
U,
E extends Throwable>
Throwables.BiPredicate<T,U,E> pp(A a,
 TriPredicate<A,T,U> triPredicate)

Type Parameters:

A -

T -

U -

E -

Parameters:

a -

triPredicate -

Returns:

pp

@Beta
public static <A,
B,
C,
E extends Throwable>
Throwables.TriPredicate<A,B,C,E> pp(TriPredicate<A,B,C> triPredicate)

Type Parameters:

A -

B -

C -

E -

Parameters:

triPredicate -

Returns:

cc

@Beta
public static <T,
E extends Throwable>
Throwables.Consumer<T,E> cc(Consumer<T> consumer)

Type Parameters:

T -

E -

Parameters:

consumer -

Returns:

cc

@Beta
public static <A,
T,
E extends Throwable>
Throwables.Consumer<T,E> cc(A a,
 BiConsumer<A,T> biConsumer)

Type Parameters:

A -

T -

E -

Parameters:

a -

biConsumer -

Returns:

cc

@Beta
public static <A,
B,
T,
E extends Throwable>
Throwables.Consumer<T,E> cc(A a,
 B b,
 TriConsumer<A,B,T> triConsumer)

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

triConsumer -

Returns:

cc

@Beta
public static <T,
U,
E extends Throwable>
Throwables.BiConsumer<T,U,E> cc(BiConsumer<T,U> biConsumer)

Type Parameters:

T -

U -

E -

Parameters:

biConsumer -

Returns:

cc

@Beta
public static <A,
T,
U,
E extends Throwable>
Throwables.BiConsumer<T,U,E> cc(A a,
 TriConsumer<A,T,U> triConsumer)

Type Parameters:

A -

T -

U -

E -

Parameters:

a -

triConsumer -

Returns:

cc

@Beta
public static <A,
B,
C,
E extends Throwable>
Throwables.TriConsumer<A,B,C,E> cc(TriConsumer<A,B,C> triConsumer)

Type Parameters:

A -

B -

C -

E -

Parameters:

triConsumer -

Returns:

ff

@Beta
public static <T,
R,
E extends Throwable>
Throwables.Function<T,R,E> ff(Function<T,? extends R> function)

Type Parameters:

T -

R -

E -

Parameters:

function -

Returns:

ff

@Beta
public static <A,
T,
R,
E extends Throwable>
Throwables.Function<T,R,E> ff(A a,
 BiFunction<A,T,R> biFunction)

Type Parameters:

A -

T -

R -

E -

Parameters:

a -

biFunction -

Returns:

ff

@Beta
public static <A,
B,
T,
R,
E extends Throwable>
Throwables.Function<T,R,E> ff(A a,
 B b,
 TriFunction<A,B,T,R> triFunction)

Type Parameters:

A -

B -

T -

R -

E -

Parameters:

a -

b -

triFunction -

Returns:

ff

@Beta
public static <T,
U,
R,
E extends Throwable>
Throwables.BiFunction<T,U,R,E> ff(BiFunction<T,U,R> biFunction)

Type Parameters:

T -

U -

R -

E -

Parameters:

biFunction -

Returns:

ff

@Beta
public static <A,
T,
U,
R,
E extends Throwable>
Throwables.BiFunction<T,U,R,E> ff(A a,
 TriFunction<A,T,U,R> triFunction)

Type Parameters:

A -

T -

U -

R -

E -

Parameters:

a -

triFunction -

Returns:

ff

@Beta
public static <A,
B,
C,
R,
E extends Throwable>
Throwables.TriFunction<A,B,C,R,E> ff(TriFunction<A,B,C,R> triFunction)

Type Parameters:

A -

B -

C -

R -

E -

Parameters:

triFunction -

Returns:

sp

@Beta
public static <T,
E extends Throwable>
Throwables.Predicate<T,E> sp(Object mutex,
 Throwables.Predicate<T,E> predicate)

Synchronized Predicate.

Type Parameters:

T -

E -

Parameters:

mutex - to synchronized on

predicate -

Returns:

sp

@Beta
public static <A,
T,
E extends Throwable>
Throwables.Predicate<T,E> sp(Object mutex,
 A a,
 Throwables.BiPredicate<A,T,E> biPredicate)

Synchronized Predicate.

Type Parameters:

A -

T -

E -

Parameters:

mutex - to synchronized on

a -

biPredicate -

Returns:

sp

@Beta
public static <A,
B,
T,
E extends Throwable>
Throwables.Predicate<T,E> sp(Object mutex,
 A a,
 B b,
 Throwables.TriPredicate<A,B,T,E> triPredicate)

Synchronized Predicate.

Type Parameters:

A -

B -

T -

E -

Parameters:

mutex - to synchronized on

a -

b -

triPredicate -

Returns:

sp

@Beta
public static <T,
U,
E extends Throwable>
Throwables.BiPredicate<T,U,E> sp(Object mutex,
 Throwables.BiPredicate<T,U,E> biPredicate)

Synchronized BiPredicate.

Type Parameters:

T -

U -

E -

Parameters:

mutex - to synchronized on

biPredicate -

Returns:

sc

@Beta
public static <T,
E extends Throwable>
Throwables.Consumer<T,E> sc(Object mutex,
 Throwables.Consumer<T,E> consumer)

Synchronized Consumer.

Type Parameters:

T -

E -

Parameters:

mutex - to synchronized on

consumer -

Returns:

sc

@Beta
public static <A,
T,
E extends Throwable>
Throwables.Consumer<T,E> sc(Object mutex,
 A a,
 Throwables.BiConsumer<A,T,E> biConsumer)

Synchronized Consumer.

Type Parameters:

A -

T -

E -

Parameters:

mutex - to synchronized on

a -

biConsumer -

Returns:

sc

@Beta
public static <T,
U,
E extends Throwable>
Throwables.BiConsumer<T,U,E> sc(Object mutex,
 Throwables.BiConsumer<T,U,E> biConsumer)

Synchronized BiConsumer.

Type Parameters:

T -

U -

E -

Parameters:

mutex - to synchronized on

biConsumer -

Returns:

sf

@Beta
public static <T,
R,
E extends Throwable>
Throwables.Function<T,R,E> sf(Object mutex,
 Throwables.Function<T,? extends R,E> function)

Synchronized Function.

Type Parameters:

T -

R -

E -

Parameters:

mutex - to synchronized on

function -

Returns:

sf

@Beta
public static <A,
T,
R,
E extends Throwable>
Throwables.Function<T,R,E> sf(Object mutex,
 A a,
 Throwables.BiFunction<A,T,R,E> biFunction)

Synchronized Function.

Type Parameters:

A -

T -

R -

E -

Parameters:

mutex - to synchronized on

a -

biFunction -

Returns:

sf

@Beta
public static <T,
U,
R,
E extends Throwable>
Throwables.BiFunction<T,U,R,E> sf(Object mutex,
 Throwables.BiFunction<T,U,R,E> biFunction)

Synchronized BiFunction.

Type Parameters:

T -

U -

R -

E -

Parameters:

mutex - to synchronized on

biFunction -

Returns:

c2f

public static <T,
E extends Throwable>
Throwables.Function<T,Void,E> c2f(Throwables.Consumer<T,E> consumer)

Type Parameters:

T -

E -

Parameters:

consumer -

Returns:

c2f

public static <T,
R,
E extends Throwable>
Throwables.Function<T,R,E> c2f(Throwables.Consumer<T,E> consumer,
 R valueToReturn)

Type Parameters:

T -

R -

E -

Parameters:

consumer -

valueToReturn -

Returns:

c2f

public static <T,
U,
E extends Throwable>
Throwables.BiFunction<T,U,Void,E> c2f(Throwables.BiConsumer<T,U,E> biConsumer)

Type Parameters:

T -

U -

E -

Parameters:

biConsumer -

Returns:

c2f

public static <T,
U,
R,
E extends Throwable>
Throwables.BiFunction<T,U,R,E> c2f(Throwables.BiConsumer<T,U,E> biConsumer,
 R valueToReturn)

Type Parameters:

T -

U -

R -

E -

Parameters:

biConsumer -

valueToReturn -

Returns:

c2f

public static <A,
B,
C,
E extends Throwable>
Throwables.TriFunction<A,B,C,Void,E> c2f(Throwables.TriConsumer<A,B,C,E> triConsumer)

Type Parameters:

A -

B -

C -

E -

Parameters:

triConsumer -

Returns:

c2f

public static <A,
B,
C,
R,
E extends Throwable>
Throwables.TriFunction<A,B,C,R,E> c2f(Throwables.TriConsumer<A,B,C,E> triConsumer,
 R valueToReturn)

Type Parameters:

A -

B -

C -

R -

E -

Parameters:

triConsumer -

valueToReturn -

Returns:

f2c

public static <T,
R,
E extends Throwable>
Throwables.Consumer<T,E> f2c(Throwables.Function<T,? extends R,E> func)

Type Parameters:

T -

R -

E -

Parameters:

func -

Returns:

f2c

public static <T,
U,
R,
E extends Throwable>
Throwables.BiConsumer<T,U,E> f2c(Throwables.BiFunction<T,U,? extends R,E> func)

Type Parameters:

T -

U -

R -

E -

Parameters:

func -

Returns:

f2c

public static <A,
B,
C,
R,
E extends Throwable>
Throwables.TriConsumer<A,B,C,E> f2c(Throwables.TriFunction<A,B,C,? extends R,E> func)

Type Parameters:

A -

B -

C -

R -

E -

Parameters:

func -

Returns:

r2c

public static <E extends Throwable>
Throwables.Callable<Void,E> r2c(Throwables.Runnable<E> runnable)

Type Parameters:

E -

Parameters:

runnable -

Returns:

r2c

public static <R,
E extends Throwable>
Throwables.Callable<R,E> r2c(Throwables.Runnable<E> runnable,
 R valueToReturn)

Type Parameters:

R -

E -

Parameters:

runnable -

valueToReturn -

Returns:

c2r

public static <R,
E extends Throwable>
Throwables.Runnable<E> c2r(Throwables.Callable<R,E> callable)

Type Parameters:

R -

E -

Parameters:

callable -

Returns:

rr

public static <E extends Throwable>
Throwables.Runnable<E> rr(Runnable runnable)

Type Parameters:

E -

Parameters:

runnable -

Returns:

cc

public static <R,
E extends Throwable>
Throwables.Callable<R,E> cc(Callable<R> callable)

Type Parameters:

R -

E -

Parameters:

callable -

Returns:

r

public static <E extends Throwable>
Throwables.Runnable<E> r(Throwables.Runnable<E> runnable)

Type Parameters:

E -

Parameters:

runnable -

Returns:

c

public static <R,
E extends Throwable>
Throwables.Callable<R,E> c(Throwables.Callable<R,E> callable)

Type Parameters:

R -

E -

Parameters:

callable -

Returns:

jr2r

public static <E extends Throwable>
Throwables.Runnable<E> jr2r(Runnable runnable)

Type Parameters:

E -

Parameters:

runnable -

Returns:

r2jr

public static <E extends Throwable> Runnable r2jr(Throwables.Runnable<E> runnable)

Type Parameters:

E -

Parameters:

runnable -

Returns:

jc2c

public static <R> Throwables.Callable<R,Exception> jc2c(Callable<R> callable)

Type Parameters:

R -

Parameters:

callable -

Returns:

c2jc

public static <R> Callable<R> c2jc(Throwables.Callable<R,? extends Exception> callable)

Type Parameters:

R -

Parameters:

callable -

Returns: