• Home
• eu.lunisolar.magma
• magma-func
• 2.0.0
• source code
• LTieIntConsumer.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

eu.lunisolar.magma.func.consumer.primitives.obj.LTieIntConsumer Maven / Gradle / Ivy

/*
 * 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) LTieIntConsumer for Java 8.
 *
 * Type: consumer
 *
 * Domain (lvl: 3): T a1,int a2,int a3
 *
 * Co-domain: none
 *
 * Special case of consumer that corresponds to expressions like     (list, index, element) -> List::set    or  (list, index, element) -> Array::set  
 *
 */
@FunctionalInterface
@SuppressWarnings("UnusedDeclaration")
public interface LTieIntConsumer extends MetaConsumer, MetaInterface.NonThrowing, TieConsumer, Codomain, Domain3, aInt, aInt> {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	public default LTieIntFunction toTieFunction() {
		return (t, i, e) -> {
			this.accept(t, i, e);
			return 1;
		};
	}

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

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

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

	public default LBiIntConsumer lShrink(LBiIntFunction left) {
		return (a2, a3) -> accept(left.apply(a2, a3), a2, a3);
	}

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

	public static  LBiIntConsumer lShrinked(LBiIntFunction left, LTieIntConsumer func) {
		return func.lShrink(left);
	}

	public static  LBiIntConsumer lShrinkedc(T a1, LTieIntConsumer func) {
		return func.lShrinkc(a1);
	}

	public default LObjIntConsumer rShrink(LOiToIntFunction right) {
		return (a1, a2) -> accept(a1, a2, right.applyAsInt(a1, a2));
	}

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

	public static  LObjIntConsumer rShrinked(LOiToIntFunction right, LTieIntConsumer func) {
		return func.rShrink(right);
	}

	public static  LObjIntConsumer rShrinkedc(int a3, LTieIntConsumer func) {
		return func.rShrinkc(a3);
	}

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

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

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

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

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

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

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

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

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

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

	final class LTieIntConsumerSingle implements LSingle>, LTieIntConsumer {
		private LTieIntConsumer target = null;

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

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

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

	@Nonnull
	static  LTieIntConsumer tieIntConsThrowing(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  LObj0Int2Int1Cons obj0Int2Int1Cons(final @Nonnull LObj0Int2Int1Cons 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  LInt1Obj0Int2Cons int1Obj0Int2Cons(final @Nonnull LInt1Obj0Int2Cons 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  LInt1Int2Obj0Cons int1Int2Obj0Cons(final @Nonnull LInt1Int2Obj0Cons 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  LInt2Obj0Int1Cons int2Obj0Int1Cons(final @Nonnull LInt2Obj0Int1Cons 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  LBiInt1Obj0Cons biInt1Obj0Cons(final @Nonnull LBiInt1Obj0Cons lambda) {
		Null.nonNullArg(lambda, "lambda");
		return lambda;
	}

	// 

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

	// 

	// 

	// 

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

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

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

	public static  LTriConsumer composed(@Nonnull final LFunction before1, @Nonnull final LToIntFunction before2, @Nonnull final LToIntFunction before3, LTieIntConsumer after) {
		return after.tieIntConsCompose(before1, before2, before3);
	}

	// 

	// 

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

	// 

	// 

	// 

	// 

	/** Permutation of LTieIntConsumer for method references. */
	@FunctionalInterface
	interface LObj0Int2Int1Cons extends LTieIntConsumer {

		void acceptObj0Int2Int1(T a1, int a3, int a2);

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

	/** Permutation of LTieIntConsumer for method references. */
	@FunctionalInterface
	interface LInt1Obj0Int2Cons extends LTieIntConsumer {

		void acceptInt1Obj0Int2(int a2, T a1, int a3);

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

	/** Permutation of LTieIntConsumer for method references. */
	@FunctionalInterface
	interface LInt1Int2Obj0Cons extends LTieIntConsumer {

		void acceptInt1Int2Obj0(int a2, int a3, T a1);

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

	/** Permutation of LTieIntConsumer for method references. */
	@FunctionalInterface
	interface LInt2Obj0Int1Cons extends LTieIntConsumer {

		void acceptInt2Obj0Int1(int a3, T a1, int a2);

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

	/** Permutation of LTieIntConsumer for method references. */
	@FunctionalInterface
	interface LBiInt1Obj0Cons extends LTieIntConsumer {

		void acceptBiInt1Obj0(int a3, int a2, T a1);

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

	// 

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

	/** Does nothing (LTieIntConsumer.LInt1Obj0Int2Cons) */
	public static  void doNothing(int a2, T a1, int a3) {
		// NOSONAR
	}

	/** Does nothing (LTieIntConsumer.LInt1Int2Obj0Cons) */
	public static  void doNothing(int a2, int a3, 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, IndexedRead ia3, C3 source3, LTieIntConsumer consumer) {
		int size = ia1.size(source1);
		LOiFunction oiFunc1 = (LOiFunction) ia1.getter();
		size = Integer.min(size, ia2.size(source2));
		LOiToIntFunction