eu.lunisolar.magma.func.function.to

Interface LToByteBiFunction<T1,T2>

All Superinterfaces:

Codomain<aType.aByte>, Domain, Domain2<aType.a<T1>,aType.a<T2>>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>

All Known Subinterfaces:

LToByteBiFunction.LToByteObj1Obj0Func<T2,T1>

All Known Implementing Classes:

LToByteBiFunction.LToByteBiFunctionSingle

@FunctionalInterface
public interface LToByteBiFunction<T1,T2>
extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aByte>, Domain2<aType.a<T1>,aType.a<T2>>

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

Type: function

Domain (lvl: 2): T1 a1,T2 a2

Co-domain: byte

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LToByteBiFunction.LToByteBiFunctionSingle<T1,T2>
static interface	LToByteBiFunction.LToByteObj1Obj0Func<T2,T1> Permutation of LToByteBiFunction for method references.

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 <T1,T2> LToByteBiFunction<T1,T2>	apply1stAsByte(LToByteFunction<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToByteBiFunction<T1,T2>	apply2ndAsByte(LToByteFunction<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
default byte	applyAsByte(T1 a1, T2 a2)
default byte	applyAsByte(T1 a1, T2 a2, ExWF<RuntimeException> exF)
default byte	applyAsByte(T1 a1, T2 a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default byte	applyAsByteThen(T1 a1, T2 a2, LToByteFunction<Throwable> handler)
byte	applyAsByteX(T1 a1, T2 a2) Implement this, but call applyAsByte(T1 a1,T2 a2)
static <T1,T2> byte	call(T1 a1, T2 a2, LToByteBiFunction<T1,T2> lambda)
default LByteSupplier	capture(T1 a1, T2 a2) Captures arguments but delays the evaluation.
default <V2,V3> LToByteBiFunction<V2,V3>	cast() Cast that replace generics.
static <V2,V3,T1,T2> LToByteBiFunction<V2,V3>	cast(LToByteBiFunction<T1,T2> function) Cast that replace generics.
default <V1,V2> LToByteBiFunction<V1,V2>	compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2) Allows to manipulate the domain of the function.
static <V1,V2,T1,T2> LToByteBiFunction<V1,V2>	composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToByteBiFunction<T1,T2> after)
static <T1,T2> LToByteBiFunction<T1,T2>	constant(byte r) Creates function that always returns the same value.
static <T1,T2> LToByteBiFunction<T1,T2>	failSafe(LToByteBiFunction<T1,T2> func, LToByteBiFunction<T1,T2> failSafe)
default byte	failSafeApplyAsByte(T1 a1, T2 a2, LToByteBiFunction<T1,T2> failSafe)
static <T1,T2> byte	failSafeApplyAsByte(T1 a1, T2 a2, LToByteBiFunction<T1,T2> func, LToByteBiFunction<T1,T2> failSafe)
default <C1,C2> void	forEach(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LByteConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static <T1,T2> void	fromTill(int min_i, int max_i, T1 a1, T2 a2, LToByteBiFunction<T1,T2> func) From-To.
static <T1,T2> void	fromTo(int min_i, int max_i, T1 a1, T2 a2, LToByteBiFunction<T1,T2> func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LToByteBiFunction<T1,T2>	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default byte	handlingApplyAsByte(T1 a1, T2 a2, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static <T1,T2> byte	handlingApplyAsByte(T1 a1, T2 a2, LToByteBiFunction<T1,T2> func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C1,C2,I2> void	iterate(IndexedRead<C1,aType.a<T1>> ia1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LByteConsumer 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.a<T1>> sa1, C1 source1, IndexedRead<C2,aType.a<T2>> ia2, C2 source2, LByteConsumer 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.a<T1>> sa1, C1 source1, SequentialRead<C2,I2,aType.a<T2>> sa2, C2 source2, LByteConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default LToByteFunction<T2>	lShrink(LFunction<T2,T1> left)
default LToByteFunction<T2>	lShrinkc(T1 a1)
static <T2,T1> LToByteFunction<T2>	lShrinked(LFunction<T2,T1> left, LToByteBiFunction<T1,T2> func)
static <T2,T1> LToByteFunction<T2>	lShrinkedc(T1 a1, LToByteBiFunction<T1,T2> func)
default byte	nestingApplyAsByte(T1 a1, T2 a2) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default byte	nonNullApplyAsByte(T1 a1, T2 a2) Just to mirror the method: Ensures the result is not null
static <T1,T2> byte	produceByte(T1 a1, T2 a2) Does nothing (LToByteBiFunction) Function
static <T1,T2> LToByteBiFunction<T1,T2>	recursive(LFunction<LToByteBiFunction<T1,T2>,LToByteBiFunction<T1,T2>> selfLambda)
default LToByteFunction<T1>	rShrink(LFunction<T1,T2> right)
default LToByteFunction<T1>	rShrinkc(T2 a2)
static <T1,T2> LToByteFunction<T1>	rShrinked(LFunction<T1,T2> right, LToByteBiFunction<T1,T2> func)
static <T1,T2> LToByteFunction<T1>	rShrinkedc(T2 a2, LToByteBiFunction<T1,T2> func)
static <T1,T2> LToByteBiFunction<T1,T2>	safe() Safe instance.
static <T1,T2> LToByteBiFunction<T1,T2>	safe(LToByteBiFunction<T1,T2> other) Safe wrapping.
static <T1,T2> LSupplier<LToByteBiFunction<T1,T2>>	safeSupplier() Safe instance supplier.
static <T1,T2> LSupplier<LToByteBiFunction<T1,T2>>	safeSupplier(LSupplier<LToByteBiFunction<T1,T2>> supplier) Safe supplier.
default byte	shovingApplyAsByte(T1 a1, T2 a2) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LBiFunction<T1,T2,V>	then(LByteFunction<? extends V> after) Combines two functions together in a order.
default LBiPredicate<T1,T2>	thenToBool(LBytePredicate after) Combines two functions together in a order.
default LToByteBiFunction<T1,T2>	thenToByte(LByteUnaryOperator after) Combines two functions together in a order.
default LToCharBiFunction<T1,T2>	thenToChar(LByteToCharFunction after) Combines two functions together in a order.
default LToDblBiFunction<T1,T2>	thenToDbl(LByteToDblFunction after) Combines two functions together in a order.
default LToFltBiFunction<T1,T2>	thenToFlt(LByteToFltFunction after) Combines two functions together in a order.
default LToIntBiFunction<T1,T2>	thenToInt(LByteToIntFunction after) Combines two functions together in a order.
default LToLongBiFunction<T1,T2>	thenToLong(LByteToLongFunction after) Combines two functions together in a order.
default LToSrtBiFunction<T1,T2>	thenToSrt(LByteToSrtFunction after) Combines two functions together in a order.
static <T1,T2> void	times(int max_i, T1 a1, T2 a2, LToByteBiFunction<T1,T2> func) From-To.
static <T1,T2> LToByteBiFunction<T1,T2>	toByteBiFunc(LToByteBiFunction<T1,T2> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,T2> LToByteBiFunction<T1,T2>	toByteBiFuncThrowing(ExF<Throwable> exF)
static <T1,T2> LToByteBiFunction<T1,T2>	toByteBiFuncThrowing(String message, ExMF<Throwable> exF)
static <T2,T1> LToByteBiFunction.LToByteObj1Obj0Func<T2,T1>	toByteObj1Obj0Func(LToByteBiFunction.LToByteObj1Obj0Func<T2,T1> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T1,T2> byte	tryApplyAsByte(T1 a1, T2 a2, LToByteBiFunction<T1,T2> func)
static <T1,T2> byte	tryApplyAsByte(T1 a1, T2 a2, LToByteBiFunction<T1,T2> func, ExWF<RuntimeException> exF)
static <T1,T2> byte	tryApplyAsByte(T1 a1, T2 a2, LToByteBiFunction<T1,T2> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2> byte	tryApplyAsByteThen(T1 a1, T2 a2, LToByteBiFunction<T1,T2> func, LToByteFunction<Throwable> handler)
default LToByteBiFunction<T1,T2>	trying(ExWF<RuntimeException> exF)
default LToByteBiFunction<T1,T2>	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LToByteBiFunction<T1,T2>	tryingThen(LToByteFunction<Throwable> handler)
default byte	tupleApplyAsByte(LPair<T1,T2> args)
static <T1,T2> LToByteBiFunction<T1,T2>	uncurry(LFunction<T1,LToByteFunction<T2>> func)
default LToByteBiFunction	untyped() Cast that removes generics.

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

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

applyAsByte

default byte applyAsByte(T1 a1,
                         T2 a2)

applyAsByteX

byte applyAsByteX(T1 a1,
                  T2 a2)
           throws Throwable

Implement this, but call applyAsByte(T1 a1,T2 a2)

Throws:

Throwable

tupleApplyAsByte

default byte tupleApplyAsByte(LPair<T1,T2> args)

handlingApplyAsByte

default byte handlingApplyAsByte(T1 a1,
                                 T2 a2,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LToByteBiFunction<T1,T2> handling(HandlingInstructions<Throwable,RuntimeException> handling)

applyAsByte

default byte applyAsByte(T1 a1,
                         T2 a2,
                         @Nonnull
                         ExWMF<RuntimeException> exF,
                         @Nonnull
                         String newMessage,
                         @Nullable
                         Object... messageParams)

trying

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

applyAsByte

default byte applyAsByte(T1 a1,
                         T2 a2,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

default LToByteBiFunction<T1,T2> trying(@Nonnull
                                        ExWF<RuntimeException> exF)

applyAsByteThen

default byte applyAsByteThen(T1 a1,
                             T2 a2,
                             @Nonnull
                             LToByteFunction<Throwable> handler)

tryingThen

default LToByteBiFunction<T1,T2> tryingThen(@Nonnull
                                            LToByteFunction<Throwable> handler)

nestingApplyAsByte

default byte nestingApplyAsByte(T1 a1,
                                T2 a2)

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

shovingApplyAsByte

default byte shovingApplyAsByte(T1 a1,
                                T2 a2)

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

handlingApplyAsByte

static <T1,T2> byte handlingApplyAsByte(T1 a1,
                                        T2 a2,
                                        LToByteBiFunction<T1,T2> func,
                                        HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsByte

static <T1,T2> byte tryApplyAsByte(T1 a1,
                                   T2 a2,
                                   LToByteBiFunction<T1,T2> func)

tryApplyAsByte

static <T1,T2> byte tryApplyAsByte(T1 a1,
                                   T2 a2,
                                   LToByteBiFunction<T1,T2> func,
                                   @Nonnull
                                   ExWMF<RuntimeException> exF,
                                   @Nonnull
                                   String newMessage,
                                   @Nullable
                                   Object... messageParams)

tryApplyAsByte

static <T1,T2> byte tryApplyAsByte(T1 a1,
                                   T2 a2,
                                   LToByteBiFunction<T1,T2> func,
                                   @Nonnull
                                   ExWF<RuntimeException> exF)

tryApplyAsByteThen

static <T1,T2> byte tryApplyAsByteThen(T1 a1,
                                       T2 a2,
                                       LToByteBiFunction<T1,T2> func,
                                       @Nonnull
                                       LToByteFunction<Throwable> handler)

failSafeApplyAsByte

default byte failSafeApplyAsByte(T1 a1,
                                 T2 a2,
                                 @Nonnull
                                 LToByteBiFunction<T1,T2> failSafe)

failSafeApplyAsByte

static <T1,T2> byte failSafeApplyAsByte(T1 a1,
                                        T2 a2,
                                        LToByteBiFunction<T1,T2> func,
                                        @Nonnull
                                        LToByteBiFunction<T1,T2> failSafe)

failSafe

static <T1,T2> LToByteBiFunction<T1,T2> failSafe(LToByteBiFunction<T1,T2> func,
                                                 @Nonnull
                                                 LToByteBiFunction<T1,T2> failSafe)

nonNullApplyAsByte

default byte nonNullApplyAsByte(T1 a1,
                                T2 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 <T1,T2> void fromTo(int min_i,
                           int max_i,
                           T1 a1,
                           T2 a2,
                           LToByteBiFunction<T1,T2> func)

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

fromTill

static <T1,T2> void fromTill(int min_i,
                             int max_i,
                             T1 a1,
                             T2 a2,
                             LToByteBiFunction<T1,T2> func)

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

times

static <T1,T2> void times(int max_i,
                          T1 a1,
                          T2 a2,
                          LToByteBiFunction<T1,T2> func)

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

lShrink

default LToByteFunction<T2> lShrink(LFunction<T2,T1> left)

lShrinkc

default LToByteFunction<T2> lShrinkc(T1 a1)

lShrinked

static <T2,T1> LToByteFunction<T2> lShrinked(LFunction<T2,T1> left,
                                             LToByteBiFunction<T1,T2> func)

lShrinkedc

static <T2,T1> LToByteFunction<T2> lShrinkedc(T1 a1,
                                              LToByteBiFunction<T1,T2> func)

rShrink

default LToByteFunction<T1> rShrink(LFunction<T1,T2> right)

rShrinkc

default LToByteFunction<T1> rShrinkc(T2 a2)

rShrinked

static <T1,T2> LToByteFunction<T1> rShrinked(LFunction<T1,T2> right,
                                             LToByteBiFunction<T1,T2> func)

rShrinkedc

static <T1,T2> LToByteFunction<T1> rShrinkedc(T2 a2,
                                              LToByteBiFunction<T1,T2> func)

uncurry

static <T1,T2> LToByteBiFunction<T1,T2> uncurry(LFunction<T1,LToByteFunction<T2>> func)

untyped

default LToByteBiFunction untyped()

Cast that removes generics.

cast

default <V2,V3> LToByteBiFunction<V2,V3> cast()

Cast that replace generics.

cast

static <V2,V3,T1,T2> LToByteBiFunction<V2,V3> cast(LToByteBiFunction<T1,T2> function)

Cast that replace generics.

capture

default LByteSupplier capture(T1 a1,
                              T2 a2)

Captures arguments but delays the evaluation.

constant

static <T1,T2> LToByteBiFunction<T1,T2> constant(byte r)

Creates function that always returns the same value.

apply1stAsByte

@Nonnull
static <T1,T2> LToByteBiFunction<T1,T2> apply1stAsByte(@Nonnull
                                                                 LToByteFunction<T1> func)

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

apply2ndAsByte

@Nonnull
static <T1,T2> LToByteBiFunction<T1,T2> apply2ndAsByte(@Nonnull
                                                                 LToByteFunction<T2> func)

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

toByteBiFunc

@Nonnull
static <T1,T2> LToByteBiFunction<T1,T2> toByteBiFunc(@Nonnull
                                                               LToByteBiFunction<T1,T2> lambda)

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

recursive

@Nonnull
static <T1,T2> LToByteBiFunction<T1,T2> recursive(@Nonnull
                                                            LFunction<LToByteBiFunction<T1,T2>,LToByteBiFunction<T1,T2>> selfLambda)

toByteBiFuncThrowing

@Nonnull
static <T1,T2> LToByteBiFunction<T1,T2> toByteBiFuncThrowing(@Nonnull
                                                                       ExF<Throwable> exF)

toByteBiFuncThrowing

@Nonnull
static <T1,T2> LToByteBiFunction<T1,T2> toByteBiFuncThrowing(String message,
                                                                       @Nonnull
                                                                       ExMF<Throwable> exF)

toByteObj1Obj0Func

@Nonnull
static <T2,T1> LToByteBiFunction.LToByteObj1Obj0Func<T2,T1> toByteObj1Obj0Func(@Nonnull
                                                                                         LToByteBiFunction.LToByteObj1Obj0Func<T2,T1> lambda)

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

call

static <T1,T2> byte call(T1 a1,
                         T2 a2,
                         @Nonnull
                         LToByteBiFunction<T1,T2> lambda)

safe

@Nonnull
static <T1,T2> LToByteBiFunction<T1,T2> safe()

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

safeSupplier

@Nonnull
static <T1,T2> LSupplier<LToByteBiFunction<T1,T2>> safeSupplier()

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

safe

@Nonnull
static <T1,T2> LToByteBiFunction<T1,T2> safe(@Nullable
                                                       LToByteBiFunction<T1,T2> other)

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

safeSupplier

@Nonnull
static <T1,T2> LSupplier<LToByteBiFunction<T1,T2>> safeSupplier(@Nullable
                                                                          LSupplier<LToByteBiFunction<T1,T2>> supplier)

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

compose

@Nonnull
default <V1,V2> LToByteBiFunction<V1,V2> compose(@Nonnull
                                                           LFunction<? super V1,? extends T1> before1,
                                                           @Nonnull
                                                           LFunction<? super V2,? extends T2> before2)

Allows to manipulate the domain of the function.

composed

static <V1,V2,T1,T2> LToByteBiFunction<V1,V2> composed(@Nonnull
                                                       LFunction<? super V1,? extends T1> before1,
                                                       @Nonnull
                                                       LFunction<? super V2,? extends T2> before2,
                                                       LToByteBiFunction<T1,T2> after)

then

@Nonnull
default <V> LBiFunction<T1,T2,V> then(@Nonnull
                                                LByteFunction<? extends V> after)

Combines two functions together in a order.

thenToByte

@Nonnull
default LToByteBiFunction<T1,T2> thenToByte(@Nonnull
                                                      LByteUnaryOperator after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LToSrtBiFunction<T1,T2> thenToSrt(@Nonnull
                                                    LByteToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LToIntBiFunction<T1,T2> thenToInt(@Nonnull
                                                    LByteToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LToLongBiFunction<T1,T2> thenToLong(@Nonnull
                                                      LByteToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LToFltBiFunction<T1,T2> thenToFlt(@Nonnull
                                                    LByteToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LToDblBiFunction<T1,T2> thenToDbl(@Nonnull
                                                    LByteToDblFunction after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LToCharBiFunction<T1,T2> thenToChar(@Nonnull
                                                      LByteToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LBiPredicate<T1,T2> thenToBool(@Nonnull
                                                 LBytePredicate after)

Combines two functions together in a order.

produceByte

static <T1,T2> byte produceByte(T1 a1,
                                T2 a2)

Does nothing (LToByteBiFunction) Function

forEach

default <C1,C2> void forEach(IndexedRead<C1,aType.a<T1>> ia1,
                             C1 source1,
                             IndexedRead<C2,aType.a<T2>> ia2,
                             C2 source2,
                             LByteConsumer 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.a<T1>> sa1,
                                C1 source1,
                                IndexedRead<C2,aType.a<T2>> ia2,
                                C2 source2,
                                LByteConsumer 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.a<T1>> ia1,
                                C1 source1,
                                SequentialRead<C2,I2,aType.a<T2>> sa2,
                                C2 source2,
                                LByteConsumer 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.a<T1>> sa1,
                                   C1 source1,
                                   SequentialRead<C2,I2,aType.a<T2>> sa2,
                                   C2 source2,
                                   LByteConsumer 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.