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

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

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) LObjIntConsumer for Java 8.
 *
 * Type: consumer
 *
 * Domain (lvl: 2): T a1,int a2
 *
 * Co-domain: none
 *
 * Special case of consumer that corresponds to expressions like     (list, element) -> List::add
 *
 */
@FunctionalInterface
@SuppressWarnings("UnusedDeclaration")
public interface LObjIntConsumer extends ObjIntConsumer, MetaConsumer, MetaInterface.NonThrowing, TeConsumer, Codomain, Domain2, aInt> {

	String DESCRIPTION = "LObjIntConsumer: void accept(T a1,int a2)";

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

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

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

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

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

	default void accept(T a1, int 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 LObjIntConsumer trying(@Nonnull ExWMF exF, @Nonnull String newMessage, @Nullable Object... messageParams) {
		return (a1, a2) -> accept(a1, a2, exF, newMessage, messageParams);
	}

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

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

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

	default LObjIntConsumer 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(T a1, int 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(T a1, int a2) {
		try {
			this.acceptX(a1, a2);
		} catch (Throwable e) { // NOSONAR
			throw Handling.shoveIt(e);
		}
	}

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

	static  void tryAccept(T a1, int a2, LObjIntConsumer func) {
		Null.nonNullArg(func, "func");
		func.nestingAccept(a1, a2);
	}

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

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

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

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

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

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

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

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

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

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

	public default LIntConsumer lShrink(LIntFunction left) {
		return a2 -> accept(left.apply(a2), a2);
	}

	public default LIntConsumer lShrinkc(T a1) {
		return a2 -> accept(a1, a2);
	}

	public static  LIntConsumer lShrinked(LIntFunction left, LObjIntConsumer func) {
		return func.lShrink(left);
	}

	public static  LIntConsumer lShrinkedc(T a1, LObjIntConsumer func) {
		return func.lShrinkc(a1);
	}

	public default LConsumer rShrink(LToIntFunction right) {
		return a1 -> accept(a1, right.applyAsInt(a1));
	}

	public default LConsumer rShrinkc(int a2) {
		return a1 -> accept(a1, a2);
	}

	public static  LConsumer rShrinked(LToIntFunction right, LObjIntConsumer func) {
		return func.rShrink(right);
	}

	public static  LConsumer rShrinkedc(int a2, LObjIntConsumer func) {
		return func.rShrinkc(a2);
	}

	/**  */
	public static  LObjIntConsumer uncurry(LFunction func) {
		return (T a1, int a2) -> func.apply(a1).accept(a2);
	}

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

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

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

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

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

	/** Captures single parameter function into this interface where only 2nd parameter will be used. */
	@Nonnull
	static  LObjIntConsumer accept2nd(@Nonnull LIntConsumer 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  LObjIntConsumer objIntCons(final @Nonnull LObjIntConsumer lambda) {
		Null.nonNullArg(lambda, "lambda");
		return lambda;
	}

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

	final class LObjIntConsumerSingle implements LSingle>, LObjIntConsumer {
		private LObjIntConsumer target = null;

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

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

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

	@Nonnull
	static  LObjIntConsumer objIntConsThrowing(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  LIntObjCons intObjCons(final @Nonnull LIntObjCons lambda) {
		Null.nonNullArg(lambda, "lambda");
		return lambda;
	}

	// 

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

	// 

	/** Wraps JRE instance. */
	@Nonnull
	static  LObjIntConsumer wrap(final ObjIntConsumer other) {
		return other::accept;
	}
	// 

	// 

	/** Safe instance. */
	@Nonnull
	static  LObjIntConsumer safe() {
		return LObjIntConsumer::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  LObjIntConsumer safe(final @Nullable LObjIntConsumer 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  LObjIntConsumer compose(@Nonnull final LFunction before1, @Nonnull final LIntUnaryOperator before2) {
		Null.nonNullArg(before1, "before1");
		Null.nonNullArg(before2, "before2");
		return (v1, v2) -> this.accept(before1.apply(v1), before2.applyAsInt(v2));
	}

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

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

	public static  LBiConsumer composed(@Nonnull final LFunction before1, @Nonnull final LToIntFunction before2, LObjIntConsumer after) {
		return after.objIntConsCompose(before1, before2);
	}

	// 

	// 

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

	// 

	// 

	// 

	// 

	/** Permutation of LObjIntConsumer for method references. */
	@FunctionalInterface
	interface LIntObjCons extends LObjIntConsumer {

		void acceptIntObj(int a2, T a1);

		@Override
		default void acceptX(T a1, int a2) {
			this.acceptIntObj(a2, a1);
		}
	}

	// 

	/** Does nothing (LObjIntConsumer) */
	public static  void doNothing(T a1, int a2) {
		// NOSONAR
	}

	/** Does nothing (LObjIntConsumer.LIntObjCons) */
	public static  void doNothing(int a2, T a1) {
		// 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, LObjIntConsumer consumer) {
		int size = ia1.size(source1);
		LOiFunction oiFunc1 = (LOiFunction) ia1.getter();
		size = Integer.min(size, ia2.size(source2));
		LOiToIntFunction oiFunc2 = (LOiToIntFunction) ia2.getter();
		int i = 0;
		for (; i < size; i++) {
			T a1 = oiFunc1.apply(source1, i);
			int a2 = oiFunc2.applyAsInt(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, LObjIntConsumer 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();
		int i = 0;
		while (testFunc1.test(iterator1) && i < size) {
			T a1 = nextFunc1.apply(iterator1);
			int a2 = oiFunc2.applyAsInt(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, LObjIntConsumer 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();
		int i = 0;
		while (i < size && testFunc2.test(iterator2)) {
			T a1 = oiFunc1.apply(source1, i);
			int a2 = nextFunc2.applyAsInt(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, LObjIntConsumer 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 i = 0;
		while (testFunc1.test(iterator1) && testFunc2.test(iterator2)) {
			T a1 = nextFunc1.apply(iterator1);
			int a2 = nextFunc2.applyAsInt(iterator2);
			consumer.accept(a1, a2);
			i++;
		}
		return i;

	}

	/**
	* For each element (or tuple) from arguments, calls the consumer (with index).
	* Thread safety, fail-fast, fail-safety of this method is not expected.
	* @returns iterations count
	*/
	public static  int indexedForEach(IndexedRead> ia1, C1 source1, LObjIntConsumer consumer) {
		int size = ia1.size(source1);
		LOiFunction oiFunc1 = (LOiFunction) ia1.getter();
		int a2 = 0;
		for (; a2 < size; a2++) {
			T a1 = oiFunc1.apply(source1, a2);
			consumer.accept(a1, a2);
		}
		return a2;

	}

	/**
	* For each element (or tuple) from arguments, calls the consumer (with index).
	* Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.
	* @returns iterations count
	*/
	public static  int indexedIterate(SequentialRead> sa1, C1 source1, LObjIntConsumer consumer) {
		Object iterator1 = ((LFunction) sa1.adapter()).apply(source1);
		LPredicate testFunc1 = (LPredicate) sa1.tester();
		LFunction nextFunc1 = (LFunction) sa1.supplier();
		int a2 = 0;
		while (testFunc1.test(iterator1)) {
			T a1 = nextFunc1.apply(iterator1);
			consumer.accept(a1, a2);
			a2++;
		}
		return a2;

	}

	/**
	* 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  T targetedForEach(T a1, IndexedRead ia2, C2 source2, LObjIntConsumer consumer) {
		int size = ia2.size(source2);
		LOiToIntFunction oiFunc2 = (LOiToIntFunction) ia2.getter();
		int i = 0;
		for (; i < size; i++) {
			int a2 = oiFunc2.applyAsInt(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  T targetedIterate(T a1, SequentialRead sa2, C2 source2, LObjIntConsumer consumer) {
		Object iterator2 = ((LFunction) sa2.adapter()).apply(source2);
		LPredicate testFunc2 = (LPredicate) sa2.tester();
		LToIntFunction nextFunc2 = (LToIntFunction) sa2.supplier();
		while (testFunc2.test(iterator2)) {
			int a2 = nextFunc2.applyAsInt(iterator2);
			consumer.accept(a1, a2);
		}
		return a1;

	}

	/** ***ITERATION:    TE_CONSUMER_GEN_IA:  FOR, [SourcePurpose{arg=T a1, type=CONST}, SourcePurpose{arg=int a2, type=IA}] */
	default  T genericForEach(T a1, IndexedRead ia2, C2 source2) {
		return targetedForEach(a1, ia2, source2, (LObjIntConsumer) this);
	}

	/** ***ITERATION:    TE_CONSUMER_GEN_SA:  WHILE, [SourcePurpose{arg=T a1, type=CONST}, SourcePurpose{arg=int a2, type=SA}] */
	default  T genericIterate(T a1, SequentialRead sa2, C2 source2) {
		return targetedIterate(a1, sa2, source2, (LObjIntConsumer) this);
	}

}