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 and 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,R,E> func)
static <K,V,R,E extends Throwable> Throwables.Function<Map.Entry<K,V>,R,E>	applyByValue(Throwables.Function<? super V,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,E extends Exception> Callable<R>	c2jc(Throwables.Callable<R,E> callable)
static <R,E extends Throwable> Throwables.Runnable<E>	c2r(Throwables.Callable<R,E> callable)
static <R,E extends Throwable> Throwables.Callable<R,E>	callable(Throwables.Callable<R,E> callable) Deprecated. replaced by c(com.landawn.abacus.util.Throwables.Callable)
static <A,T,E extends Throwable> Throwables.Consumer<T,E>	cc(A a, BiConsumer<A,T> biConsumer)
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 <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,R,E> func)
static <T,R,E extends Throwable> Throwables.Consumer<T,E>	f2c(Throwables.Function<T,R,E> func)
static <A,B,C,R,E extends Throwable> Throwables.TriConsumer<A,B,C,E>	f2c(Throwables.TriFunction<A,B,C,R,E> func)
static <A,T,R,E extends Throwable> Throwables.Function<T,R,E>	ff(A a, BiFunction<A,T,R> biFunction)
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 <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,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,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,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,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,T,E extends Throwable> Throwables.Predicate<T,E>	pp(A a, BiPredicate<A,T> biPredicate)
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 <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.BinaryOperator<T,E>	replacingMerger()
static <E extends Throwable> Throwables.Runnable<E>	rr(Runnable runnable)
static <E extends Throwable> Throwables.Runnable<E>	runnable(Throwables.Runnable<E> runnable) Deprecated. replaced by r(com.landawn.abacus.util.Throwables.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 <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,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 Detail

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 -

Parameters:

supplier -

Returns:

identity

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

alwaysTrue

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

alwaysFalse

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

key

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

value

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

inverse

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

entry

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

pair

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

triple

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

tuple1

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

tuple2

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

tuple3

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

emptyAction

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

doNothing

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

throwRuntimeException

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

throwIOException

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

throwException

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

throwException

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

sleep

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

sleepUninterruptibly

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

close

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

closeQuietly

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

println

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

println

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

notNull

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

notNullOrEmpty

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

notNullOrEmptyA

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

notNullOrEmptyC

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

notNullOrEmptyM

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

isNull

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

isNullOrEmpty

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

isNullOrEmptyA

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

isNullOrEmptyC

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

isNullOrEmptyM

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

throwingMerger

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

ignoringMerger

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

replacingMerger

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

testByKey

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

testByValue

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

acceptByKey

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

acceptByValue

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

applyByKey

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

applyByValue

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

not

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

not

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

not

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

p

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

p

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

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)

p

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

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)

p

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

c

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

c

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

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)

c

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

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)

c

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

f

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

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)

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)

f

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

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)

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)

pp

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

pp

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

pp

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

pp

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

pp

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

pp

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

cc

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

cc

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

cc

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

cc

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

cc

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

cc

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

ff

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

ff

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

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)

ff

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

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)

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)

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 -

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,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)

c2f

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

c2f

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

c2f

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

c2f

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

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)

f2c

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

f2c

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

f2c

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

r2c

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

r2c

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

c2r

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

rr

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

cc

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

r

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

c

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

jr2r

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

r2jr

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

jc2c

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

c2jc

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

runnable

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

Deprecated. replaced by r(com.landawn.abacus.util.Throwables.Runnable)

Type Parameters:

E -

Parameters:

runnable -

Returns:

callable

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

Deprecated. replaced by c(com.landawn.abacus.util.Throwables.Callable)

Type Parameters:

R -

E -

Parameters:

callable -

Returns: