eu.lunisolar.magma.func.predicate

Interface LObjBytePredicate<T>

All Superinterfaces:

Codomain<aType.aBool>, Domain, Domain2<aType.a<T>,aType.aByte>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaPredicate

All Known Subinterfaces:

LObjBytePredicate.LByteObjPred<T>

All Known Implementing Classes:

LObjBytePredicate.LObjBytePredicateSingle

@FunctionalInterface
public interface LObjBytePredicate<T>
extends MetaPredicate, MetaInterface.NonThrowing, Codomain<aType.aBool>, Domain2<aType.a<T>,aType.aByte>

Non-throwing functional interface (lambda) LObjBytePredicate for Java 8.

Type: predicate

Domain (lvl: 2): T a1,byte a2

Co-domain: boolean

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	LObjBytePredicate.LByteObjPred<T> Permutation of LObjBytePredicate for method references.
static class	LObjBytePredicate.LObjBytePredicateSingle<T>

Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface

MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Field Summary

Fields

Modifier and Type	Field and Description
static String	DESCRIPTION

Method Summary

Modifier and Type	Method and Description
static <T> boolean	alwaysFalse(byte a2, T a1) Returns FALSE.
static <T> boolean	alwaysFalse(T a1, byte a2) Returns FALSE.
static <T> boolean	alwaysTrue(byte a2, T a1) Returns TRUE.
static <T> boolean	alwaysTrue(T a1, byte a2) Returns TRUE.
default LObjBytePredicate<T>	and(LObjBytePredicate<? super T> other) Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
default <V> LObjByteFunction<T,V>	boolToObjByteFunc(LBoolFunction<? extends V> after) Combines two functions together in a order.
default LObjBytePredicate<T>	boolToObjBytePred(LLogicalOperator after) Combines two functions together in a order.
static <T> LObjBytePredicate.LByteObjPred<T>	byteObjPred(LObjBytePredicate.LByteObjPred<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> boolean	call(T a1, byte a2, LObjBytePredicate<T> lambda)
default LBoolSupplier	capture(T a1, byte a2) Captures arguments but delays the evaluation.
default <V2> LObjBytePredicate<V2>	cast() Cast that replace generics.
static <V2,T> LObjBytePredicate<V2>	cast(LObjBytePredicate<T> function) Cast that replace generics.
default <V1> LObjBytePredicate<V1>	compose(LFunction<? super V1,? extends T> before1, LByteUnaryOperator before2) Allows to manipulate the domain of the function.
static <V1,T> LObjBytePredicate<V1>	composed(LFunction<? super V1,? extends T> before1, LByteUnaryOperator before2, LObjBytePredicate<T> after)
static <V1,V2,T> LBiPredicate<V1,V2>	composed(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2, LObjBytePredicate<T> after)
static <T> LObjBytePredicate<T>	constant(boolean r) Creates function that always returns the same value.
default boolean	doApplyAsBoolean(T a1, byte a2) For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.
default boolean	doIf(T a1, byte a2, LAction action)
default boolean	doIf(T a1, byte a2, LObjByteConsumer<? super T> consumer)
static <T> boolean	doIf(T a1, byte a2, LObjBytePredicate<T> predicate, LAction action)
static <T> boolean	doIf(T a1, byte a2, LObjBytePredicate<T> predicate, LObjByteConsumer<? super T> consumer)
default <V> boolean	doIf(V a1, T a2, byte a3, LBiObjByteConsumer<V,? super T> consumer)
static <T> LObjBytePredicate<T>	failSafe(LObjBytePredicate<T> func, LObjBytePredicate<T> failSafe)
default boolean	failSafeTest(T a1, byte a2, LObjBytePredicate<T> failSafe)
static <T> boolean	failSafeTest(T a1, byte a2, LObjBytePredicate<T> func, LObjBytePredicate<T> failSafe)
default <C1,C2> void	filterForEach(IndexedRead<C1,aType.a<T>> ia1, C1 source1, IndexedRead<C2,aType.aByte> ia2, C2 source2, LObjByteConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,C2,I2> void	filterIterate(IndexedRead<C1,aType.a<T>> ia1, C1 source1, SequentialRead<C2,I2,aType.aByte> sa2, C2 source2, LObjByteConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2> void	filterIterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, IndexedRead<C2,aType.aByte> ia2, C2 source2, LObjByteConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
default <C1,I1,C2,I2> void	filterIterate(SequentialRead<C1,I1,aType.a<T>> sa1, C1 source1, SequentialRead<C2,I2,aType.aByte> sa2, C2 source2, LObjByteConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer if predicate test passes.
static <T> void	fromTill(int min_i, int max_i, T a1, byte a2, LObjBytePredicate<T> func) From-To.
static <T> void	fromTo(int min_i, int max_i, T a1, byte a2, LObjBytePredicate<T> func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LObjBytePredicate<T>	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default boolean	handlingTest(T a1, byte a2, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static <T> boolean	handlingTest(T a1, byte a2, LObjBytePredicate<T> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <T> LObjBytePredicate<T>	isEqual(T v1, byte v2) Creates predicate that evaluates if an object is equal with the argument one.
default LBytePredicate	lShrink(LByteFunction<T> left)
default LBytePredicate	lShrinkc(T a1)
static <T> LBytePredicate	lShrinked(LByteFunction<T> left, LObjBytePredicate<T> func)
static <T> LBytePredicate	lShrinkedc(T a1, LObjBytePredicate<T> func)
default LObjBytePredicate<T>	negate() Returns a predicate that represents the logical negation of this predicate.
default boolean	nestingTest(T a1, byte a2) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default boolean	nonNullTest(T a1, byte a2) Just to mirror the method: Ensures the result is not null
static <T> LObjBytePredicate<T>	objBytePred(LObjBytePredicate<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V1,V2> LBiPredicate<V1,V2>	objBytePredCompose(LFunction<? super V1,? extends T> before1, LToByteFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <T> LObjBytePredicate<T>	objBytePredThrowing(ExF<Throwable> exF)
static <T> LObjBytePredicate<T>	objBytePredThrowing(String message, ExMF<Throwable> exF)
default LObjBytePredicate<T>	or(LObjBytePredicate<? super T> other) Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
static <T> LObjBytePredicate<T>	recursive(LFunction<LObjBytePredicate<T>,LObjBytePredicate<T>> selfLambda)
default LPredicate<T>	rShrink(LToByteFunction<T> right)
default LPredicate<T>	rShrinkc(byte a2)
static <T> LPredicate<T>	rShrinked(LToByteFunction<T> right, LObjBytePredicate<T> func)
static <T> LPredicate<T>	rShrinkedc(byte a2, LObjBytePredicate<T> func)
static <T> LObjBytePredicate<T>	safe() Safe instance.
static <T> LObjBytePredicate<T>	safe(LObjBytePredicate<T> other) Safe wrapping.
static <T> LSupplier<LObjBytePredicate<T>>	safeSupplier() Safe instance supplier.
static <T> LSupplier<LObjBytePredicate<T>>	safeSupplier(LSupplier<LObjBytePredicate<T>> supplier) Safe supplier.
default boolean	shovingTest(T a1, byte a2) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default boolean	test(T a1, byte a2)
default boolean	test(T a1, byte a2, ExWF<RuntimeException> exF)
default boolean	test(T a1, byte a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T> LObjBytePredicate<T>	test1st(LPredicate<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T> LObjBytePredicate<T>	test2nd(LBytePredicate func) Captures single parameter function into this interface where only 2nd parameter will be used.
default boolean	testThen(T a1, byte a2, LPredicate<Throwable> handler)
boolean	testX(T a1, byte a2) Implement this, but call test(T a1,byte a2)
static <T> void	throwIf(T a1, byte a2, LObjBytePredicate<T> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)
static <T> void	throwIfNot(T a1, byte a2, LObjBytePredicate<T> pred, ExMF<RuntimeException> factory, String newMessage, Object... messageParams)
static <T> void	times(int max_i, T a1, byte a2, LObjBytePredicate<T> func) From-To.
default LObjBytePredicate<T>	trying(ExWF<RuntimeException> exF)
default LObjBytePredicate<T>	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LObjBytePredicate<T>	tryingThen(LPredicate<Throwable> handler)
static <T> boolean	tryTest(T a1, byte a2, LObjBytePredicate<T> func)
static <T> boolean	tryTest(T a1, byte a2, LObjBytePredicate<T> func, ExWF<RuntimeException> exF)
static <T> boolean	tryTest(T a1, byte a2, LObjBytePredicate<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T> boolean	tryTestThen(T a1, byte a2, LObjBytePredicate<T> func, LPredicate<Throwable> handler)
default boolean	tupleTest(LObjBytePair<T> args)
static <T> LObjBytePredicate<T>	uncurry(LFunction<T,LBytePredicate> func)
default LObjBytePredicate	untyped() Cast that removes generics.
default LObjBytePredicate<T>	xor(LObjBytePredicate<? super T> other) Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaPredicate

isPredicate

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaFunction

isFunction

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.MetaFunctionalInterface

formatTo, isAction, isConsumer, isOperator, isSupplier

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface

isThrowing

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface.NonThrowing

isThrowing

Field Detail

DESCRIPTION

static final String DESCRIPTION

See Also:

Constant Field Values

Method Detail

test

default boolean test(T a1,
                     byte a2)

testX

boolean testX(T a1,
              byte a2)
       throws Throwable

Implement this, but call test(T a1,byte a2)

Throws:

Throwable

tupleTest

default boolean tupleTest(LObjBytePair<T> args)

handlingTest

default boolean handlingTest(T a1,
                             byte a2,
                             HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LObjBytePredicate<T> handling(HandlingInstructions<Throwable,RuntimeException> handling)

test

default boolean test(T a1,
                     byte a2,
                     @Nonnull
                     ExWMF<RuntimeException> exF,
                     @Nonnull
                     String newMessage,
                     @Nullable
                     Object... messageParams)

trying

default LObjBytePredicate<T> trying(@Nonnull
                                    ExWMF<RuntimeException> exF,
                                    @Nonnull
                                    String newMessage,
                                    @Nullable
                                    Object... messageParams)

test

default boolean test(T a1,
                     byte a2,
                     @Nonnull
                     ExWF<RuntimeException> exF)

trying

default LObjBytePredicate<T> trying(@Nonnull
                                    ExWF<RuntimeException> exF)

testThen

default boolean testThen(T a1,
                         byte a2,
                         @Nonnull
                         LPredicate<Throwable> handler)

tryingThen

default LObjBytePredicate<T> tryingThen(@Nonnull
                                        LPredicate<Throwable> handler)

nestingTest

default boolean nestingTest(T a1,
                            byte a2)

Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingTest

default boolean shovingTest(T a1,
                            byte a2)

Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingTest

static <T> boolean handlingTest(T a1,
                                byte a2,
                                LObjBytePredicate<T> func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryTest

static <T> boolean tryTest(T a1,
                           byte a2,
                           LObjBytePredicate<T> func)

tryTest

static <T> boolean tryTest(T a1,
                           byte a2,
                           LObjBytePredicate<T> func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryTest

static <T> boolean tryTest(T a1,
                           byte a2,
                           LObjBytePredicate<T> func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryTestThen

static <T> boolean tryTestThen(T a1,
                               byte a2,
                               LObjBytePredicate<T> func,
                               @Nonnull
                               LPredicate<Throwable> handler)

failSafeTest

default boolean failSafeTest(T a1,
                             byte a2,
                             @Nonnull
                             LObjBytePredicate<T> failSafe)

failSafeTest

static <T> boolean failSafeTest(T a1,
                                byte a2,
                                LObjBytePredicate<T> func,
                                @Nonnull
                                LObjBytePredicate<T> failSafe)

failSafe

static <T> LObjBytePredicate<T> failSafe(LObjBytePredicate<T> func,
                                         @Nonnull
                                         LObjBytePredicate<T> failSafe)

doIf

default boolean doIf(T a1,
                     byte a2,
                     LAction action)

doIf

static <T> boolean doIf(T a1,
                        byte a2,
                        @Nonnull
                        LObjBytePredicate<T> predicate,
                        @Nonnull
                        LAction action)

doIf

static <T> boolean doIf(T a1,
                        byte a2,
                        @Nonnull
                        LObjBytePredicate<T> predicate,
                        @Nonnull
                        LObjByteConsumer<? super T> consumer)

doIf

default boolean doIf(T a1,
                     byte a2,
                     @Nonnull
                     LObjByteConsumer<? super T> consumer)

throwIf

static <T> void throwIf(T a1,
                        byte a2,
                        LObjBytePredicate<T> pred,
                        ExMF<RuntimeException> factory,
                        @Nonnull
                        String newMessage,
                        @Nullable
                        Object... messageParams)

throwIfNot

static <T> void throwIfNot(T a1,
                           byte a2,
                           LObjBytePredicate<T> pred,
                           ExMF<RuntimeException> factory,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

nonNullTest

default boolean nonNullTest(T a1,
                            byte a2)

Just to mirror the method: Ensures the result is not null

doApplyAsBoolean

default boolean doApplyAsBoolean(T a1,
                                 byte a2)

For convenience, where “test()” makes things more confusing than “applyAsBoolean()”.

functionalInterfaceDescription

@Nonnull
default String functionalInterfaceDescription()

Returns description of the functional interface.

Specified by:

functionalInterfaceDescription in interface MetaFunctionalInterface

doIf

default <V> boolean doIf(V a1,
                         T a2,
                         byte a3,
                         LBiObjByteConsumer<V,? super T> consumer)

fromTo

static <T> void fromTo(int min_i,
                       int max_i,
                       T a1,
                       byte a2,
                       LObjBytePredicate<T> func)

From-To. Intended to be used with non-capturing lambda.

fromTill

static <T> void fromTill(int min_i,
                         int max_i,
                         T a1,
                         byte a2,
                         LObjBytePredicate<T> func)

From-To. Intended to be used with non-capturing lambda.

times

static <T> void times(int max_i,
                      T a1,
                      byte a2,
                      LObjBytePredicate<T> func)

From-To. Intended to be used with non-capturing lambda.

lShrink

default LBytePredicate lShrink(LByteFunction<T> left)

lShrinkc

default LBytePredicate lShrinkc(T a1)

lShrinked

static <T> LBytePredicate lShrinked(LByteFunction<T> left,
                                    LObjBytePredicate<T> func)

lShrinkedc

static <T> LBytePredicate lShrinkedc(T a1,
                                     LObjBytePredicate<T> func)

rShrink

default LPredicate<T> rShrink(LToByteFunction<T> right)

rShrinkc

default LPredicate<T> rShrinkc(byte a2)

rShrinked

static <T> LPredicate<T> rShrinked(LToByteFunction<T> right,
                                   LObjBytePredicate<T> func)

rShrinkedc

static <T> LPredicate<T> rShrinkedc(byte a2,
                                    LObjBytePredicate<T> func)

uncurry

static <T> LObjBytePredicate<T> uncurry(LFunction<T,LBytePredicate> func)

untyped

default LObjBytePredicate untyped()

Cast that removes generics.

cast

default <V2> LObjBytePredicate<V2> cast()

Cast that replace generics.

cast

static <V2,T> LObjBytePredicate<V2> cast(LObjBytePredicate<T> function)

Cast that replace generics.

capture

default LBoolSupplier capture(T a1,
                              byte a2)

Captures arguments but delays the evaluation.

constant

static <T> LObjBytePredicate<T> constant(boolean r)

Creates function that always returns the same value.

test1st

@Nonnull
static <T> LObjBytePredicate<T> test1st(@Nonnull
                                                  LPredicate<T> func)

Captures single parameter function into this interface where only 1st parameter will be used.

test2nd

@Nonnull
static <T> LObjBytePredicate<T> test2nd(@Nonnull
                                                  LBytePredicate func)

Captures single parameter function into this interface where only 2nd parameter will be used.

objBytePred

@Nonnull
static <T> LObjBytePredicate<T> objBytePred(@Nonnull
                                                      LObjBytePredicate<T> lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

recursive

@Nonnull
static <T> LObjBytePredicate<T> recursive(@Nonnull
                                                    LFunction<LObjBytePredicate<T>,LObjBytePredicate<T>> selfLambda)

objBytePredThrowing

@Nonnull
static <T> LObjBytePredicate<T> objBytePredThrowing(@Nonnull
                                                              ExF<Throwable> exF)

objBytePredThrowing

@Nonnull
static <T> LObjBytePredicate<T> objBytePredThrowing(String message,
                                                              @Nonnull
                                                              ExMF<Throwable> exF)

byteObjPred

@Nonnull
static <T> LObjBytePredicate.LByteObjPred<T> byteObjPred(@Nonnull
                                                                   LObjBytePredicate.LByteObjPred<T> lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

call

static <T> boolean call(T a1,
                        byte a2,
                        @Nonnull
                        LObjBytePredicate<T> lambda)

safe

@Nonnull
static <T> LObjBytePredicate<T> safe()

Safe instance. That always returns the same value (as alwaysFalse).

safeSupplier

@Nonnull
static <T> LSupplier<LObjBytePredicate<T>> safeSupplier()

Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static <T> LObjBytePredicate<T> safe(@Nullable
                                               LObjBytePredicate<T> other)

Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.

safeSupplier

@Nonnull
static <T> LSupplier<LObjBytePredicate<T>> safeSupplier(@Nullable
                                                                  LSupplier<LObjBytePredicate<T>> supplier)

Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.

negate

@Nonnull
default LObjBytePredicate<T> negate()

Returns a predicate that represents the logical negation of this predicate.

See Also:

java.util.function.Predicate#negate}

and

@Nonnull
default LObjBytePredicate<T> and(@Nonnull
                                           LObjBytePredicate<? super T> other)

Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.

See Also:

java.util.function.Predicate#and()}

or

@Nonnull
default LObjBytePredicate<T> or(@Nonnull
                                          LObjBytePredicate<? super T> other)

Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.

See Also:

java.util.function.Predicate#or}

xor

@Nonnull
default LObjBytePredicate<T> xor(@Nonnull
                                           LObjBytePredicate<? super T> other)

Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.

See Also:

java.util.function.Predicate#or}

isEqual

@Nonnull
static <T> LObjBytePredicate<T> isEqual(T v1,
                                                  byte v2)

Creates predicate that evaluates if an object is equal with the argument one.

See Also:

java.util.function.Predicate#isEqual()

compose

@Nonnull
default <V1> LObjBytePredicate<V1> compose(@Nonnull
                                                     LFunction<? super V1,? extends T> before1,
                                                     @Nonnull
                                                     LByteUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static <V1,T> LObjBytePredicate<V1> composed(@Nonnull
                                             LFunction<? super V1,? extends T> before1,
                                             @Nonnull
                                             LByteUnaryOperator before2,
                                             LObjBytePredicate<T> after)

objBytePredCompose

@Nonnull
default <V1,V2> LBiPredicate<V1,V2> objBytePredCompose(@Nonnull
                                                                 LFunction<? super V1,? extends T> before1,
                                                                 @Nonnull
                                                                 LToByteFunction<? super V2> before2)

Allows to manipulate the domain of the function.

composed

static <V1,V2,T> LBiPredicate<V1,V2> composed(@Nonnull
                                              LFunction<? super V1,? extends T> before1,
                                              @Nonnull
                                              LToByteFunction<? super V2> before2,
                                              LObjBytePredicate<T> after)

boolToObjByteFunc

@Nonnull
default <V> LObjByteFunction<T,V> boolToObjByteFunc(@Nonnull
                                                              LBoolFunction<? extends V> after)

Combines two functions together in a order.

boolToObjBytePred

@Nonnull
default LObjBytePredicate<T> boolToObjBytePred(@Nonnull
                                                         LLogicalOperator after)

Combines two functions together in a order.

alwaysTrue

static <T> boolean alwaysTrue(T a1,
                              byte a2)

Returns TRUE.

alwaysFalse

static <T> boolean alwaysFalse(T a1,
                               byte a2)

Returns FALSE.

alwaysTrue

static <T> boolean alwaysTrue(byte a2,
                              T a1)

Returns TRUE.

alwaysFalse

static <T> boolean alwaysFalse(byte a2,
                               T a1)

Returns FALSE.

filterForEach

default <C1,C2> void filterForEach(IndexedRead<C1,aType.a<T>> ia1,
                                   C1 source1,
                                   IndexedRead<C2,aType.aByte> ia2,
                                   C2 source2,
                                   LObjByteConsumer<? super T> consumer)

For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.

filterIterate

default <C1,I1,C2> void filterIterate(SequentialRead<C1,I1,aType.a<T>> sa1,
                                      C1 source1,
                                      IndexedRead<C2,aType.aByte> ia2,
                                      C2 source2,
                                      LObjByteConsumer<? super T> consumer)

For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.

filterIterate

default <C1,C2,I2> void filterIterate(IndexedRead<C1,aType.a<T>> ia1,
                                      C1 source1,
                                      SequentialRead<C2,I2,aType.aByte> sa2,
                                      C2 source2,
                                      LObjByteConsumer<? super T> consumer)

For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method is not expected.

filterIterate

default <C1,I1,C2,I2> void filterIterate(SequentialRead<C1,I1,aType.a<T>> sa1,
                                         C1 source1,
                                         SequentialRead<C2,I2,aType.aByte> sa2,
                                         C2 source2,
                                         LObjByteConsumer<? super T> consumer)

For each element (or tuple) from arguments, calls the consumer if predicate test passes. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.