All Downloads are FREE. Search and download functionalities are using the official Maven repository.

eu.lunisolar.magma.func.predicate.LObjIntBytePredicate Maven / Gradle / Ivy

There is a newer version: 3.0.0
Show newest version
/*
 * This file is part of "lunisolar-magma".
 *
 * (C) Copyright 2014-2019 Lunisolar (http://lunisolar.eu/).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package eu.lunisolar.magma.func.predicate;

import javax.annotation.Nonnull; // NOSONAR
import javax.annotation.Nullable; // NOSONAR
import java.util.Comparator; // NOSONAR
import java.util.Objects; // NOSONAR
import eu.lunisolar.magma.basics.*; //NOSONAR
import eu.lunisolar.magma.basics.builder.*; // NOSONAR
import eu.lunisolar.magma.basics.exceptions.*; // NOSONAR
import eu.lunisolar.magma.basics.meta.*; // NOSONAR
import eu.lunisolar.magma.basics.meta.aType.*; // NOSONAR
import eu.lunisolar.magma.basics.meta.functional.*; // NOSONAR
import eu.lunisolar.magma.basics.meta.functional.type.*; // NOSONAR
import eu.lunisolar.magma.basics.meta.functional.domain.*; // NOSONAR
import eu.lunisolar.magma.func.IA;
import eu.lunisolar.magma.func.SA;
import eu.lunisolar.magma.func.*; // NOSONAR
import eu.lunisolar.magma.func.tuple.*; // NOSONAR
import java.util.function.*; // NOSONAR
import java.util.*; // NOSONAR
import java.lang.reflect.*;

import eu.lunisolar.magma.func.action.*; // NOSONAR
import eu.lunisolar.magma.func.consumer.*; // NOSONAR
import eu.lunisolar.magma.func.consumer.primitives.*; // NOSONAR
import eu.lunisolar.magma.func.consumer.primitives.bi.*; // NOSONAR
import eu.lunisolar.magma.func.consumer.primitives.obj.*; // NOSONAR
import eu.lunisolar.magma.func.consumer.primitives.tri.*; // NOSONAR
import eu.lunisolar.magma.func.function.*; // NOSONAR
import eu.lunisolar.magma.func.function.conversion.*; // NOSONAR
import eu.lunisolar.magma.func.function.from.*; // NOSONAR
import eu.lunisolar.magma.func.function.to.*; // NOSONAR
import eu.lunisolar.magma.func.operator.binary.*; // NOSONAR
import eu.lunisolar.magma.func.operator.ternary.*; // NOSONAR
import eu.lunisolar.magma.func.operator.unary.*; // NOSONAR
import eu.lunisolar.magma.func.predicate.*; // NOSONAR
import eu.lunisolar.magma.func.supplier.*; // NOSONAR

/**
 * Non-throwing functional interface (lambda) LObjIntBytePredicate for Java 8.
 *
 * Type: predicate
 *
 * Domain (lvl: 3): T a1,int a2,byte a3
 *
 * Co-domain: boolean
 *
 */
@FunctionalInterface
@SuppressWarnings("UnusedDeclaration")
public interface LObjIntBytePredicate extends MetaPredicate, MetaInterface.NonThrowing, Codomain, Domain3, aInt, aByte> { // NOSONAR

	String DESCRIPTION = "LObjIntBytePredicate: boolean test(T a1,int a2,byte a3)";

	// boolean test(T a1,int a2,byte a3) ;
	default boolean test(T a1, int a2, byte a3) {
		// return nestingTest(a1,a2,a3);
		try {
			return this.testX(a1, a2, a3);
		} catch (Throwable e) { // NOSONAR
			throw Handling.nestCheckedAndThrow(e);
		}
	}

	/**
	 * Implement this, but call test(T a1,int a2,byte a3)
	 */
	boolean testX(T a1, int a2, byte a3) throws Throwable;

	default boolean tupleTest(LObjIntByteTriple args) {
		return test(args.first(), args.second(), args.third());
	}

	/** Function call that handles exceptions according to the instructions. */
	default boolean handlingTest(T a1, int a2, byte a3, HandlingInstructions handling) {
		try {
			return this.testX(a1, a2, a3);
		} catch (Throwable e) { // NOSONAR
			throw Handler.handleOrNest(e, handling);
		}
	}

	default LObjIntBytePredicate handling(HandlingInstructions handling) {
		return (a1, a2, a3) -> handlingTest(a1, a2, a3, handling);
	}

	default boolean test(T a1, int a2, byte a3, @Nonnull ExWMF exF, @Nonnull String newMessage, @Nullable Object... messageParams) {
		try {
			return this.testX(a1, a2, a3);
		} catch (Throwable e) { // NOSONAR
			throw Handling.wrap(e, exF, newMessage, messageParams);
		}
	}

	default LObjIntBytePredicate trying(@Nonnull ExWMF exF, @Nonnull String newMessage, @Nullable Object... messageParams) {
		return (a1, a2, a3) -> test(a1, a2, a3, exF, newMessage, messageParams);
	}

	default boolean test(T a1, int a2, byte a3, @Nonnull ExWF exF) {
		try {
			return this.testX(a1, a2, a3);
		} catch (Throwable e) { // NOSONAR
			throw Handling.wrap(e, exF);
		}
	}

	default LObjIntBytePredicate trying(@Nonnull ExWF exF) {
		return (a1, a2, a3) -> test(a1, a2, a3, exF);
	}

	default boolean testThen(T a1, int a2, byte a3, @Nonnull LPredicate handler) {
		try {
			return this.testX(a1, a2, a3);
		} catch (Throwable e) { // NOSONAR
			Handling.handleErrors(e);
			return handler.test(e);
		}
	}

	default LObjIntBytePredicate tryingThen(@Nonnull LPredicate handler) {
		return (a1, a2, a3) -> testThen(a1, a2, a3, handler);
	}

	/** Function call that handles exceptions by always nesting checked exceptions and propagating the others as is. */
	default boolean nestingTest(T a1, int a2, byte a3) {
		try {
			return this.testX(a1, a2, a3);
		} catch (Throwable e) { // NOSONAR
			throw Handling.nestCheckedAndThrow(e);
		}
	}

	/** Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones. */
	default boolean shovingTest(T a1, int a2, byte a3) {
		try {
			return this.testX(a1, a2, a3);
		} catch (Throwable e) { // NOSONAR
			throw Handling.shoveIt(e);
		}
	}

	static  boolean handlingTest(T a1, int a2, byte a3, LObjIntBytePredicate func, HandlingInstructions handling) { // <-
		Null.nonNullArg(func, "func");
		return func.handlingTest(a1, a2, a3, handling);
	}

	static  boolean tryTest(T a1, int a2, byte a3, LObjIntBytePredicate func) {
		Null.nonNullArg(func, "func");
		return func.nestingTest(a1, a2, a3);
	}

	static  boolean tryTest(T a1, int a2, byte a3, LObjIntBytePredicate func, @Nonnull ExWMF exF, @Nonnull String newMessage, @Nullable Object... messageParams) {
		Null.nonNullArg(func, "func");
		return func.test(a1, a2, a3, exF, newMessage, messageParams);
	}

	static  boolean tryTest(T a1, int a2, byte a3, LObjIntBytePredicate func, @Nonnull ExWF exF) {
		Null.nonNullArg(func, "func");
		return func.test(a1, a2, a3, exF);
	}

	static  boolean tryTestThen(T a1, int a2, byte a3, LObjIntBytePredicate func, @Nonnull LPredicate handler) {
		Null.nonNullArg(func, "func");
		return func.testThen(a1, a2, a3, handler);
	}

	default boolean failSafeTest(T a1, int a2, byte a3, @Nonnull LObjIntBytePredicate failSafe) {
		try {
			return test(a1, a2, a3);
		} catch (Throwable e) { // NOSONAR
			Handling.handleErrors(e);
			return failSafe.test(a1, a2, a3);
		}
	}

	static  boolean failSafeTest(T a1, int a2, byte a3, LObjIntBytePredicate func, @Nonnull LObjIntBytePredicate failSafe) {
		Null.nonNullArg(failSafe, "failSafe");
		if (func == null) {
			return failSafe.test(a1, a2, a3);
		} else {
			return func.failSafeTest(a1, a2, a3, failSafe);
		}
	}

	static  LObjIntBytePredicate failSafe(LObjIntBytePredicate func, @Nonnull LObjIntBytePredicate failSafe) {
		Null.nonNullArg(failSafe, "failSafe");
		return (a1, a2, a3) -> failSafeTest(a1, a2, a3, func, failSafe);
	}

	default boolean doIf(T a1, int a2, byte a3, LAction action) {
		Null.nonNullArg(action, "action");
		if (test(a1, a2, a3)) {
			action.execute();
			return true;
		} else {
			return false;
		}
	}

	static  boolean doIf(T a1, int a2, byte a3, @Nonnull LObjIntBytePredicate predicate, @Nonnull LAction action) {
		Null.nonNullArg(predicate, "predicate");
		return predicate.doIf(a1, a2, a3, action);
	}

	static  boolean doIf(T a1, int a2, byte a3, @Nonnull LObjIntBytePredicate predicate, @Nonnull LTieByteConsumer consumer) {
		Null.nonNullArg(predicate, "predicate");
		return predicate.doIf(a1, a2, a3, consumer);
	}

	default boolean doIf(T a1, int a2, byte a3, @Nonnull LTieByteConsumer consumer) {
		Null.nonNullArg(consumer, "consumer");
		if (test(a1, a2, a3)) {
			consumer.accept(a1, a2, a3);
			return true;
		} else {
			return false;
		}
	}

	static  void throwIf(T a1, int a2, byte a3, LObjIntBytePredicate pred, ExMF factory, @Nonnull String newMessage, @Nullable Object... messageParams) {
		if (pred.test(a1, a2, a3)) {
			throw Handling.create(factory, newMessage, messageParams);
		}
	}

	static  void throwIfNot(T a1, int a2, byte a3, LObjIntBytePredicate pred, ExMF factory, @Nonnull String newMessage, @Nullable Object... messageParams) {
		if (!pred.test(a1, a2, a3)) {
			throw Handling.create(factory, newMessage, messageParams);
		}
	}

	/** Just to mirror the method: Ensures the result is not null */
	default boolean nonNullTest(T a1, int a2, byte a3) {
		return test(a1, a2, a3);
	}

	/** For convenience, where "test()" makes things more confusing than "applyAsBoolean()". */

	default boolean doApplyAsBoolean(T a1, int a2, byte a3) {
		return test(a1, a2, a3);
	}

	/** Returns description of the functional interface. */
	@Nonnull
	default String functionalInterfaceDescription() {
		return LObjIntBytePredicate.DESCRIPTION;
	}

	/** From-To. Intended to be used with non-capturing lambda. */
	public static  void fromTo(int min_a2, int max_a2, T a1, byte a3, LObjIntBytePredicate func) {
		Null.nonNullArg(func, "func");
		if (min_a2 <= max_a2) {
			for (int a2 = min_a2; a2 <= max_a2; a2++) {
				func.test(a1, a2, a3);
			}
		} else {
			for (int a2 = min_a2; a2 >= max_a2; a2--) {
				func.test(a1, a2, a3);
			}
		}
	}

	/** From-To. Intended to be used with non-capturing lambda. */
	public static  void fromTill(int min_a2, int max_a2, T a1, byte a3, LObjIntBytePredicate func) {
		Null.nonNullArg(func, "func");
		if (min_a2 <= max_a2) {
			for (int a2 = min_a2; a2 < max_a2; a2++) {
				func.test(a1, a2, a3);
			}
		} else {
			for (int a2 = min_a2; a2 > max_a2; a2--) {
				func.test(a1, a2, a3);
			}
		}
	}

	/** From-To. Intended to be used with non-capturing lambda. */
	public static  void times(int max_a2, T a1, byte a3, LObjIntBytePredicate func) {
		if (max_a2 < 0)
			return;
		fromTill(0, max_a2, a1, a3, func);
	}

	/**  */
	public static  LObjIntBytePredicate uncurry(LFunction> func) {
		return (T a1, int a2, byte a3) -> func.apply(a1).apply(a2).test(a3);
	}

	/** Cast that removes generics. */
	public default LObjIntBytePredicate untyped() {
		return this;
	}

	/** Cast that replace generics. */
	public default  LObjIntBytePredicate cast() {
		return untyped();
	}

	/** Cast that replace generics. */
	public static  LObjIntBytePredicate cast(LObjIntBytePredicate function) {
		return (LObjIntBytePredicate) function;
	}

	/** Captures arguments but delays the evaluation. */
	default LBoolSupplier capture(T a1, int a2, byte a3) {
		return () -> this.test(a1, a2, a3);
	}

	/** Creates function that always returns the same value. */
	static  LObjIntBytePredicate constant(boolean r) {
		return (a1, a2, a3) -> r;
	}

	/** Captures single parameter function into this interface where only 1st parameter will be used. */
	@Nonnull
	static  LObjIntBytePredicate test1st(@Nonnull LPredicate func) {
		return (a1, a2, a3) -> func.test(a1);
	}

	/** Captures single parameter function into this interface where only 2nd parameter will be used. */
	@Nonnull
	static  LObjIntBytePredicate test2nd(@Nonnull LIntPredicate func) {
		return (a1, a2, a3) -> func.test(a2);
	}

	/** Captures single parameter function into this interface where only 3rd parameter will be used. */
	@Nonnull
	static  LObjIntBytePredicate test3rd(@Nonnull LBytePredicate func) {
		return (a1, a2, a3) -> func.test(a3);
	}

	/** Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces). */
	@Nonnull
	static  LObjIntBytePredicate objIntBytePred(final @Nonnull LObjIntBytePredicate lambda) {
		Null.nonNullArg(lambda, "lambda");
		return lambda;
	}

	@Nonnull
	static  LObjIntBytePredicate recursive(final @Nonnull LFunction, LObjIntBytePredicate> selfLambda) {
		final LObjIntBytePredicateSingle single = new LObjIntBytePredicateSingle();
		LObjIntBytePredicate func = selfLambda.apply(single);
		single.target = func;
		return func;
	}

	final class LObjIntBytePredicateSingle implements LSingle>, LObjIntBytePredicate {
		private LObjIntBytePredicate target = null;

		@Override
		public boolean testX(T a1, int a2, byte a3) throws Throwable {
			return target.testX(a1, a2, a3);
		}

		@Override
		public LObjIntBytePredicate value() {
			return target;
		}
	}

	@Nonnull
	static  LObjIntBytePredicate objIntBytePredThrowing(final @Nonnull ExF exF) {
		Null.nonNullArg(exF, "exF");
		return (a1, a2, a3) -> {
			throw exF.produce();
		};
	}

	@Nonnull
	static  LObjIntBytePredicate objIntBytePredThrowing(final String message, final @Nonnull ExMF exF) {
		Null.nonNullArg(exF, "exF");
		return (a1, a2, a3) -> {
			throw exF.produce(message);
		};
	}

	// 

	/** Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces). */
	@Nonnull
	static  LObjByteIntPred objByteIntPred(final @Nonnull LObjByteIntPred lambda) {
		Null.nonNullArg(lambda, "lambda");
		return lambda;
	}

	/** Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces). */
	@Nonnull
	static  LIntObjBytePred intObjBytePred(final @Nonnull LIntObjBytePred lambda) {
		Null.nonNullArg(lambda, "lambda");
		return lambda;
	}

	/** Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces). */
	@Nonnull
	static  LIntByteObjPred intByteObjPred(final @Nonnull LIntByteObjPred lambda) {
		Null.nonNullArg(lambda, "lambda");
		return lambda;
	}

	/** Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces). */
	@Nonnull
	static  LByteObjIntPred byteObjIntPred(final @Nonnull LByteObjIntPred lambda) {
		Null.nonNullArg(lambda, "lambda");
		return lambda;
	}

	/** Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces). */
	@Nonnull
	static  LByteIntObjPred byteIntObjPred(final @Nonnull LByteIntObjPred lambda) {
		Null.nonNullArg(lambda, "lambda");
		return lambda;
	}

	// 

	static  boolean call(T a1, int a2, byte a3, final @Nonnull LObjIntBytePredicate lambda) {
		Null.nonNullArg(lambda, "lambda");
		return lambda.test(a1, a2, a3);
	}

	// 

	// 

	// 

	/** Safe instance. That always returns the same value (as alwaysFalse). */
	@Nonnull
	static  LObjIntBytePredicate safe() {
		return LObjIntBytePredicate::alwaysFalse;
	}

	/** Safe instance supplier. Returns supplier of safe() instance. */
	@Nonnull
	static  LSupplier> safeSupplier() {
		return () -> safe();
	}

	/** Safe wrapping. Either argument function is returned (if it is not null) or safe() instance. */
	@Nonnull
	static  LObjIntBytePredicate safe(final @Nullable LObjIntBytePredicate other) {
		if (other == null) {
			return safe();
		} else {
			return other;
		}
	}

	/** Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance. */
	@Nonnull
	static  LSupplier> safeSupplier(final @Nullable LSupplier> supplier) {
		if (supplier == null) {
			return safeSupplier();
		} else {
			return supplier;
		}
	}

	// 
	// 

	/**
	 * Returns a predicate that represents the logical negation of this predicate.
	 *
	 * @see {@link java.util.function.Predicate#negate}
	 */
	@Nonnull
	default LObjIntBytePredicate negate() {
		return (a1, a2, a3) -> !test(a1, a2, a3);
	}

	/**
	 * Returns a predicate that represents the logical AND of evaluation of this predicate and the argument one.
	 * @see {@link java.util.function.Predicate#and()}
	 */
	@Nonnull
	default LObjIntBytePredicate and(@Nonnull LObjIntBytePredicate other) {
		Null.nonNullArg(other, "other");
		return (a1, a2, a3) -> test(a1, a2, a3) && other.test(a1, a2, a3);
	}

	/**
	 * Returns a predicate that represents the logical OR of evaluation of this predicate and the argument one.
	 * @see {@link java.util.function.Predicate#or}
	 */
	@Nonnull
	default LObjIntBytePredicate or(@Nonnull LObjIntBytePredicate other) {
		Null.nonNullArg(other, "other");
		return (a1, a2, a3) -> test(a1, a2, a3) || other.test(a1, a2, a3);
	}

	/**
	 * Returns a predicate that represents the logical XOR of evaluation of this predicate and the argument one.
	 * @see {@link java.util.function.Predicate#or}
	 */
	@Nonnull
	default LObjIntBytePredicate xor(@Nonnull LObjIntBytePredicate other) {
		Null.nonNullArg(other, "other");
		return (a1, a2, a3) -> test(a1, a2, a3) ^ other.test(a1, a2, a3);
	}

	/**
	 * Creates predicate that evaluates if an object is equal with the argument one.
	 * @see {@link java.util.function.Predicate#isEqual()
	 */
	@Nonnull
	static  LObjIntBytePredicate isEqual(T v1, int v2, byte v3) {
		return (a1, a2, a3) -> (a1 == null ? v1 == null : a1.equals(v1)) && (a2 == v2) && (a3 == v3);
	}

	// 

	// 

	/** Allows to manipulate the domain of the function. */
	@Nonnull
	default  LObjIntBytePredicate compose(@Nonnull final LFunction before1, @Nonnull final LIntUnaryOperator before2, @Nonnull final LByteUnaryOperator before3) {
		Null.nonNullArg(before1, "before1");
		Null.nonNullArg(before2, "before2");
		Null.nonNullArg(before3, "before3");
		return (v1, v2, v3) -> this.test(before1.apply(v1), before2.applyAsInt(v2), before3.applyAsByte(v3));
	}

	public static  LObjIntBytePredicate composed(@Nonnull final LFunction before1, @Nonnull final LIntUnaryOperator before2, @Nonnull final LByteUnaryOperator before3, LObjIntBytePredicate after) {
		return after.compose(before1, before2, before3);
	}

	/** Allows to manipulate the domain of the function. */
	@Nonnull
	default  LTriPredicate objIntBytePredCompose(@Nonnull final LFunction before1, @Nonnull final LToIntFunction before2, @Nonnull final LToByteFunction before3) {
		Null.nonNullArg(before1, "before1");
		Null.nonNullArg(before2, "before2");
		Null.nonNullArg(before3, "before3");
		return (v1, v2, v3) -> this.test(before1.apply(v1), before2.applyAsInt(v2), before3.applyAsByte(v3));
	}

	public static  LTriPredicate composed(@Nonnull final LFunction before1, @Nonnull final LToIntFunction before2, @Nonnull final LToByteFunction before3,
			LObjIntBytePredicate after) {
		return after.objIntBytePredCompose(before1, before2, before3);
	}

	// 

	// 

	/** Combines two functions together in a order. */
	@Nonnull
	default  LObjIntByteFunction boolToObjIntByteFunc(@Nonnull LBoolFunction after) {
		Null.nonNullArg(after, "after");
		return (a1, a2, a3) -> after.apply(this.test(a1, a2, a3));
	}

	/** Combines two functions together in a order. */
	@Nonnull
	default LTieByteFunction boolToTieByteFunc(@Nonnull LBoolToIntFunction after) {
		Null.nonNullArg(after, "after");
		return (a1, a2, a3) -> after.applyAsInt(this.test(a1, a2, a3));
	}

	/** Combines two functions together in a order. */
	@Nonnull
	default LObjIntBytePredicate boolToObjIntBytePred(@Nonnull LLogicalOperator after) {
		Null.nonNullArg(after, "after");
		return (a1, a2, a3) -> after.apply(this.test(a1, a2, a3));
	}

	// 

	// 

	// 

	// 

	/** Permutation of LObjIntBytePredicate for method references. */
	@FunctionalInterface
	interface LObjByteIntPred extends LObjIntBytePredicate {

		boolean testObjByteInt(T a1, byte a3, int a2);

		@Override
		default boolean testX(T a1, int a2, byte a3) {
			return this.testObjByteInt(a1, a3, a2);
		}
	}

	/** Permutation of LObjIntBytePredicate for method references. */
	@FunctionalInterface
	interface LIntObjBytePred extends LObjIntBytePredicate {

		boolean testIntObjByte(int a2, T a1, byte a3);

		@Override
		default boolean testX(T a1, int a2, byte a3) {
			return this.testIntObjByte(a2, a1, a3);
		}
	}

	/** Permutation of LObjIntBytePredicate for method references. */
	@FunctionalInterface
	interface LIntByteObjPred extends LObjIntBytePredicate {

		boolean testIntByteObj(int a2, byte a3, T a1);

		@Override
		default boolean testX(T a1, int a2, byte a3) {
			return this.testIntByteObj(a2, a3, a1);
		}
	}

	/** Permutation of LObjIntBytePredicate for method references. */
	@FunctionalInterface
	interface LByteObjIntPred extends LObjIntBytePredicate {

		boolean testByteObjInt(byte a3, T a1, int a2);

		@Override
		default boolean testX(T a1, int a2, byte a3) {
			return this.testByteObjInt(a3, a1, a2);
		}
	}

	/** Permutation of LObjIntBytePredicate for method references. */
	@FunctionalInterface
	interface LByteIntObjPred extends LObjIntBytePredicate {

		boolean testByteIntObj(byte a3, int a2, T a1);

		@Override
		default boolean testX(T a1, int a2, byte a3) {
			return this.testByteIntObj(a3, a2, a1);
		}
	}

	// 

	// >>> LObjIntBytePredicate

	/** Returns TRUE. */
	public static  boolean alwaysTrue(T a1, int a2, byte a3) {
		return true;
	}

	/** Returns FALSE. */
	public static  boolean alwaysFalse(T a1, int a2, byte a3) {
		return false;
	}

	// >>> LObjByteIntPred

	/** Returns TRUE. */
	public static  boolean alwaysTrue(T a1, byte a3, int a2) {
		return true;
	}

	/** Returns FALSE. */
	public static  boolean alwaysFalse(T a1, byte a3, int a2) {
		return false;
	}

	// >>> LIntObjBytePred

	/** Returns TRUE. */
	public static  boolean alwaysTrue(int a2, T a1, byte a3) {
		return true;
	}

	/** Returns FALSE. */
	public static  boolean alwaysFalse(int a2, T a1, byte a3) {
		return false;
	}

	// >>> LIntByteObjPred

	/** Returns TRUE. */
	public static  boolean alwaysTrue(int a2, byte a3, T a1) {
		return true;
	}

	/** Returns FALSE. */
	public static  boolean alwaysFalse(int a2, byte a3, T a1) {
		return false;
	}

	// >>> LByteObjIntPred

	/** Returns TRUE. */
	public static  boolean alwaysTrue(byte a3, T a1, int a2) {
		return true;
	}

	/** Returns FALSE. */
	public static  boolean alwaysFalse(byte a3, T a1, int a2) {
		return false;
	}

	// >>> LByteIntObjPred

	/** Returns TRUE. */
	public static  boolean alwaysTrue(byte a3, int a2, T a1) {
		return true;
	}

	/** Returns FALSE. */
	public static  boolean alwaysFalse(byte a3, int a2, T a1) {
		return false;
	}

	/**
	* 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.
	*/
	default  void filterForEach(IndexedRead> ia1, C1 source1, IndexedRead ia2, C2 source2, IndexedRead ia3, C3 source3, LTieByteConsumer consumer) {
		int size = ia1.size(source1);
		LOiFunction oiFunc1 = (LOiFunction) ia1.getter();
		size = Integer.min(size, ia2.size(source2));
		LOiToIntFunction oiFunc2 = (LOiToIntFunction) ia2.getter();
		size = Integer.min(size, ia3.size(source3));
		LOiToByteFunction oiFunc3 = (LOiToByteFunction) ia3.getter();
		int i = 0;
		for (; i < size; i++) {
			T a1 = oiFunc1.apply(source1, i);
			int a2 = oiFunc2.applyAsInt(source2, i);
			byte a3 = oiFunc3.applyAsByte(source3, i);
			doIf(a1, a2, a3, 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.
	*/
	default  void filterIterate(SequentialRead> sa1, C1 source1, IndexedRead ia2, C2 source2, IndexedRead ia3, C3 source3, LTieByteConsumer consumer) {
		Object iterator1 = ((LFunction) sa1.adapter()).apply(source1);
		LPredicate testFunc1 = (LPredicate) sa1.tester();
		LFunction nextFunc1 = (LFunction) sa1.supplier();
		int size = ia2.size(source2);
		LOiToIntFunction oiFunc2 = (LOiToIntFunction) ia2.getter();
		size = Integer.min(size, ia3.size(source3));
		LOiToByteFunction oiFunc3 = (LOiToByteFunction) ia3.getter();
		int i = 0;
		while (testFunc1.test(iterator1) && i < size) {
			T a1 = nextFunc1.apply(iterator1);
			int a2 = oiFunc2.applyAsInt(source2, i);
			byte a3 = oiFunc3.applyAsByte(source3, i);
			doIf(a1, a2, a3, consumer);
			i++;
		}
	}

	/**
	* 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.
	*/
	default  void filterIterate(IndexedRead> ia1, C1 source1, SequentialRead sa2, C2 source2, IndexedRead ia3, C3 source3, LTieByteConsumer consumer) {
		int size = ia1.size(source1);
		LOiFunction oiFunc1 = (LOiFunction) ia1.getter();
		Object iterator2 = ((LFunction) sa2.adapter()).apply(source2);
		LPredicate testFunc2 = (LPredicate) sa2.tester();
		LToIntFunction nextFunc2 = (LToIntFunction) sa2.supplier();
		size = Integer.min(size, ia3.size(source3));
		LOiToByteFunction oiFunc3 = (LOiToByteFunction) ia3.getter();
		int i = 0;
		while (i < size && testFunc2.test(iterator2)) {
			T a1 = oiFunc1.apply(source1, i);
			int a2 = nextFunc2.applyAsInt(iterator2);
			byte a3 = oiFunc3.applyAsByte(source3, i);
			doIf(a1, a2, a3, consumer);
			i++;
		}
	}

	/**
	* 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.
	*/
	default  void filterIterate(SequentialRead> sa1, C1 source1, SequentialRead sa2, C2 source2, IndexedRead ia3, C3 source3, LTieByteConsumer consumer) {
		Object iterator1 = ((LFunction) sa1.adapter()).apply(source1);
		LPredicate testFunc1 = (LPredicate) sa1.tester();
		LFunction nextFunc1 = (LFunction) sa1.supplier();
		Object iterator2 = ((LFunction) sa2.adapter()).apply(source2);
		LPredicate testFunc2 = (LPredicate) sa2.tester();
		LToIntFunction nextFunc2 = (LToIntFunction) sa2.supplier();
		int size = ia3.size(source3);
		LOiToByteFunction oiFunc3 = (LOiToByteFunction) ia3.getter();
		int i = 0;
		while (testFunc1.test(iterator1) && testFunc2.test(iterator2) && i < size) {
			T a1 = nextFunc1.apply(iterator1);
			int a2 = nextFunc2.applyAsInt(iterator2);
			byte a3 = oiFunc3.applyAsByte(source3, i);
			doIf(a1, a2, a3, consumer);
			i++;
		}
	}

	/**
	* 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.
	*/
	default  void filterIterate(IndexedRead> ia1, C1 source1, IndexedRead ia2, C2 source2, SequentialRead sa3, C3 source3, LTieByteConsumer consumer) {
		int size = ia1.size(source1);
		LOiFunction oiFunc1 = (LOiFunction) ia1.getter();
		size = Integer.min(size, ia2.size(source2));
		LOiToIntFunction oiFunc2 = (LOiToIntFunction) ia2.getter();
		Object iterator3 = ((LFunction) sa3.adapter()).apply(source3);
		LPredicate testFunc3 = (LPredicate) sa3.tester();
		LToByteFunction nextFunc3 = (LToByteFunction) sa3.supplier();
		int i = 0;
		while (i < size && testFunc3.test(iterator3)) {
			T a1 = oiFunc1.apply(source1, i);
			int a2 = oiFunc2.applyAsInt(source2, i);
			byte a3 = nextFunc3.applyAsByte(iterator3);
			doIf(a1, a2, a3, consumer);
			i++;
		}
	}

	/**
	* 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.
	*/
	default  void filterIterate(SequentialRead> sa1, C1 source1, IndexedRead ia2, C2 source2, SequentialRead sa3, C3 source3, LTieByteConsumer consumer) {
		Object iterator1 = ((LFunction) sa1.adapter()).apply(source1);
		LPredicate testFunc1 = (LPredicate) sa1.tester();
		LFunction nextFunc1 = (LFunction) sa1.supplier();
		int size = ia2.size(source2);
		LOiToIntFunction oiFunc2 = (LOiToIntFunction) ia2.getter();
		Object iterator3 = ((LFunction) sa3.adapter()).apply(source3);
		LPredicate testFunc3 = (LPredicate) sa3.tester();
		LToByteFunction nextFunc3 = (LToByteFunction) sa3.supplier();
		int i = 0;
		while (testFunc1.test(iterator1) && i < size && testFunc3.test(iterator3)) {
			T a1 = nextFunc1.apply(iterator1);
			int a2 = oiFunc2.applyAsInt(source2, i);
			byte a3 = nextFunc3.applyAsByte(iterator3);
			doIf(a1, a2, a3, consumer);
			i++;
		}
	}

	/**
	* 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.
	*/
	default  void filterIterate(IndexedRead> ia1, C1 source1, SequentialRead sa2, C2 source2, SequentialRead sa3, C3 source3, LTieByteConsumer consumer) {
		int size = ia1.size(source1);
		LOiFunction oiFunc1 = (LOiFunction) ia1.getter();
		Object iterator2 = ((LFunction) sa2.adapter()).apply(source2);
		LPredicate testFunc2 = (LPredicate) sa2.tester();
		LToIntFunction nextFunc2 = (LToIntFunction) sa2.supplier();
		Object iterator3 = ((LFunction) sa3.adapter()).apply(source3);
		LPredicate testFunc3 = (LPredicate) sa3.tester();
		LToByteFunction nextFunc3 = (LToByteFunction) sa3.supplier();
		int i = 0;
		while (i < size && testFunc2.test(iterator2) && testFunc3.test(iterator3)) {
			T a1 = oiFunc1.apply(source1, i);
			int a2 = nextFunc2.applyAsInt(iterator2);
			byte a3 = nextFunc3.applyAsByte(iterator3);
			doIf(a1, a2, a3, consumer);
			i++;
		}
	}

	/**
	* 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.
	*/
	default  void filterIterate(SequentialRead> sa1, C1 source1, SequentialRead sa2, C2 source2, SequentialRead sa3, C3 source3, LTieByteConsumer consumer) {
		Object iterator1 = ((LFunction) sa1.adapter()).apply(source1);
		LPredicate testFunc1 = (LPredicate) sa1.tester();
		LFunction nextFunc1 = (LFunction) sa1.supplier();
		Object iterator2 = ((LFunction) sa2.adapter()).apply(source2);
		LPredicate testFunc2 = (LPredicate) sa2.tester();
		LToIntFunction nextFunc2 = (LToIntFunction) sa2.supplier();
		Object iterator3 = ((LFunction) sa3.adapter()).apply(source3);
		LPredicate testFunc3 = (LPredicate) sa3.tester();
		LToByteFunction nextFunc3 = (LToByteFunction) sa3.supplier();
		while (testFunc1.test(iterator1) && testFunc2.test(iterator2) && testFunc3.test(iterator3)) {
			T a1 = nextFunc1.apply(iterator1);
			int a2 = nextFunc2.applyAsInt(iterator2);
			byte a3 = nextFunc3.applyAsByte(iterator3);
			doIf(a1, a2, a3, consumer);
		}
	}

}