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

eu.lunisolar.magma.func.consumer.primitives.bi.LBiDblConsumer 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.consumer.primitives.bi;

import javax.annotation.Nonnull; // NOSONAR
import javax.annotation.Nullable; // NOSONAR
import java.util.Objects; // NOSONAR
import eu.lunisolar.magma.basics.*; //NOSONAR
import eu.lunisolar.magma.basics.exceptions.*; // NOSONAR
import eu.lunisolar.magma.func.*; // 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.consumer.*; // NOSONAR
import eu.lunisolar.magma.func.*; // NOSONAR
import eu.lunisolar.magma.func.tuple.*; // NOSONAR
import java.util.function.*; // NOSONAR
import java.util.*;
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) LBiDblConsumer for Java 8.
 *
 * Type: consumer
 *
 * Domain (lvl: 2): double a1,double a2
 *
 * Co-domain: none
 *
 */
@FunctionalInterface
@SuppressWarnings("UnusedDeclaration")
public interface LBiDblConsumer extends MetaConsumer, MetaInterface.NonThrowing, Codomain, Domain2 {

	String DESCRIPTION = "LBiDblConsumer: void accept(double a1,double a2)";

	// void accept(double a1,double a2) ;
	default void accept(double a1, double a2) {
		// nestingAccept(a1,a2);
		try {
			this.acceptX(a1, a2);
		} catch (Throwable e) { // NOSONAR
			throw Handling.nestCheckedAndThrow(e);
		}
	}

	/**
	 * Implement this, but call accept(double a1,double a2)
	 */
	void acceptX(double a1, double a2) throws Throwable;

	default LTuple.Void tupleAccept(LDblPair args) {
		accept(args.first(), args.second());
		return LTuple.Void.INSTANCE;
	}

	/** Function call that handles exceptions according to the instructions. */
	default void handlingAccept(double a1, double a2, HandlingInstructions handling) {
		try {
			this.acceptX(a1, a2);
		} catch (Throwable e) { // NOSONAR
			throw Handler.handleOrNest(e, handling);
		}
	}

	default LBiDblConsumer handling(HandlingInstructions handling) {
		return (a1, a2) -> handlingAccept(a1, a2, handling);
	}

	default void accept(double a1, double a2, @Nonnull ExWMF exF, @Nonnull String newMessage, @Nullable Object... messageParams) {
		try {
			this.acceptX(a1, a2);
		} catch (Throwable e) { // NOSONAR
			throw Handling.wrap(e, exF, newMessage, messageParams);
		}
	}

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

	default void accept(double a1, double a2, @Nonnull ExWF exF) {
		try {
			this.acceptX(a1, a2);
		} catch (Throwable e) { // NOSONAR
			throw Handling.wrap(e, exF);
		}
	}

	default LBiDblConsumer trying(@Nonnull ExWF exF) {
		return (a1, a2) -> accept(a1, a2, exF);
	}

	default void acceptThen(double a1, double a2, @Nonnull LConsumer handler) {
		try {
			this.acceptX(a1, a2);
		} catch (Throwable e) { // NOSONAR
			Handling.handleErrors(e);
			handler.accept(e);
		}
	}

	default LBiDblConsumer tryingThen(@Nonnull LConsumer handler) {
		return (a1, a2) -> acceptThen(a1, a2, handler);
	}

	/** Function call that handles exceptions by always nesting checked exceptions and propagating the others as is. */
	default void nestingAccept(double a1, double a2) {
		try {
			this.acceptX(a1, a2);
		} 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 void shovingAccept(double a1, double a2) {
		try {
			this.acceptX(a1, a2);
		} catch (Throwable e) { // NOSONAR
			throw Handling.shoveIt(e);
		}
	}

	static void handlingAccept(double a1, double a2, LBiDblConsumer func, HandlingInstructions handling) { // <-
		Null.nonNullArg(func, "func");
		func.handlingAccept(a1, a2, handling);
	}

	static void tryAccept(double a1, double a2, LBiDblConsumer func) {
		Null.nonNullArg(func, "func");
		func.nestingAccept(a1, a2);
	}

	static void tryAccept(double a1, double a2, LBiDblConsumer func, @Nonnull ExWMF exF, @Nonnull String newMessage, @Nullable Object... messageParams) {
		Null.nonNullArg(func, "func");
		func.accept(a1, a2, exF, newMessage, messageParams);
	}

	static void tryAccept(double a1, double a2, LBiDblConsumer func, @Nonnull ExWF exF) {
		Null.nonNullArg(func, "func");
		func.accept(a1, a2, exF);
	}

	static void tryAcceptThen(double a1, double a2, LBiDblConsumer func, @Nonnull LConsumer handler) {
		Null.nonNullArg(func, "func");
		func.acceptThen(a1, a2, handler);
	}

	default void failSafeAccept(double a1, double a2, @Nonnull LBiDblConsumer failSafe) {
		try {
			accept(a1, a2);
		} catch (Throwable e) { // NOSONAR
			Handling.handleErrors(e);
			failSafe.accept(a1, a2);
		}
	}

	static void failSafeAccept(double a1, double a2, LBiDblConsumer func, @Nonnull LBiDblConsumer failSafe) {
		Null.nonNullArg(failSafe, "failSafe");
		if (func == null) {
			failSafe.accept(a1, a2);
		} else {
			func.failSafeAccept(a1, a2, failSafe);
		}
	}

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

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

	/** From-To. Intended to be used with non-capturing lambda. */
	public static void fromTo(int min_i, int max_i, double a1, double a2, LBiDblConsumer func) {
		Null.nonNullArg(func, "func");
		if (min_i <= max_i) {
			for (int i = min_i; i <= max_i; i++) {
				func.accept(a1, a2);
			}
		} else {
			for (int i = min_i; i >= max_i; i--) {
				func.accept(a1, a2);
			}
		}
	}

	/** From-To. Intended to be used with non-capturing lambda. */
	public static void fromTill(int min_i, int max_i, double a1, double a2, LBiDblConsumer func) {
		Null.nonNullArg(func, "func");
		if (min_i <= max_i) {
			for (int i = min_i; i < max_i; i++) {
				func.accept(a1, a2);
			}
		} else {
			for (int i = min_i; i > max_i; i--) {
				func.accept(a1, a2);
			}
		}
	}

	/** From-To. Intended to be used with non-capturing lambda. */
	public static void times(int max_i, double a1, double a2, LBiDblConsumer func) {
		if (max_i < 0)
			return;
		fromTill(0, max_i, a1, a2, func);
	}

	public default LDblConsumer lShrink(LDblUnaryOperator left) {
		return a2 -> accept(left.applyAsDbl(a2), a2);
	}

	public default LDblConsumer lShrinkc(double a1) {
		return a2 -> accept(a1, a2);
	}

	public static LDblConsumer lShrinked(LDblUnaryOperator left, LBiDblConsumer func) {
		return func.lShrink(left);
	}

	public static LDblConsumer lShrinkedc(double a1, LBiDblConsumer func) {
		return func.lShrinkc(a1);
	}

	public default LDblConsumer rShrink(LDblUnaryOperator right) {
		return a1 -> accept(a1, right.applyAsDbl(a1));
	}

	public default LDblConsumer rShrinkc(double a2) {
		return a1 -> accept(a1, a2);
	}

	public static LDblConsumer rShrinked(LDblUnaryOperator right, LBiDblConsumer func) {
		return func.rShrink(right);
	}

	public static LDblConsumer rShrinkedc(double a2, LBiDblConsumer func) {
		return func.rShrinkc(a2);
	}

	/**  */
	public static LBiDblConsumer uncurry(LDblFunction func) {
		return (double a1, double a2) -> func.apply(a1).accept(a2);
	}

	/** Captures arguments but delays the evaluation. */
	default LAction capture(double a1, double a2) {
		return () -> this.accept(a1, a2);
	}

	/** Captures single parameter function into this interface where only 1st parameter will be used. */
	@Nonnull
	static LBiDblConsumer accept1st(@Nonnull LDblConsumer func) {
		return (a1, a2) -> func.accept(a1);
	}

	/** Captures single parameter function into this interface where only 2nd parameter will be used. */
	@Nonnull
	static LBiDblConsumer accept2nd(@Nonnull LDblConsumer func) {
		return (a1, a2) -> func.accept(a2);
	}

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

	@Nonnull
	static LBiDblConsumer recursive(final @Nonnull LFunction selfLambda) {
		final LBiDblConsumerSingle single = new LBiDblConsumerSingle();
		LBiDblConsumer func = selfLambda.apply(single);
		single.target = func;
		return func;
	}

	final class LBiDblConsumerSingle implements LSingle, LBiDblConsumer {
		private LBiDblConsumer target = null;

		@Override
		public void acceptX(double a1, double a2) throws Throwable {
			target.acceptX(a1, a2);
		}

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

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

	@Nonnull
	static LBiDblConsumer biDblConsThrowing(final String message, final @Nonnull ExMF exF) {
		Null.nonNullArg(exF, "exF");
		return (a1, a2) -> {
			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 LDbl1Dbl0Cons dbl1Dbl0Cons(final @Nonnull LDbl1Dbl0Cons lambda) {
		Null.nonNullArg(lambda, "lambda");
		return lambda;
	}

	// 

	static void call(double a1, double a2, final @Nonnull LBiDblConsumer lambda) {
		Null.nonNullArg(lambda, "lambda");
		lambda.accept(a1, a2);
	}

	// 

	// 

	// 

	/** Safe instance. */
	@Nonnull
	static LBiDblConsumer safe() {
		return LBiDblConsumer::doNothing;
	}

	/** 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 LBiDblConsumer safe(final @Nullable LBiDblConsumer 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;
		}
	}

	// 

	// 

	/** Allows to manipulate the domain of the function. */
	@Nonnull
	default LBiDblConsumer compose(@Nonnull final LDblUnaryOperator before1, @Nonnull final LDblUnaryOperator before2) {
		Null.nonNullArg(before1, "before1");
		Null.nonNullArg(before2, "before2");
		return (v1, v2) -> this.accept(before1.applyAsDbl(v1), before2.applyAsDbl(v2));
	}

	public static LBiDblConsumer composed(@Nonnull final LDblUnaryOperator before1, @Nonnull final LDblUnaryOperator before2, LBiDblConsumer after) {
		return after.compose(before1, before2);
	}

	/** Allows to manipulate the domain of the function. */
	@Nonnull
	default  LBiConsumer biDblConsCompose(@Nonnull final LToDblFunction before1, @Nonnull final LToDblFunction before2) {
		Null.nonNullArg(before1, "before1");
		Null.nonNullArg(before2, "before2");
		return (v1, v2) -> this.accept(before1.applyAsDbl(v1), before2.applyAsDbl(v2));
	}

	public static  LBiConsumer composed(@Nonnull final LToDblFunction before1, @Nonnull final LToDblFunction before2, LBiDblConsumer after) {
		return after.biDblConsCompose(before1, before2);
	}

	// 

	// 

	/** Combines two LBiDblConsumer together in a order. */
	@Nonnull
	default LBiDblConsumer andThen(@Nonnull LBiDblConsumer after) {
		Null.nonNullArg(after, "after");
		return (a1, a2) -> {
			this.accept(a1, a2);
			after.accept(a1, a2);
		};
	}

	// 

	// 

	// 

	// 

	/** Permutation of LBiDblConsumer for method references. */
	@FunctionalInterface
	interface LDbl1Dbl0Cons extends LBiDblConsumer {

		void acceptDbl1Dbl0(double a2, double a1);

		@Override
		default void acceptX(double a1, double a2) {
			this.acceptDbl1Dbl0(a2, a1);
		}
	}

	// 

	/** Does nothing (LBiDblConsumer) */
	public static void doNothing(double a1, double a2) {
		// NOSONAR
	}

	/**
	* For each element (or tuple) from arguments, calls the consumer.
	* Thread safety, fail-fast, fail-safety of this method is not expected.
	* @returns iterations count
	*/
	public static  int forEach(IndexedRead ia1, C1 source1, IndexedRead ia2, C2 source2, LBiDblConsumer consumer) {
		int size = ia1.size(source1);
		LOiToDblFunction oiFunc1 = (LOiToDblFunction) ia1.getter();
		size = Integer.min(size, ia2.size(source2));
		LOiToDblFunction oiFunc2 = (LOiToDblFunction) ia2.getter();
		int i = 0;
		for (; i < size; i++) {
			double a1 = oiFunc1.applyAsDbl(source1, i);
			double a2 = oiFunc2.applyAsDbl(source2, i);
			consumer.accept(a1, a2);
		}
		return i;

	}

	/**
	* For each element (or tuple) from arguments, calls the consumer.
	* Thread safety, fail-fast, fail-safety of this method is not expected.
	* @returns iterations count
	*/
	public static  int iterate(SequentialRead sa1, C1 source1, IndexedRead ia2, C2 source2, LBiDblConsumer consumer) {
		Object iterator1 = ((LFunction) sa1.adapter()).apply(source1);
		LPredicate testFunc1 = (LPredicate) sa1.tester();
		LToDblFunction nextFunc1 = (LToDblFunction) sa1.supplier();
		int size = ia2.size(source2);
		LOiToDblFunction oiFunc2 = (LOiToDblFunction) ia2.getter();
		int i = 0;
		while (testFunc1.test(iterator1) && i < size) {
			double a1 = nextFunc1.applyAsDbl(iterator1);
			double a2 = oiFunc2.applyAsDbl(source2, i);
			consumer.accept(a1, a2);
			i++;
		}
		return i;

	}

	/**
	* For each element (or tuple) from arguments, calls the consumer.
	* Thread safety, fail-fast, fail-safety of this method is not expected.
	* @returns iterations count
	*/
	public static  int iterate(IndexedRead ia1, C1 source1, SequentialRead sa2, C2 source2, LBiDblConsumer consumer) {
		int size = ia1.size(source1);
		LOiToDblFunction oiFunc1 = (LOiToDblFunction) ia1.getter();
		Object iterator2 = ((LFunction) sa2.adapter()).apply(source2);
		LPredicate testFunc2 = (LPredicate) sa2.tester();
		LToDblFunction nextFunc2 = (LToDblFunction) sa2.supplier();
		int i = 0;
		while (i < size && testFunc2.test(iterator2)) {
			double a1 = oiFunc1.applyAsDbl(source1, i);
			double a2 = nextFunc2.applyAsDbl(iterator2);
			consumer.accept(a1, a2);
			i++;
		}
		return i;

	}

	/**
	* For each element (or tuple) from arguments, calls the consumer.
	* Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.
	* @returns iterations count
	*/
	public static  int iterate(SequentialRead sa1, C1 source1, SequentialRead sa2, C2 source2, LBiDblConsumer consumer) {
		Object iterator1 = ((LFunction) sa1.adapter()).apply(source1);
		LPredicate testFunc1 = (LPredicate) sa1.tester();
		LToDblFunction nextFunc1 = (LToDblFunction) sa1.supplier();
		Object iterator2 = ((LFunction) sa2.adapter()).apply(source2);
		LPredicate testFunc2 = (LPredicate) sa2.tester();
		LToDblFunction nextFunc2 = (LToDblFunction) sa2.supplier();
		int i = 0;
		while (testFunc1.test(iterator1) && testFunc2.test(iterator2)) {
			double a1 = nextFunc1.applyAsDbl(iterator1);
			double a2 = nextFunc2.applyAsDbl(iterator2);
			consumer.accept(a1, a2);
			i++;
		}
		return i;

	}

	/**
	* For each element (or tuple) from arguments, calls the consumer. First argument is designated as 'target' object.
	* Thread safety, fail-fast, fail-safety of this method is not expected.
	* @returns 'target' object
	*/
	public static  double targetedForEach(double a1, IndexedRead ia2, C2 source2, LBiDblConsumer consumer) {
		int size = ia2.size(source2);
		LOiToDblFunction oiFunc2 = (LOiToDblFunction) ia2.getter();
		int i = 0;
		for (; i < size; i++) {
			double a2 = oiFunc2.applyAsDbl(source2, i);
			consumer.accept(a1, a2);
		}
		return a1;

	}

	/**
	* For each element (or tuple) from arguments, calls the consumer. First argument is designated as 'target' object.
	* Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.
	* @returns 'target' object
	*/
	public static  double targetedIterate(double a1, SequentialRead sa2, C2 source2, LBiDblConsumer consumer) {
		Object iterator2 = ((LFunction) sa2.adapter()).apply(source2);
		LPredicate testFunc2 = (LPredicate) sa2.tester();
		LToDblFunction nextFunc2 = (LToDblFunction) sa2.supplier();
		while (testFunc2.test(iterator2)) {
			double a2 = nextFunc2.applyAsDbl(iterator2);
			consumer.accept(a1, a2);
		}
		return a1;

	}

}