Uses of Interface
com.landawn.abacus.util.Throwables.Consumer

Packages that use Throwables.Consumer

Package	Description
com.landawn.abacus.util
com.landawn.abacus.util.function
com.landawn.abacus.util.stream

Uses of Throwables.Consumer in com.landawn.abacus.util

Classes in com.landawn.abacus.util that implement Throwables.Consumer

Modifier and Type	Class	Description
class	BigDecimalSummaryStatistics
class	BigIntegerSummaryStatistics

Methods in com.landawn.abacus.util that return Throwables.Consumer

Modifier and Type	Method	Description
static <K, V, E extends Throwable> Throwables.Consumer<Map.Entry<K,V>,E>	Fn.Fnn.acceptByKey(Throwables.Consumer<? super K,E> consumer)
static <K, V, E extends Throwable> Throwables.Consumer<Map.Entry<K,V>,E>	Fn.Fnn.acceptByValue(Throwables.Consumer<? super V,E> consumer)
static <A, B, T, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.c(A a, B b, Throwables.TriConsumer<A,B,T,E> triConsumer)
static <A, T, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.c(A a, Throwables.BiConsumer<A,T,E> biConsumer)
static <T, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.c(Throwables.Consumer<T,E> predicate)
static <A, B, T, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.cc(A a, B b, TriConsumer<A,B,T> triConsumer)
static <A, T, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.cc(A a, BiConsumer<A,T> biConsumer)
static <T, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.cc(Consumer<T> consumer)
static <T extends AutoCloseable> Throwables.Consumer<T,Exception>	Fn.Fnn.close()
static <T extends AutoCloseable, E extends Exception> Throwables.Consumer<T,E>	Fn.Fnn.closeQuietly()
static <T, E extends Exception> Throwables.Consumer<T,E>	Fn.Fnn.doNothing()
static <K, V, E extends Exception> Throwables.Consumer<Map.Entry<K,V>,E>	Fn.Entries.ec(Throwables.BiConsumer<? super K,? super V,E> c)
static <T, R, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.f2c(Throwables.Function<T,? extends R,E> func)
static <T, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.from(Consumer<T> consumer)
static <T, E extends Exception> Throwables.Consumer<T,E>	Fn.Fnn.println()
static <T, E extends Exception> Throwables.Consumer<T,E>	Fn.Fnn.rateLimiter(double permitsPerSecond)	Returns a stateful Consumer.
static <T, E extends Exception> Throwables.Consumer<T,E>	Fn.Fnn.rateLimiter(RateLimiter rateLimiter)	Returns a stateful Consumer.
static <A, T, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.sc(Object mutex, A a, Throwables.BiConsumer<A,T,E> biConsumer)	Synchronized Consumer.
static <T, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.sc(Object mutex, Throwables.Consumer<T,E> consumer)	Synchronized Consumer.
static <T, E extends Exception> Throwables.Consumer<T,E>	Fn.Fnn.sleep(long millis)
static <T, E extends Exception> Throwables.Consumer<T,E>	Fn.Fnn.sleepUninterruptibly(long millis)
static <T> Throwables.Consumer<T,Exception>	Fn.Fnn.throwException(String errorMessage)
static <T, E extends Exception> Throwables.Consumer<T,E>	Fn.Fnn.throwException(Supplier<? extends E> excpetionSupplier)
static <T> Throwables.Consumer<T,IOException>	Fn.Fnn.throwIOException(String errorMessage)
static <T> Throwables.Consumer<T,RuntimeException>	Fn.Fnn.throwRuntimeException(String errorMessage)

Methods in com.landawn.abacus.util with parameters of type Throwables.Consumer

Modifier and Type	Method	Description
<E extends Exception> void	BooleanList.accept(Throwables.Consumer<? super BooleanList,E> action)
<E extends Exception> Builder<T>	Builder.accept(Throwables.Consumer<? super T,E> consumer)
<E extends Exception> void	ByteList.accept(Throwables.Consumer<? super ByteList,E> action)
<E extends Exception> void	CharList.accept(Throwables.Consumer<? super CharList,E> action)
<E extends Exception> void	DataSet.accept(Throwables.Consumer<? super DataSet,E> action)
<E extends Exception> void	DoubleList.accept(Throwables.Consumer<? super DoubleList,E> action)
<E extends Exception> void	FloatList.accept(Throwables.Consumer<? super FloatList,E> action)
<E extends Exception> void	Holder.accept(Throwables.Consumer<? super T,E> action)
<E extends Exception> void	IntList.accept(Throwables.Consumer<? super IntList,E> action)
<E extends Exception> void	LongList.accept(Throwables.Consumer<? super LongList,E> action)
<E extends Exception> void	LongMultiset.accept(Throwables.Consumer<? super LongMultiset<T>,E> action)
<X extends Exception> void	Multimap.accept(Throwables.Consumer<? super Multimap<K,E,V>,X> action)
<E extends Exception> void	Multiset.accept(Throwables.Consumer<? super Multiset<T>,E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableArray.accept(Throwables.Consumer<? super T[],E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableBooleanArray.accept(Throwables.Consumer<? super boolean[],E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableByteArray.accept(Throwables.Consumer<? super byte[],E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableCharArray.accept(Throwables.Consumer<? super char[],E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableDeque.accept(Throwables.Consumer<? super Deque<T>,E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableDoubleArray.accept(Throwables.Consumer<? super double[],E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableEntry.accept(Throwables.Consumer<? super NoCachingNoUpdating.DisposableEntry<K,V>,E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableFloatArray.accept(Throwables.Consumer<? super float[],E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableIntArray.accept(Throwables.Consumer<? super int[],E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableLongArray.accept(Throwables.Consumer<? super long[],E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableShortArray.accept(Throwables.Consumer<? super short[],E> action)
<E extends Exception> void	Pair.accept(Throwables.Consumer<? super Pair<L,R>,E> action)
abstract <E extends Exception> void	PrimitiveList.accept(Throwables.Consumer<? super L,E> action)
<E extends Exception> void	RowDataSet.accept(Throwables.Consumer<? super DataSet,E> action)
<X extends Exception> void	Sheet.accept(Throwables.Consumer<? super Sheet<R,C,E>,X> action)
<E extends Exception> void	ShortList.accept(Throwables.Consumer<? super ShortList,E> action)
<E extends Throwable> void	Synchronized.accept(Throwables.Consumer<? super T,E> consumer)
static <T, E extends Throwable> void	Synchronized.accept(T mutex, Throwables.Consumer<? super T,E> consumer)
<E extends Exception> void	Triple.accept(Throwables.Consumer<? super Triple<L,M,R>,E> action)
<E extends Exception> void	Tuple.accept(Throwables.Consumer<? super TP,E> action)
static <K, V, E extends Throwable> Throwables.Consumer<Map.Entry<K,V>,E>	Fn.Fnn.acceptByKey(Throwables.Consumer<? super K,E> consumer)
static <K, V, E extends Throwable> Throwables.Consumer<Map.Entry<K,V>,E>	Fn.Fnn.acceptByValue(Throwables.Consumer<? super V,E> consumer)
<E extends Exception> If.OrElse	BooleanList.acceptIfNotEmpty(Throwables.Consumer<? super BooleanList,E> action)	Accept if not empty.
<E extends Exception> If.OrElse	ByteList.acceptIfNotEmpty(Throwables.Consumer<? super ByteList,E> action)	Accept if not empty.
<E extends Exception> If.OrElse	CharList.acceptIfNotEmpty(Throwables.Consumer<? super CharList,E> action)	Accept if not empty.
<E extends Exception> If.OrElse	DoubleList.acceptIfNotEmpty(Throwables.Consumer<? super DoubleList,E> action)	Accept if not empty.
<E2 extends Exception> If.OrElse	ExceptionalStream.acceptIfNotEmpty(Throwables.Consumer<? super ExceptionalStream<T,E>,E2> action)
<E extends Exception> If.OrElse	FloatList.acceptIfNotEmpty(Throwables.Consumer<? super FloatList,E> action)	Accept if not empty.
<E extends Exception> If.OrElse	IntList.acceptIfNotEmpty(Throwables.Consumer<? super IntList,E> action)	Accept if not empty.
<E extends Exception> If.OrElse	LongList.acceptIfNotEmpty(Throwables.Consumer<? super LongList,E> action)	Accept if not empty.
<E extends Exception> If.OrElse	LongMultiset.acceptIfNotEmpty(Throwables.Consumer<? super LongMultiset<T>,E> action)	Accept if not empty.
<X extends Exception> If.OrElse	Multimap.acceptIfNotEmpty(Throwables.Consumer<? super Multimap<K,E,V>,X> action)	Accept if not empty.
<E extends Exception> If.OrElse	Multiset.acceptIfNotEmpty(Throwables.Consumer<? super Multiset<T>,E> action)	Accept if not empty.
abstract <E extends Exception> If.OrElse	PrimitiveList.acceptIfNotEmpty(Throwables.Consumer<? super L,E> action)	Accept if not empty.
<E extends Exception> If.OrElse	ShortList.acceptIfNotEmpty(Throwables.Consumer<? super ShortList,E> action)	Accept if not empty.
<E extends Exception> void	Holder.acceptIfNotNull(Throwables.Consumer<? super T,E> action)	Deprecated. replaced by Holder.ifNotNull(com.landawn.abacus.util.Throwables.Consumer)
ContinuableFuture<Void>	ExceptionalStream.asyncRun(Throwables.Consumer<? super ExceptionalStream<T,E>,? extends Exception> terminalAction)
ContinuableFuture<Void>	ExceptionalStream.asyncRun(Throwables.Consumer<? super ExceptionalStream<T,E>,? extends Exception> terminalAction, Executor executor)
static <T, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.c(Throwables.Consumer<T,E> predicate)
static <T, E extends Throwable> Throwables.Function<T,Void,E>	Fn.Fnn.c2f(Throwables.Consumer<T,E> consumer)
static <T, R, E extends Throwable> Throwables.Function<T,R,E>	Fn.Fnn.c2f(Throwables.Consumer<T,E> consumer, R valueToReturn)
static <T, E extends Exception> Consumer<T>	Fn.cc(Throwables.Consumer<T,E> consumer)
ExceptionalStream<T,E>	ExceptionalStream.dropWhile(Throwables.Predicate<? super T,? extends E> predicate, Throwables.Consumer<? super T,? extends E> actionOnDroppedItem)
ExceptionalStream<T,E>	ExceptionalStream.filter(Throwables.Predicate<? super T,? extends E> predicate, Throwables.Consumer<? super T,? extends E> actionOnDroppedItem)
<X extends Exception> void	Multimap.flatForEachValue(Throwables.Consumer<? super E,X> action)	Flat for each value.
<E extends Exception> void	DataSet.forEach(int fromRowIndex, int toRowIndex, Throwables.Consumer<? super NoCachingNoUpdating.DisposableObjArray,E> action)	Performs the given action for each row of the DataSet until all rows have been processed or the action throws an exception.
<E extends Exception> void	DataSet.forEach(Throwables.Consumer<? super NoCachingNoUpdating.DisposableObjArray,E> action)	Performs the given action for each row of the DataSet until all rows have been processed or the action throws an exception.
<E extends Exception> void	DataSet.forEach(Collection<String> columnNames, int fromRowIndex, int toRowIndex, Throwables.Consumer<? super NoCachingNoUpdating.DisposableObjArray,E> action)	Performs the given action for each row of the DataSet until all rows have been processed or the action throws an exception.
<E extends Exception> void	DataSet.forEach(Collection<String> columnNames, Throwables.Consumer<? super NoCachingNoUpdating.DisposableObjArray,E> action)	Performs the given action for each row of the DataSet until all rows have been processed or the action throws an exception.
<E2 extends Exception> void	ExceptionalStream.forEach(Throwables.Consumer<? super T,E2> action)
<E2 extends Exception, E3 extends Exception> void	ExceptionalStream.forEach(Throwables.Consumer<? super T,E2> action, Throwables.Runnable<E3> onComplete)
<E extends Exception> void	ImmutableArray.forEach(Throwables.Consumer<T,E> consumer)
static <T, E extends Exception> void	Iterators.forEach(Collection<? extends Iterator<? extends T>> iterators, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<? super T,E> elementParser)
static <T, E extends Exception, E2 extends Exception> void	Iterators.forEach(Collection<? extends Iterator<? extends T>> iterators, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<? super T,E> elementParser, Throwables.Runnable<E2> onComplete)
static <T, E extends Exception> void	Iterators.forEach(Collection<? extends Iterator<? extends T>> iterators, long offset, long count, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<? super T,E> elementParser)
static <T, E extends Exception, E2 extends Exception> void	Iterators.forEach(Collection<? extends Iterator<? extends T>> iterators, long offset, long count, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<? super T,E> elementParser, Throwables.Runnable<E2> onComplete)	Parse the elements in the specified iterators one by one.
static <T, E extends Exception> void	Iterators.forEach(Collection<? extends Iterator<? extends T>> iterators, long offset, long count, Throwables.Consumer<? super T,E> elementParser)
static <T, E extends Exception, E2 extends Exception> void	Iterators.forEach(Collection<? extends Iterator<? extends T>> iterators, long offset, long count, Throwables.Consumer<? super T,E> elementParser, Throwables.Runnable<E2> onComplete)
static <T, E extends Exception> void	Iterators.forEach(Collection<? extends Iterator<? extends T>> iterators, Throwables.Consumer<? super T,E> elementParser)
static <T, E extends Exception, E2 extends Exception> void	Iterators.forEach(Collection<? extends Iterator<? extends T>> iterators, Throwables.Consumer<? super T,E> elementParser, Throwables.Runnable<E2> onComplete)
static <T, E extends Exception> void	Iterators.forEach(Iterator<? extends T> iter, long offset, long count, int processThreadNum, int queueSize, Throwables.Consumer<? super T,E> elementParser)
static <T, E extends Exception, E2 extends Exception> void	Iterators.forEach(Iterator<? extends T> iter, long offset, long count, int processThreadNum, int queueSize, Throwables.Consumer<? super T,E> elementParser, Throwables.Runnable<E2> onComplete)	Parse the elements in the specified iterators one by one.
static <T, E extends Exception> void	Iterators.forEach(Iterator<? extends T> iter, long offset, long count, Throwables.Consumer<? super T,E> elementParser)
static <T, E extends Exception, E2 extends Exception> void	Iterators.forEach(Iterator<? extends T> iter, long offset, long count, Throwables.Consumer<? super T,E> elementParser, Throwables.Runnable<E2> onComplete)
static <T, E extends Exception> void	Iterators.forEach(Iterator<? extends T> iter, Throwables.Consumer<? super T,E> elementParser)
static <T, E extends Exception, E2 extends Exception> void	Iterators.forEach(Iterator<? extends T> iter, Throwables.Consumer<? super T,E> elementParser, Throwables.Runnable<E2> onComplete)
<E extends Exception> void	LongMultiset.forEach(Throwables.Consumer<? super T,E> action)
static <K, V, E extends Exception> void	Maps.forEach(Map<K,V> map, Throwables.Consumer<? super Map.Entry<K,V>,E> action)
<E extends Exception> void	Multiset.forEach(Throwables.Consumer<? super T,E> action)
static <T, E extends Exception> void	N.forEach(Iterable<? extends T> c, Throwables.Consumer<? super T,E> action)
static <T, E extends Exception> void	N.forEach(Collection<? extends T> c, int fromIndex, int toIndex, Throwables.Consumer<? super T,E> action)	Mostly it's designed for one-step operation to complete the operation in one step.
static <T, E extends Exception> void	N.forEach(Iterator<? extends T> iter, Throwables.Consumer<? super T,E> action)
static <K, V, E extends Exception> void	N.forEach(Map<K,V> map, Throwables.Consumer<? super Map.Entry<K,V>,E> action)
static <T, E extends Exception> void	N.forEach(T[] a, int fromIndex, int toIndex, Throwables.Consumer<? super T,E> action)
static <T, E extends Exception> void	N.forEach(T[] a, Throwables.Consumer<? super T,E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableArray.forEach(Throwables.Consumer<? super T,E> action)
<E extends Exception> void	NoCachingNoUpdating.DisposableDeque.forEach(Throwables.Consumer<? super T,E> action)
<E extends Exception> void	Pair.forEach(Throwables.Consumer<?,E> comsumer)
<E extends Exception> void	RowDataSet.forEach(int fromRowIndex, int toRowIndex, Throwables.Consumer<? super NoCachingNoUpdating.DisposableObjArray,E> action)
<E extends Exception> void	RowDataSet.forEach(Throwables.Consumer<? super NoCachingNoUpdating.DisposableObjArray,E> action)
<E extends Exception> void	RowDataSet.forEach(Collection<String> columnNames, int fromRowIndex, int toRowIndex, Throwables.Consumer<? super NoCachingNoUpdating.DisposableObjArray,E> action)
<E extends Exception> void	RowDataSet.forEach(Collection<String> columnNames, Throwables.Consumer<? super NoCachingNoUpdating.DisposableObjArray,E> action)
<E extends Exception> void	Triple.forEach(Throwables.Consumer<?,E> comsumer)
abstract <E extends Exception> void	Tuple.forEach(Throwables.Consumer<?,E> consumer)
<E extends Exception> void	Tuple.Tuple1.forEach(Throwables.Consumer<?,E> consumer)
<E extends Exception> void	Tuple.Tuple2.forEach(Throwables.Consumer<?,E> consumer)
<E extends Exception> void	Tuple.Tuple3.forEach(Throwables.Consumer<?,E> consumer)
<E extends Exception> void	Tuple.Tuple4.forEach(Throwables.Consumer<?,E> consumer)
<E extends Exception> void	Tuple.Tuple5.forEach(Throwables.Consumer<?,E> consumer)
<E extends Exception> void	Tuple.Tuple6.forEach(Throwables.Consumer<?,E> consumer)
<E extends Exception> void	Tuple.Tuple7.forEach(Throwables.Consumer<?,E> consumer)
<E extends Exception> void	Tuple.Tuple8.forEach(Throwables.Consumer<?,E> consumer)
<E extends Exception> void	Tuple.Tuple9.forEach(Throwables.Consumer<?,E> consumer)
<E2 extends Exception> void	ExceptionalStream.forEachInParallel(Throwables.Consumer<? super T,E2> action, int threadNum)
<E2 extends Exception> void	ExceptionalStream.forEachInParallel(Throwables.Consumer<? super T,E2> action, int threadNum, Executor executor)
<X extends Exception> void	Multimap.forEachKey(Throwables.Consumer<? super K,X> action)	For each key.
static <T, E extends Exception> void	N.forEachNonNull(Iterable<T> c, Throwables.Consumer<? super T,E> action)	For each non null.
static <T, E extends Exception> void	N.forEachNonNull(T[] a, Throwables.Consumer<? super T,E> action)	For each non null.
<E extends Exception> void	LineIterator.foreachRemaining(Throwables.Consumer<? super String,E> action)
<E extends Exception> void	ObjIterator.foreachRemaining(Throwables.Consumer<? super T,E> action)
<E2 extends Exception> void	ExceptionalStream.forEachUntil(MutableBoolean flagToBreak, Throwables.Consumer<? super T,E2> action)	Iterate and execute action until flagToBreak is set true.
<X extends Exception> void	Multimap.forEachValue(Throwables.Consumer<? super V,X> action)	For each value.
<E extends Exception> void	ContinuableFuture.getThenAccept(long timeout, TimeUnit unit, Throwables.Consumer<? super T,E> action)	Gets the then accept.
<E extends Exception> void	ContinuableFuture.getThenAccept(Throwables.Consumer<? super T,E> action)	Gets the then accept.
<E2 extends Throwable> void	Result.ifFailure(Throwables.Consumer<? super E,E2> actionOnFailure)
<E2 extends Throwable, E3 extends Throwable> void	Result.ifFailureOrElse(Throwables.Consumer<? super E,E2> actionOnFailure, Throwables.Consumer<? super T,E3> actionOnSuccess)	If failure or else.
<E extends Exception> void	Holder.ifNotNull(Throwables.Consumer<? super T,E> action)	If not null.
<E extends Exception> u.Nullable<T>	u.Nullable.ifNotNull(Throwables.Consumer<? super T,E> action)	If not null.
<E extends Exception, E2 extends Exception> void	Holder.ifNotNullOrElse(Throwables.Consumer<? super T,E> action, Throwables.Runnable<E2> emptyAction)	If not null or else.
<E extends Exception, E2 extends Exception> u.Nullable<T>	u.Nullable.ifNotNullOrElse(Throwables.Consumer<? super T,E> action, Throwables.Runnable<E2> emptyAction)	If not null or else.
static <T, E1 extends Exception, E2 extends Exception> void	N.ifOrElse(boolean b, T init, Throwables.Consumer<? super T,E1> actionForTrue, Throwables.Consumer<? super T,E2> actionForFalse)	If or else.
<E extends Exception> u.Nullable<T>	u.Nullable.ifPresent(Throwables.Consumer<? super T,E> action)
<E extends Exception> u.Optional<T>	u.Optional.ifPresent(Throwables.Consumer<? super T,E> action)
<E extends Exception, E2 extends Exception> u.Nullable<T>	u.Nullable.ifPresentOrElse(Throwables.Consumer<? super T,E> action, Throwables.Runnable<E2> emptyAction)	If present or else.
<E extends Exception, E2 extends Exception> u.Optional<T>	u.Optional.ifPresentOrElse(Throwables.Consumer<? super T,E> action, Throwables.Runnable<E2> emptyAction)	If present or else.
<E2 extends Throwable> void	Result.ifSuccess(Throwables.Consumer<? super T,E2> actionOnSuccess)
<E2 extends Throwable, E3 extends Throwable> void	Result.ifSuccessOrElse(Throwables.Consumer<? super T,E2> actionOnSuccess, Throwables.Consumer<? super E,E3> actionOnFailure)	If success or else.
ExceptionalStream<T,E>	ExceptionalStream.onEach(Throwables.Consumer<? super T,? extends E> action)
ExceptionalStream<T,Exception>	ExceptionalStream.onEachE(Throwables.Consumer<? super T,? extends Exception> action)
<U, E extends Throwable> void	If.OrElse.orElse(U init, Throwables.Consumer<? super U,E> action)
static <E extends Exception> void	IOUtil.parse(File file, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(File file, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)
static <E extends Exception> void	IOUtil.parse(File file, long lineOffset, long count, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(File file, long lineOffset, long count, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)	Parse the specified files/directory line by line.
static <E extends Exception> void	IOUtil.parse(File file, long lineOffset, long count, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(File file, long lineOffset, long count, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)	Parse the specified files/directory line by line.
static <E extends Exception> void	IOUtil.parse(File file, long lineOffset, long count, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(File file, long lineOffset, long count, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)
static <E extends Exception> void	IOUtil.parse(File file, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(File file, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)
static <E extends Exception> void	IOUtil.parse(InputStream is, long lineOffset, long count, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(InputStream is, long lineOffset, long count, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)	Parse the specified Reader line by line.
static <E extends Exception> void	IOUtil.parse(InputStream is, long lineOffset, long count, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(InputStream is, long lineOffset, long count, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)
static <E extends Exception> void	IOUtil.parse(InputStream is, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(InputStream is, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)
static <E extends Exception> void	IOUtil.parse(Reader reader, long lineOffset, long count, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(Reader reader, long lineOffset, long count, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)	Parse the specified Reader line by line.
static <E extends Exception> void	IOUtil.parse(Reader reader, long lineOffset, long count, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(Reader reader, long lineOffset, long count, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)
static <E extends Exception> void	IOUtil.parse(Reader reader, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(Reader reader, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)
static <E extends Exception> void	IOUtil.parse(List<File> files, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(List<File> files, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)
static <E extends Exception> void	IOUtil.parse(List<File> files, long lineOffset, long count, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(List<File> files, long lineOffset, long count, int readThreadNum, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)	Parse the specified files/directory line by line.
static <E extends Exception> void	IOUtil.parse(List<File> files, long lineOffset, long count, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(List<File> files, long lineOffset, long count, int processThreadNum, int queueSize, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)	Parse the specified files/directory line by line.
static <E extends Exception> void	IOUtil.parse(List<File> files, long lineOffset, long count, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(List<File> files, long lineOffset, long count, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)
static <E extends Exception> void	IOUtil.parse(List<File> files, Throwables.Consumer<String,E> lineParser)
static <E extends Exception, E2 extends Exception> void	IOUtil.parse(List<File> files, Throwables.Consumer<String,E> lineParser, Throwables.Runnable<E2> onComplete)
ExceptionalStream<T,E>	ExceptionalStream.peek(Throwables.Consumer<? super T,? extends E> action)
ExceptionalStream<T,E>	ExceptionalStream.peekFirst(Throwables.Consumer<? super T,? extends E> action)
ExceptionalStream<T,E>	ExceptionalStream.peekIf(Throwables.Predicate<? super T,E> predicate, Throwables.Consumer<? super T,E> action)
ExceptionalStream<T,E>	ExceptionalStream.peekLast(Throwables.Consumer<? super T,? extends E> action)
void	Try.run(Throwables.Consumer<? super T,? extends Exception> cmd)
void	Try.run(Throwables.Consumer<? super T,? extends Exception> cmd, Consumer<? super Exception> actionOnError)
<U, E extends Exception> ContinuableFuture<Void>	ContinuableFuture.runAfterBoth(ContinuableFuture<U> other, Throwables.Consumer<? super Tuple.Tuple4<T,? super Exception,U,? super Exception>,E> action)	Run after both.
<E extends Exception> ContinuableFuture<Void>	ContinuableFuture.runAfterEither(ContinuableFuture<? extends T> other, Throwables.Consumer<? super T,E> action)	Run after either.
static <T, E extends Throwable> Throwables.Consumer<T,E>	Fn.Fnn.sc(Object mutex, Throwables.Consumer<T,E> consumer)	Synchronized Consumer.
ExceptionalStream<T,E>	ExceptionalStream.spsOnEach(int maxThreadNum, Throwables.Consumer<? super T,E> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
ExceptionalStream<T,E>	ExceptionalStream.spsOnEach(Throwables.Consumer<? super T,E> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
ExceptionalStream<T,Exception>	ExceptionalStream.spsOnEachE(int maxThreadNum, Throwables.Consumer<? super T,? extends Exception> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
ExceptionalStream<T,Exception>	ExceptionalStream.spsOnEachE(Throwables.Consumer<? super T,? extends Exception> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
<U, E extends Throwable> If.OrElse	If.then(U init, Throwables.Consumer<? super U,E> action)
<E extends Exception> ContinuableFuture<Void>	ContinuableFuture.thenRun(Throwables.Consumer<? super T,E> action)

Uses of Throwables.Consumer in com.landawn.abacus.util.function

Subinterfaces of Throwables.Consumer in com.landawn.abacus.util.function

Modifier and Type	Interface	Description
interface	Consumer<T>	Refer to JDK API documentation at: https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

Methods in com.landawn.abacus.util.function that return Throwables.Consumer

Modifier and Type	Method	Description
default <E extends Throwable> Throwables.Consumer<T,E>	Consumer.toThrowable()

Uses of Throwables.Consumer in com.landawn.abacus.util.stream

Methods in com.landawn.abacus.util.stream with parameters of type Throwables.Consumer

Modifier and Type	Method	Description
<E extends Exception> If.OrElse	BaseStream.acceptIfNotEmpty(Throwables.Consumer<? super S,E> action)	This is a terminal operation.
<E extends Exception> If.OrElse	EntryStream.acceptIfNotEmpty(Throwables.Consumer<? super EntryStream<K,V>,E> action)
ContinuableFuture<Void>	Stream.asyncRun(Throwables.Consumer<? super Stream<T>,? extends Exception> terminalAction)
ContinuableFuture<Void>	Stream.asyncRun(Throwables.Consumer<? super Stream<T>,? extends Exception> terminalAction, Executor executor)
<E extends Exception> void	EntryStream.forEach(Throwables.Consumer<? super Map.Entry<K,V>,E> action)
abstract <E extends Exception> void	Stream.forEach(Throwables.Consumer<? super T,E> action)
abstract <E extends Exception, E2 extends Exception> void	Stream.forEach(Throwables.Consumer<? super T,E> action, Throwables.Runnable<E2> onComplete)
abstract <E extends Exception> void	Stream.forEachUntil(MutableBoolean flagToBreak, Throwables.Consumer<? super T,E> action)	Iterate and execute action until flagToBreak is set true.
Stream<T>	Stream.onEachE(Throwables.Consumer<? super T,? extends Exception> action)
Stream<T>	Stream.spsOnEachE(int maxThreadNum, Throwables.Consumer<? super T,? extends Exception> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
Stream<T>	Stream.spsOnEachE(Throwables.Consumer<? super T,? extends Exception> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.