eu.lunisolar.magma.func.operator.binary

Interface LLongBinaryOperator

All Superinterfaces:

Codomain<aType.aLong>, Domain, Domain2<aType.aLong,aType.aLong>, Formattable, java.util.function.LongBinaryOperator, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaOperator

All Known Implementing Classes:

LLongBinaryOperator.LLongBinaryOperatorSingle

@FunctionalInterface
public interface LLongBinaryOperator
extends java.util.function.LongBinaryOperator, MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aLong>, Domain2<aType.aLong,aType.aLong>

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

Type: operator

Domain (lvl: 2): long a1,long a2

Co-domain: long

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LLongBinaryOperator.LLongBinaryOperatorSingle

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 LLongBinaryOperator	apply1stAsLong(LLongUnaryOperator func) Captures single parameter function into this interface where only 1st parameter will be used.
static LLongBinaryOperator	apply2ndAsLong(LLongUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
default long	applyAsLong(long a1, long a2)
default long	applyAsLong(long a1, long a2, ExWF<RuntimeException> exF)
default long	applyAsLong(long a1, long a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default long	applyAsLongThen(long a1, long a2, LToLongFunction<Throwable> handler)
long	applyAsLongX(long a1, long a2) Implement this, but call applyAsLong(long a1,long a2)
static long	call(long a1, long a2, LLongBinaryOperator lambda)
default LLongSupplier	capture(long a1, long a2) Captures arguments but delays the evaluation.
default LLongBinaryOperator	compose(LLongUnaryOperator before1, LLongUnaryOperator before2) Allows to manipulate the domain of the function.
static LLongBinaryOperator	composed(LLongUnaryOperator before1, LLongUnaryOperator before2, LLongBinaryOperator after)
static <V1,V2> LToLongBiFunction<V1,V2>	composed(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2, LLongBinaryOperator after)
static LLongBinaryOperator	constant(long r) Creates function that always returns the same value.
static LLongBinaryOperator	failSafe(LLongBinaryOperator func, LLongBinaryOperator failSafe)
default long	failSafeApplyAsLong(long a1, long a2, LLongBinaryOperator failSafe)
static long	failSafeApplyAsLong(long a1, long a2, LLongBinaryOperator func, LLongBinaryOperator failSafe)
default <C1,C2> void	forEach(IndexedRead<C1,aType.aLong> ia1, C1 source1, IndexedRead<C2,aType.aLong> ia2, C2 source2, LLongConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static void	fromTill(int min_i, int max_i, long a1, long a2, LLongBinaryOperator func) From-To.
static void	fromTo(int min_i, int max_i, long a1, long a2, LLongBinaryOperator func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LLongBinaryOperator	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default long	handlingApplyAsLong(long a1, long a2, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static long	handlingApplyAsLong(long a1, long a2, LLongBinaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C1,C2,I2> void	iterate(IndexedRead<C1,aType.aLong> ia1, C1 source1, SequentialRead<C2,I2,aType.aLong> sa2, C2 source2, LLongConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	iterate(SequentialRead<C1,I1,aType.aLong> sa1, C1 source1, IndexedRead<C2,aType.aLong> ia2, C2 source2, LLongConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	iterate(SequentialRead<C1,I1,aType.aLong> sa1, C1 source1, SequentialRead<C2,I2,aType.aLong> sa2, C2 source2, LLongConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static LLongBinaryOperator	longBinaryOp(LLongBinaryOperator lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V1,V2> LToLongBiFunction<V1,V2>	longBinaryOpCompose(LToLongFunction<? super V1> before1, LToLongFunction<? super V2> before2) Allows to manipulate the domain of the function.
static LLongBinaryOperator	longBinaryOpThrowing(ExF<Throwable> exF)
static LLongBinaryOperator	longBinaryOpThrowing(String message, ExMF<Throwable> exF)
default LLongUnaryOperator	lShrink(LLongUnaryOperator left)
default LLongUnaryOperator	lShrinkc(long a1)
static LLongUnaryOperator	lShrinked(LLongUnaryOperator left, LLongBinaryOperator func)
static LLongUnaryOperator	lShrinkedc(long a1, LLongBinaryOperator func)
static LLongBinaryOperator	max() Returns function that returns the higher value.
static LLongBinaryOperator	maxBy(Comparator<Long> comparator) Creates function that returns the lesser value according to the comparator.
static LLongBinaryOperator	min() Returns function that returns the lower value.
static LLongBinaryOperator	minBy(Comparator<Long> comparator) Creates function that returns the lesser value according to the comparator.
default long	nestingApplyAsLong(long a1, long a2) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default long	nonNullApplyAsLong(long a1, long a2) Just to mirror the method: Ensures the result is not null
static long	produceLong(long a1, long a2) Does nothing (LLongBinaryOperator) Operator
static LLongBinaryOperator	recursive(LFunction<LLongBinaryOperator,LLongBinaryOperator> selfLambda)
default LLongUnaryOperator	rShrink(LLongUnaryOperator right)
default LLongUnaryOperator	rShrinkc(long a2)
static LLongUnaryOperator	rShrinked(LLongUnaryOperator right, LLongBinaryOperator func)
static LLongUnaryOperator	rShrinkedc(long a2, LLongBinaryOperator func)
static LLongBinaryOperator	safe() Safe instance.
static LLongBinaryOperator	safe(LLongBinaryOperator other) Safe wrapping.
static LSupplier<LLongBinaryOperator>	safeSupplier() Safe instance supplier.
static LSupplier<LLongBinaryOperator>	safeSupplier(LSupplier<LLongBinaryOperator> supplier) Safe supplier.
default long	shovingApplyAsLong(long a1, long a2) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LBiLongFunction<V>	then(LLongFunction<? extends V> after) Combines two functions together in a order.
default LBiLongPredicate	thenToBool(LLongPredicate after) Combines two functions together in a order.
default LLongBinaryOperator	thenToLong(LLongUnaryOperator after) Combines two functions together in a order.
static void	times(int max_i, long a1, long a2, LLongBinaryOperator func) From-To.
static long	tryApplyAsLong(long a1, long a2, LLongBinaryOperator func)
static long	tryApplyAsLong(long a1, long a2, LLongBinaryOperator func, ExWF<RuntimeException> exF)
static long	tryApplyAsLong(long a1, long a2, LLongBinaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static long	tryApplyAsLongThen(long a1, long a2, LLongBinaryOperator func, LToLongFunction<Throwable> handler)
default LLongBinaryOperator	trying(ExWF<RuntimeException> exF)
default LLongBinaryOperator	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LLongBinaryOperator	tryingThen(LToLongFunction<Throwable> handler)
default long	tupleApplyAsLong(LLongPair args)
static LLongBinaryOperator	uncurry(LLongFunction<LLongUnaryOperator> func)
static LLongBinaryOperator	wrap(java.util.function.LongBinaryOperator other) Wraps JRE instance.

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

isOperator

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, isPredicate, 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

applyAsLong

default long applyAsLong(long a1,
                         long a2)

Specified by:

applyAsLong in interface java.util.function.LongBinaryOperator

applyAsLongX

long applyAsLongX(long a1,
                  long a2)
           throws Throwable

Implement this, but call applyAsLong(long a1,long a2)

Throws:

Throwable

tupleApplyAsLong

default long tupleApplyAsLong(LLongPair args)

handlingApplyAsLong

default long handlingApplyAsLong(long a1,
                                 long a2,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LLongBinaryOperator handling(HandlingInstructions<Throwable,RuntimeException> handling)

applyAsLong

default long applyAsLong(long a1,
                         long a2,
                         @Nonnull
                         ExWMF<RuntimeException> exF,
                         @Nonnull
                         String newMessage,
                         @Nullable
                         Object... messageParams)

trying

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

applyAsLong

default long applyAsLong(long a1,
                         long a2,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

default LLongBinaryOperator trying(@Nonnull
                                   ExWF<RuntimeException> exF)

applyAsLongThen

default long applyAsLongThen(long a1,
                             long a2,
                             @Nonnull
                             LToLongFunction<Throwable> handler)

tryingThen

default LLongBinaryOperator tryingThen(@Nonnull
                                       LToLongFunction<Throwable> handler)

nestingApplyAsLong

default long nestingApplyAsLong(long a1,
                                long a2)

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

shovingApplyAsLong

default long shovingApplyAsLong(long a1,
                                long a2)

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

handlingApplyAsLong

static long handlingApplyAsLong(long a1,
                                long a2,
                                LLongBinaryOperator func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsLong

static long tryApplyAsLong(long a1,
                           long a2,
                           LLongBinaryOperator func)

tryApplyAsLong

static long tryApplyAsLong(long a1,
                           long a2,
                           LLongBinaryOperator func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsLong

static long tryApplyAsLong(long a1,
                           long a2,
                           LLongBinaryOperator func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsLongThen

static long tryApplyAsLongThen(long a1,
                               long a2,
                               LLongBinaryOperator func,
                               @Nonnull
                               LToLongFunction<Throwable> handler)

failSafeApplyAsLong

default long failSafeApplyAsLong(long a1,
                                 long a2,
                                 @Nonnull
                                 LLongBinaryOperator failSafe)

failSafeApplyAsLong

static long failSafeApplyAsLong(long a1,
                                long a2,
                                LLongBinaryOperator func,
                                @Nonnull
                                LLongBinaryOperator failSafe)

failSafe

static LLongBinaryOperator failSafe(LLongBinaryOperator func,
                                    @Nonnull
                                    LLongBinaryOperator failSafe)

nonNullApplyAsLong

default long nonNullApplyAsLong(long a1,
                                long a2)

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

functionalInterfaceDescription

@Nonnull
default String functionalInterfaceDescription()

Returns description of the functional interface.

Specified by:

functionalInterfaceDescription in interface MetaFunctionalInterface

fromTo

static void fromTo(int min_i,
                   int max_i,
                   long a1,
                   long a2,
                   LLongBinaryOperator func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     long a1,
                     long a2,
                     LLongBinaryOperator func)

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

times

static void times(int max_i,
                  long a1,
                  long a2,
                  LLongBinaryOperator func)

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

lShrink

default LLongUnaryOperator lShrink(LLongUnaryOperator left)

lShrinkc

default LLongUnaryOperator lShrinkc(long a1)

lShrinked

static LLongUnaryOperator lShrinked(LLongUnaryOperator left,
                                    LLongBinaryOperator func)

lShrinkedc

static LLongUnaryOperator lShrinkedc(long a1,
                                     LLongBinaryOperator func)

rShrink

default LLongUnaryOperator rShrink(LLongUnaryOperator right)

rShrinkc

default LLongUnaryOperator rShrinkc(long a2)

rShrinked

static LLongUnaryOperator rShrinked(LLongUnaryOperator right,
                                    LLongBinaryOperator func)

rShrinkedc

static LLongUnaryOperator rShrinkedc(long a2,
                                     LLongBinaryOperator func)

uncurry

static LLongBinaryOperator uncurry(LLongFunction<LLongUnaryOperator> func)

capture

default LLongSupplier capture(long a1,
                              long a2)

Captures arguments but delays the evaluation.

constant

static LLongBinaryOperator constant(long r)

Creates function that always returns the same value.

apply1stAsLong

@Nonnull
static LLongBinaryOperator apply1stAsLong(@Nonnull
                                                    LLongUnaryOperator func)

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

apply2ndAsLong

@Nonnull
static LLongBinaryOperator apply2ndAsLong(@Nonnull
                                                    LLongUnaryOperator func)

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

longBinaryOp

@Nonnull
static LLongBinaryOperator longBinaryOp(@Nonnull
                                                  LLongBinaryOperator lambda)

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

recursive

@Nonnull
static LLongBinaryOperator recursive(@Nonnull
                                               LFunction<LLongBinaryOperator,LLongBinaryOperator> selfLambda)

longBinaryOpThrowing

@Nonnull
static LLongBinaryOperator longBinaryOpThrowing(@Nonnull
                                                          ExF<Throwable> exF)

longBinaryOpThrowing

@Nonnull
static LLongBinaryOperator longBinaryOpThrowing(String message,
                                                          @Nonnull
                                                          ExMF<Throwable> exF)

call

static long call(long a1,
                 long a2,
                 @Nonnull
                 LLongBinaryOperator lambda)

wrap

@Nonnull
static LLongBinaryOperator wrap(java.util.function.LongBinaryOperator other)

Wraps JRE instance.

safe

@Nonnull
static LLongBinaryOperator safe()

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

safeSupplier

@Nonnull
static LSupplier<LLongBinaryOperator> safeSupplier()

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

safe

@Nonnull
static LLongBinaryOperator safe(@Nullable
                                          LLongBinaryOperator other)

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

safeSupplier

@Nonnull
static LSupplier<LLongBinaryOperator> safeSupplier(@Nullable
                                                             LSupplier<LLongBinaryOperator> supplier)

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

minBy

@Nonnull
static LLongBinaryOperator minBy(@Nonnull
                                           Comparator<Long> comparator)

Creates function that returns the lesser value according to the comparator.

See Also:

java.util.function.BinaryOperator#minBy}

maxBy

@Nonnull
static LLongBinaryOperator maxBy(@Nonnull
                                           Comparator<Long> comparator)

Creates function that returns the lesser value according to the comparator.

See Also:

java.util.function.BinaryOperator#maxBy}

min

@Nonnull
static LLongBinaryOperator min()

Returns function that returns the lower value.

See Also:

java.util.function.BinaryOperator#minBy}

max

@Nonnull
static LLongBinaryOperator max()

Returns function that returns the higher value.

See Also:

java.util.function.BinaryOperator#maxBy}

compose

@Nonnull
default LLongBinaryOperator compose(@Nonnull
                                              LLongUnaryOperator before1,
                                              @Nonnull
                                              LLongUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static LLongBinaryOperator composed(@Nonnull
                                    LLongUnaryOperator before1,
                                    @Nonnull
                                    LLongUnaryOperator before2,
                                    LLongBinaryOperator after)

longBinaryOpCompose

@Nonnull
default <V1,V2> LToLongBiFunction<V1,V2> longBinaryOpCompose(@Nonnull
                                                                       LToLongFunction<? super V1> before1,
                                                                       @Nonnull
                                                                       LToLongFunction<? super V2> before2)

Allows to manipulate the domain of the function.

composed

static <V1,V2> LToLongBiFunction<V1,V2> composed(@Nonnull
                                                 LToLongFunction<? super V1> before1,
                                                 @Nonnull
                                                 LToLongFunction<? super V2> before2,
                                                 LLongBinaryOperator after)

then

@Nonnull
default <V> LBiLongFunction<V> then(@Nonnull
                                              LLongFunction<? extends V> after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LLongBinaryOperator thenToLong(@Nonnull
                                                 LLongUnaryOperator after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LBiLongPredicate thenToBool(@Nonnull
                                              LLongPredicate after)

Combines two functions together in a order.

produceLong

static long produceLong(long a1,
                        long a2)

Does nothing (LLongBinaryOperator) Operator

forEach

default <C1,C2> void forEach(IndexedRead<C1,aType.aLong> ia1,
                             C1 source1,
                             IndexedRead<C2,aType.aLong> ia2,
                             C2 source2,
                             LLongConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,I1,C2> void iterate(SequentialRead<C1,I1,aType.aLong> sa1,
                                C1 source1,
                                IndexedRead<C2,aType.aLong> ia2,
                                C2 source2,
                                LLongConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,C2,I2> void iterate(IndexedRead<C1,aType.aLong> ia1,
                                C1 source1,
                                SequentialRead<C2,I2,aType.aLong> sa2,
                                C2 source2,
                                LLongConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,I1,C2,I2> void iterate(SequentialRead<C1,I1,aType.aLong> sa1,
                                   C1 source1,
                                   SequentialRead<C2,I2,aType.aLong> sa2,
                                   C2 source2,
                                   LLongConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.