T1
- type of first elementT2
- type of second elementT3
- type of third elementT4
- type of fourth elementpublic interface ITuple4<T1,T2,T3,T4>
This is sometimes useful to access either Tuple4
or NTuple4
in a general way,
although in most cases the concrete implementations are usually preferable.
If you want to iterate over a tuple or access its elements by index
(note that both is only possible for a common super type of the tuple's types)
Indexable.viewTuple(ITuple4)
will come to help.
Note that this class is automatically created by tools.TupleClassCreator
(not yet public).
Modifier and Type | Interface and Description |
---|---|
static class |
ITuple4.Base<T1,T2,T3,T4>
Abstract base implementation of a 4-tuple.
|
Modifier and Type | Method and Description |
---|---|
T1 |
_1()
Get the first element.
|
default ITuple2<T1,T2> |
_12()
Create a new 2-tuple from this one where the elements are ordered: 1st, 2nd.
|
default ITuple3<T1,T2,T3> |
_123()
Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 3rd.
|
default ITuple3<T1,T2,T4> |
_124()
Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 4th.
|
default ITuple4<T1,T2,T4,T3> |
_1243()
Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 3rd.
|
default ITuple2<T1,T3> |
_13()
Create a new 2-tuple from this one where the elements are ordered: 1st, 3rd.
|
default ITuple3<T1,T3,T2> |
_132()
Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 2nd.
|
default ITuple4<T1,T3,T2,T4> |
_1324()
Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 2nd, 4th.
|
default ITuple3<T1,T3,T4> |
_134()
Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 4th.
|
default ITuple4<T1,T3,T4,T2> |
_1342()
Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 2nd.
|
default ITuple2<T1,T4> |
_14()
Create a new 2-tuple from this one where the elements are ordered: 1st, 4th.
|
default ITuple3<T1,T4,T2> |
_142()
Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 2nd.
|
default ITuple4<T1,T4,T2,T3> |
_1423()
Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 2nd, 3rd.
|
default ITuple3<T1,T4,T3> |
_143()
Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 3rd.
|
default ITuple4<T1,T4,T3,T2> |
_1432()
Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 3rd, 2nd.
|
T2 |
_2()
Get the second element.
|
default ITuple2<T2,T1> |
_21()
Create a new 2-tuple from this one where the elements are ordered: 2nd, 1st.
|
default ITuple3<T2,T1,T3> |
_213()
Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 3rd.
|
default ITuple4<T2,T1,T3,T4> |
_2134()
Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 3rd, 4th.
|
default ITuple3<T2,T1,T4> |
_214()
Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 4th.
|
default ITuple4<T2,T1,T4,T3> |
_2143()
Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 4th, 3rd.
|
default ITuple2<T2,T3> |
_23()
Create a new 2-tuple from this one where the elements are ordered: 2nd, 3rd.
|
default ITuple3<T2,T3,T1> |
_231()
Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 1st.
|
default ITuple4<T2,T3,T1,T4> |
_2314()
Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 1st, 4th.
|
default ITuple3<T2,T3,T4> |
_234()
Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 4th.
|
default ITuple4<T2,T3,T4,T1> |
_2341()
Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 1st.
|
default ITuple2<T2,T4> |
_24()
Create a new 2-tuple from this one where the elements are ordered: 2nd, 4th.
|
default ITuple3<T2,T4,T1> |
_241()
Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 1st.
|
default ITuple4<T2,T4,T1,T3> |
_2413()
Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 1st, 3rd.
|
default ITuple3<T2,T4,T3> |
_243()
Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 3rd.
|
default ITuple4<T2,T4,T3,T1> |
_2431()
Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 3rd, 1st.
|
T3 |
_3()
Get the third element.
|
default ITuple2<T3,T1> |
_31()
Create a new 2-tuple from this one where the elements are ordered: 3rd, 1st.
|
default ITuple3<T3,T1,T2> |
_312()
Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 2nd.
|
default ITuple4<T3,T1,T2,T4> |
_3124()
Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 2nd, 4th.
|
default ITuple3<T3,T1,T4> |
_314()
Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 4th.
|
default ITuple4<T3,T1,T4,T2> |
_3142()
Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 4th, 2nd.
|
default ITuple2<T3,T2> |
_32()
Create a new 2-tuple from this one where the elements are ordered: 3rd, 2nd.
|
default ITuple3<T3,T2,T1> |
_321()
Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 1st.
|
default ITuple4<T3,T2,T1,T4> |
_3214()
Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 1st, 4th.
|
default ITuple3<T3,T2,T4> |
_324()
Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 4th.
|
default ITuple4<T3,T2,T4,T1> |
_3241()
Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 4th, 1st.
|
default ITuple2<T3,T4> |
_34()
Create a new 2-tuple from this one where the elements are ordered: 3rd, 4th.
|
default ITuple3<T3,T4,T1> |
_341()
Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 1st.
|
default ITuple4<T3,T4,T1,T2> |
_3412()
Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 1st, 2nd.
|
default ITuple3<T3,T4,T2> |
_342()
Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 2nd.
|
default ITuple4<T3,T4,T2,T1> |
_3421()
Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 2nd, 1st.
|
T4 |
_4()
Get the fourth element.
|
default ITuple2<T4,T1> |
_41()
Create a new 2-tuple from this one where the elements are ordered: 4th, 1st.
|
default ITuple3<T4,T1,T2> |
_412()
Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 2nd.
|
default ITuple4<T4,T1,T2,T3> |
_4123()
Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 2nd, 3rd.
|
default ITuple3<T4,T1,T3> |
_413()
Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 3rd.
|
default ITuple4<T4,T1,T3,T2> |
_4132()
Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 3rd, 2nd.
|
default ITuple2<T4,T2> |
_42()
Create a new 2-tuple from this one where the elements are ordered: 4th, 2nd.
|
default ITuple3<T4,T2,T1> |
_421()
Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 1st.
|
default ITuple4<T4,T2,T1,T3> |
_4213()
Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 1st, 3rd.
|
default ITuple3<T4,T2,T3> |
_423()
Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 3rd.
|
default ITuple4<T4,T2,T3,T1> |
_4231()
Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 3rd, 1st.
|
default ITuple2<T4,T3> |
_43()
Create a new 2-tuple from this one where the elements are ordered: 4th, 3rd.
|
default ITuple3<T4,T3,T1> |
_431()
Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 1st.
|
default ITuple4<T4,T3,T1,T2> |
_4312()
Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 1st, 2nd.
|
default ITuple3<T4,T3,T2> |
_432()
Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 2nd.
|
default ITuple4<T4,T3,T2,T1> |
_4321()
Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 2nd, 1st.
|
default ITuple4.Base<T1,T2,T3,T4> |
asBase()
Convert this 4-tuple into a
base tuple which provides useful implementations for standard methods. |
static <S1,E1,E2,E3,E4,R> |
concat1(java.util.function.Function<S1,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1,
Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
Combine a 1-argument function returning a 4-tuple with a 4-parameter function returning another result value
into one 1-argument function.
|
static <S1,S2,E1,E2,E3,E4,R> |
concat2(java.util.function.BiFunction<S1,S2,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1,
Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
Combine a 2-argument function returning a 4-tuple with a 4-parameter function returning another result value
into one 2-argument function.
|
static <S1,S2,S3,E1,E2,E3,E4,R> |
concat3(Function3<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3> fn1,
Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
Combine a 3-argument function returning a 4-tuple with a 4-parameter function returning another result value
into one 3-argument function.
|
static <S1,S2,S3,S4,E1,E2,E3,E4,R> |
concat4(Function4<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4> fn1,
Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
Combine a 4-argument function returning a 4-tuple with a 4-parameter function returning another result value
into one 4-argument function.
|
static <S1,S2,S3,S4,S5,E1,E2,E3,E4,R> |
concat5(Function5<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5> fn1,
Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
Combine a 5-argument function returning a 4-tuple with a 4-parameter function returning another result value
into one 5-argument function.
|
static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4,R> |
concat6(Function6<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6> fn1,
Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
Combine a 6-argument function returning a 4-tuple with a 4-parameter function returning another result value
into one 6-argument function.
|
static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4,R> |
concat7(Function7<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7> fn1,
Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
Combine a 7-argument function returning a 4-tuple with a 4-parameter function returning another result value
into one 7-argument function.
|
static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4,R> |
concat8(Function8<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
Combine a 8-argument function returning a 4-tuple with a 4-parameter function returning another result value
into one 8-argument function.
|
static <S1,E1,E2,E3,E4> |
concatPred1(java.util.function.Function<S1,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1,
Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
Combine a 1-argument function returning a 4-tuple with a 4-parameter predicate into a 1-argument predicate.
|
static <S1,S2,E1,E2,E3,E4> |
concatPred2(java.util.function.BiFunction<S1,S2,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1,
Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
Combine a 2-argument function returning a 4-tuple with a 4-parameter predicate into a 2-argument predicate.
|
static <S1,S2,S3,E1,E2,E3,E4> |
concatPred3(Function3<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3> fn1,
Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
Combine a 3-argument function returning a 4-tuple with a 4-parameter predicate into a 3-argument predicate.
|
static <S1,S2,S3,S4,E1,E2,E3,E4> |
concatPred4(Function4<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4> fn1,
Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
Combine a 4-argument function returning a 4-tuple with a 4-parameter predicate into a 4-argument predicate.
|
static <S1,S2,S3,S4,S5,E1,E2,E3,E4> |
concatPred5(Function5<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5> fn1,
Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
Combine a 5-argument function returning a 4-tuple with a 4-parameter predicate into a 5-argument predicate.
|
static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4> |
concatPred6(Function6<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6> fn1,
Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
Combine a 6-argument function returning a 4-tuple with a 4-parameter predicate into a 6-argument predicate.
|
static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4> |
concatPred7(Function7<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7> fn1,
Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
Combine a 7-argument function returning a 4-tuple with a 4-parameter predicate into a 7-argument predicate.
|
static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4> |
concatPred8(Function8<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
Combine a 8-argument function returning a 4-tuple with a 4-parameter predicate into a 8-argument predicate.
|
static <S1,E1,E2,E3,E4> |
concatProc1(java.util.function.Function<S1,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1,
Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
Combine a 1-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 1-argument consumer/procedure.
|
static <S1,S2,E1,E2,E3,E4> |
concatProc2(java.util.function.BiFunction<S1,S2,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1,
Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
Combine a 2-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 2-argument consumer/procedure.
|
static <S1,S2,S3,E1,E2,E3,E4> |
concatProc3(Function3<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3> fn1,
Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
Combine a 3-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 3-argument consumer/procedure.
|
static <S1,S2,S3,S4,E1,E2,E3,E4> |
concatProc4(Function4<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4> fn1,
Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
Combine a 4-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 4-argument consumer/procedure.
|
static <S1,S2,S3,S4,S5,E1,E2,E3,E4> |
concatProc5(Function5<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5> fn1,
Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
Combine a 5-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 5-argument consumer/procedure.
|
static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4> |
concatProc6(Function6<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6> fn1,
Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
Combine a 6-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 6-argument consumer/procedure.
|
static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4> |
concatProc7(Function7<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7> fn1,
Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
Combine a 7-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 7-argument consumer/procedure.
|
static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4> |
concatProc8(Function8<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
Combine a 8-argument function returning a 4-tuple with a 4-parameter consumer/procedure into a 8-argument consumer/procedure.
|
static boolean |
equals(ITuple4<?,?,?,?> tuple,
java.lang.Object o)
Basic implementation of equals for 4-tuples.
|
default NTuple4<T1,T2,T3,T4> |
frozen()
Convert this into an object of a concrete tuple implementation.
|
default Tuple4<T1,T2,T3,T4> |
frozenNotNull()
Convert this into an object of a concrete tuple implementation.
|
static int |
hash(ITuple4<?,?,?,?> tuple)
Basic implementation for calculating a hash code of a 4-tuple.
|
default <T> T |
invoke(Function4<T,? super T1,? super T2,? super T3,? super T4> function)
Invoke a %d-argument function on this tuple.
|
default void |
sendTo(Procedure4<? super T1,? super T2,? super T3,? super T4> procedure)
Send this tuple unpacked to a 4-argument procedure.
|
default boolean |
testBy(Predicate4<? super T1,? super T2,? super T3,? super T4> predicate)
Test a 4-argument predicate with this tuple unpacked.
|
static java.lang.String |
toString(ITuple4<?,?,?,?> tuple)
Basic implementation for creating a string from a 4-tuple.
|
static java.lang.String |
toString(java.lang.String prefix,
ITuple4<?,?,?,?> tuple)
Basic implementation for creating a string from a 4-tuple.
|
static <E1,E2,E3,E4> |
view(E1 elem1,
E2 elem2,
E3 elem3,
E4 elem4)
Create a new 4-tuple on the fly.
|
T1 _1()
T2 _2()
T3 _3()
T4 _4()
@NotNull default ITuple4<T1,T2,T4,T3> _1243()
@NotNull default ITuple4<T1,T4,T2,T3> _1423()
@NotNull default ITuple4<T4,T1,T2,T3> _4123()
@NotNull default ITuple4<T4,T1,T3,T2> _4132()
@NotNull default ITuple4<T1,T4,T3,T2> _1432()
@NotNull default ITuple4<T1,T3,T4,T2> _1342()
@NotNull default ITuple4<T1,T3,T2,T4> _1324()
@NotNull default ITuple4<T3,T1,T2,T4> _3124()
@NotNull default ITuple4<T3,T1,T4,T2> _3142()
@NotNull default ITuple4<T3,T4,T1,T2> _3412()
@NotNull default ITuple4<T4,T3,T1,T2> _4312()
@NotNull default ITuple4<T4,T3,T2,T1> _4321()
@NotNull default ITuple4<T3,T4,T2,T1> _3421()
@NotNull default ITuple4<T3,T2,T4,T1> _3241()
@NotNull default ITuple4<T3,T2,T1,T4> _3214()
@NotNull default ITuple4<T2,T3,T1,T4> _2314()
@NotNull default ITuple4<T2,T3,T4,T1> _2341()
@NotNull default ITuple4<T2,T4,T3,T1> _2431()
@NotNull default ITuple4<T4,T2,T3,T1> _4231()
@NotNull default ITuple4<T4,T2,T1,T3> _4213()
@NotNull default ITuple4<T2,T4,T1,T3> _2413()
@NotNull default ITuple4<T2,T1,T4,T3> _2143()
@NotNull default ITuple4<T2,T1,T3,T4> _2134()
@NotNull default ITuple3<T1,T2,T3> _123()
@NotNull default ITuple3<T1,T3,T2> _132()
@NotNull default ITuple3<T3,T1,T2> _312()
@NotNull default ITuple3<T3,T2,T1> _321()
@NotNull default ITuple3<T2,T3,T1> _231()
@NotNull default ITuple3<T2,T1,T3> _213()
@NotNull default ITuple3<T1,T2,T4> _124()
@NotNull default ITuple3<T1,T4,T2> _142()
@NotNull default ITuple3<T4,T1,T2> _412()
@NotNull default ITuple3<T4,T2,T1> _421()
@NotNull default ITuple3<T2,T4,T1> _241()
@NotNull default ITuple3<T2,T1,T4> _214()
@NotNull default ITuple3<T1,T3,T4> _134()
@NotNull default ITuple3<T1,T4,T3> _143()
@NotNull default ITuple3<T4,T1,T3> _413()
@NotNull default ITuple3<T4,T3,T1> _431()
@NotNull default ITuple3<T3,T4,T1> _341()
@NotNull default ITuple3<T3,T1,T4> _314()
@NotNull default ITuple3<T2,T3,T4> _234()
@NotNull default ITuple3<T2,T4,T3> _243()
@NotNull default ITuple3<T4,T2,T3> _423()
@NotNull default ITuple3<T4,T3,T2> _432()
@NotNull default ITuple3<T3,T4,T2> _342()
@NotNull default ITuple3<T3,T2,T4> _324()
@NotNull default ITuple2<T1,T2> _12()
@NotNull default ITuple2<T2,T1> _21()
@NotNull default ITuple2<T1,T3> _13()
@NotNull default ITuple2<T3,T1> _31()
@NotNull default ITuple2<T2,T3> _23()
@NotNull default ITuple2<T3,T2> _32()
@NotNull default ITuple2<T1,T4> _14()
@NotNull default ITuple2<T4,T1> _41()
@NotNull default ITuple2<T2,T4> _24()
@NotNull default ITuple2<T4,T2> _42()
@NotNull default ITuple2<T3,T4> _34()
@NotNull default ITuple2<T4,T3> _43()
@NotNull default ITuple4.Base<T1,T2,T3,T4> asBase()
base tuple
which provides useful implementations for standard methods.@NotNull default NTuple4<T1,T2,T3,T4> frozen()
null
elements,
see frozenNotNull()
for a method which returns tuples
which don't have nullable elements.@NotNull default Tuple4<T1,T2,T3,T4> frozenNotNull()
null
elements, but if this interface has null
elements this method
will throw a NullPointerException
.
See frozen()
for a method which will not throw exceptions.
java.lang.NullPointerException
- if any element of this tuple is null
default <T> T invoke(@NotNull Function4<T,? super T1,? super T2,? super T3,? super T4> function)
T
- function return typefunction
- function called with the unpacked elements of this tupledefault void sendTo(@NotNull Procedure4<? super T1,? super T2,? super T3,? super T4> procedure)
procedure
- procedure called with the unpacked elements of this tupledefault boolean testBy(@NotNull Predicate4<? super T1,? super T2,? super T3,? super T4> predicate)
predicate
- predicate called with the unpacked elements of this tuple@NotNull static <E1,E2,E3,E4> ITuple4<E1,E2,E3,E4> view(E1 elem1, E2 elem2, E3 elem3, E4 elem4)
Tuple4
instead as that gives guarantees of the non-nullness of its elements, or a NTuple4
as that at least is serializable (as is Tuple4
).E1
- type of first elementE2
- type of second elementE3
- type of third elementE4
- type of fourth elementelem1
- first element of returned tupleelem2
- second element of returned tupleelem3
- third element of returned tupleelem4
- fourth element of returned tuplestatic boolean equals(@NotNull ITuple4<?,?,?,?> tuple, @Nullable java.lang.Object o)
Object.equals(Object)
.
Don't forget hashing: hash(ITuple4)
tuple
- tuple to compareo
- other object to comparefalse
if o
is null
, not a ITuple4
, or its members differtrue
otherwisestatic int hash(@NotNull ITuple4<?,?,?,?> tuple)
Object.hashCode()
.
Don't forget equals: equals(ITuple4, Object)
.tuple
- tuple to hash@NotNull static java.lang.String toString(@NotNull ITuple4<?,?,?,?> tuple)
"ITuple4"
as prefix.
This can be used im implementations to implement Object.toString()
.tuple
- tuple to converttoString(String, ITuple4)
@NotNull static java.lang.String toString(@NotNull java.lang.String prefix, @NotNull ITuple4<?,?,?,?> tuple)
Object.toString()
.prefix
- prefix for the outputtuple
- tuple to converttoString(ITuple4)
@NotNull static <S1,E1,E2,E3,E4,R> java.util.function.Function<S1,R> concat1(@NotNull java.util.function.Function<S1,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, @NotNull Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
S1
- first argument of incoming function fn1
and returned functionE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tupleR
- result typefn1
- 1-argument function returning a 4-tuplefn2
- 4-argument function which can use the expanded tuple elements as arguments and returns the result value@NotNull static <S1,E1,E2,E3,E4> java.util.function.Consumer<S1> concatProc1(@NotNull java.util.function.Function<S1,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, @NotNull Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
S1
- first argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 1-argument function returning a 4-tupleproc2
- 4-argument consumer/procedure which can use the expanded tuple elements as arguments@NotNull static <S1,E1,E2,E3,E4> java.util.function.Predicate<S1> concatPred1(@NotNull java.util.function.Function<S1,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, @NotNull Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
S1
- first argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 1-argument function returning a 4-tuplepred2
- 4-argument predicate which can use the expanded tuple elements as argumentsfn1
@NotNull static <S1,S2,E1,E2,E3,E4,R> java.util.function.BiFunction<S1,S2,R> concat2(@NotNull java.util.function.BiFunction<S1,S2,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, @NotNull Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
S1
- first argument of incoming function fn1
and returned functionS2
- second argument of incoming function fn1
and returned functionE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tupleR
- result typefn1
- 2-argument function returning a 4-tuplefn2
- 4-argument function which can use the expanded tuple elements as arguments and returns the result value@NotNull static <S1,S2,E1,E2,E3,E4> java.util.function.BiConsumer<S1,S2> concatProc2(@NotNull java.util.function.BiFunction<S1,S2,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, @NotNull Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 2-argument function returning a 4-tupleproc2
- 4-argument consumer/procedure which can use the expanded tuple elements as arguments@NotNull static <S1,S2,E1,E2,E3,E4> java.util.function.BiPredicate<S1,S2> concatPred2(@NotNull java.util.function.BiFunction<S1,S2,? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>> fn1, @NotNull Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 2-argument function returning a 4-tuplepred2
- 4-argument predicate which can use the expanded tuple elements as argumentsfn1
@NotNull static <S1,S2,S3,E1,E2,E3,E4,R> Function3<R,S1,S2,S3> concat3(@NotNull Function3<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3> fn1, @NotNull Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
S1
- first argument of incoming function fn1
and returned functionS2
- second argument of incoming function fn1
and returned functionS3
- third argument of incoming function fn1
and returned functionE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tupleR
- result typefn1
- 3-argument function returning a 4-tuplefn2
- 4-argument function which can use the expanded tuple elements as arguments and returns the result value@NotNull static <S1,S2,S3,E1,E2,E3,E4> Procedure3<S1,S2,S3> concatProc3(@NotNull Function3<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3> fn1, @NotNull Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 3-argument function returning a 4-tupleproc2
- 4-argument consumer/procedure which can use the expanded tuple elements as arguments@NotNull static <S1,S2,S3,E1,E2,E3,E4> Predicate3<S1,S2,S3> concatPred3(@NotNull Function3<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3> fn1, @NotNull Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 3-argument function returning a 4-tuplepred2
- 4-argument predicate which can use the expanded tuple elements as argumentsfn1
@NotNull static <S1,S2,S3,S4,E1,E2,E3,E4,R> Function4<R,S1,S2,S3,S4> concat4(@NotNull Function4<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4> fn1, @NotNull Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
S1
- first argument of incoming function fn1
and returned functionS2
- second argument of incoming function fn1
and returned functionS3
- third argument of incoming function fn1
and returned functionS4
- fourth argument of incoming function fn1
and returned functionE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tupleR
- result typefn1
- 4-argument function returning a 4-tuplefn2
- 4-argument function which can use the expanded tuple elements as arguments and returns the result value@NotNull static <S1,S2,S3,S4,E1,E2,E3,E4> Procedure4<S1,S2,S3,S4> concatProc4(@NotNull Function4<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4> fn1, @NotNull Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureS4
- fourth argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 4-argument function returning a 4-tupleproc2
- 4-argument consumer/procedure which can use the expanded tuple elements as arguments@NotNull static <S1,S2,S3,S4,E1,E2,E3,E4> Predicate4<S1,S2,S3,S4> concatPred4(@NotNull Function4<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4> fn1, @NotNull Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureS4
- fourth argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 4-argument function returning a 4-tuplepred2
- 4-argument predicate which can use the expanded tuple elements as argumentsfn1
@NotNull static <S1,S2,S3,S4,S5,E1,E2,E3,E4,R> Function5<R,S1,S2,S3,S4,S5> concat5(@NotNull Function5<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5> fn1, @NotNull Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
S1
- first argument of incoming function fn1
and returned functionS2
- second argument of incoming function fn1
and returned functionS3
- third argument of incoming function fn1
and returned functionS4
- fourth argument of incoming function fn1
and returned functionS5
- fifth argument of incoming function fn1
and returned functionE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tupleR
- result typefn1
- 5-argument function returning a 4-tuplefn2
- 4-argument function which can use the expanded tuple elements as arguments and returns the result value@NotNull static <S1,S2,S3,S4,S5,E1,E2,E3,E4> Procedure5<S1,S2,S3,S4,S5> concatProc5(@NotNull Function5<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5> fn1, @NotNull Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureS4
- fourth argument of function and returned consumer/procedureS5
- fifth argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 5-argument function returning a 4-tupleproc2
- 4-argument consumer/procedure which can use the expanded tuple elements as arguments@NotNull static <S1,S2,S3,S4,S5,E1,E2,E3,E4> Predicate5<S1,S2,S3,S4,S5> concatPred5(@NotNull Function5<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5> fn1, @NotNull Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureS4
- fourth argument of function and returned consumer/procedureS5
- fifth argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 5-argument function returning a 4-tuplepred2
- 4-argument predicate which can use the expanded tuple elements as argumentsfn1
@NotNull static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4,R> Function6<R,S1,S2,S3,S4,S5,S6> concat6(@NotNull Function6<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6> fn1, @NotNull Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
S1
- first argument of incoming function fn1
and returned functionS2
- second argument of incoming function fn1
and returned functionS3
- third argument of incoming function fn1
and returned functionS4
- fourth argument of incoming function fn1
and returned functionS5
- fifth argument of incoming function fn1
and returned functionS6
- sixth argument of incoming function fn1
and returned functionE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tupleR
- result typefn1
- 6-argument function returning a 4-tuplefn2
- 4-argument function which can use the expanded tuple elements as arguments and returns the result value@NotNull static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4> Procedure6<S1,S2,S3,S4,S5,S6> concatProc6(@NotNull Function6<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6> fn1, @NotNull Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureS4
- fourth argument of function and returned consumer/procedureS5
- fifth argument of function and returned consumer/procedureS6
- sixth argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 6-argument function returning a 4-tupleproc2
- 4-argument consumer/procedure which can use the expanded tuple elements as arguments@NotNull static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4> Predicate6<S1,S2,S3,S4,S5,S6> concatPred6(@NotNull Function6<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6> fn1, @NotNull Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureS4
- fourth argument of function and returned consumer/procedureS5
- fifth argument of function and returned consumer/procedureS6
- sixth argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 6-argument function returning a 4-tuplepred2
- 4-argument predicate which can use the expanded tuple elements as argumentsfn1
@NotNull static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4,R> Function7<R,S1,S2,S3,S4,S5,S6,S7> concat7(@NotNull Function7<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7> fn1, @NotNull Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
S1
- first argument of incoming function fn1
and returned functionS2
- second argument of incoming function fn1
and returned functionS3
- third argument of incoming function fn1
and returned functionS4
- fourth argument of incoming function fn1
and returned functionS5
- fifth argument of incoming function fn1
and returned functionS6
- sixth argument of incoming function fn1
and returned functionS7
- seventh argument of incoming function fn1
and returned functionE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tupleR
- result typefn1
- 7-argument function returning a 4-tuplefn2
- 4-argument function which can use the expanded tuple elements as arguments and returns the result value@NotNull static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4> Procedure7<S1,S2,S3,S4,S5,S6,S7> concatProc7(@NotNull Function7<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7> fn1, @NotNull Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureS4
- fourth argument of function and returned consumer/procedureS5
- fifth argument of function and returned consumer/procedureS6
- sixth argument of function and returned consumer/procedureS7
- seventh argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 7-argument function returning a 4-tupleproc2
- 4-argument consumer/procedure which can use the expanded tuple elements as arguments@NotNull static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4> Predicate7<S1,S2,S3,S4,S5,S6,S7> concatPred7(@NotNull Function7<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7> fn1, @NotNull Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureS4
- fourth argument of function and returned consumer/procedureS5
- fifth argument of function and returned consumer/procedureS6
- sixth argument of function and returned consumer/procedureS7
- seventh argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 7-argument function returning a 4-tuplepred2
- 4-argument predicate which can use the expanded tuple elements as argumentsfn1
@NotNull static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4,R> Function8<R,S1,S2,S3,S4,S5,S6,S7,S8> concat8(@NotNull Function8<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, @NotNull Function4<R,? super E1,? super E2,? super E3,? super E4> fn2)
S1
- first argument of incoming function fn1
and returned functionS2
- second argument of incoming function fn1
and returned functionS3
- third argument of incoming function fn1
and returned functionS4
- fourth argument of incoming function fn1
and returned functionS5
- fifth argument of incoming function fn1
and returned functionS6
- sixth argument of incoming function fn1
and returned functionS7
- seventh argument of incoming function fn1
and returned functionS8
- eighth argument of incoming function fn1
and returned functionE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tupleR
- result typefn1
- 8-argument function returning a 4-tuplefn2
- 4-argument function which can use the expanded tuple elements as arguments and returns the result value@NotNull static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4> Procedure8<S1,S2,S3,S4,S5,S6,S7,S8> concatProc8(@NotNull Function8<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, @NotNull Procedure4<? super E1,? super E2,? super E3,? super E4> proc2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureS4
- fourth argument of function and returned consumer/procedureS5
- fifth argument of function and returned consumer/procedureS6
- sixth argument of function and returned consumer/procedureS7
- seventh argument of function and returned consumer/procedureS8
- eighth argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 8-argument function returning a 4-tupleproc2
- 4-argument consumer/procedure which can use the expanded tuple elements as arguments@NotNull static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4> Predicate8<S1,S2,S3,S4,S5,S6,S7,S8> concatPred8(@NotNull Function8<? extends ITuple4<? extends E1,? extends E2,? extends E3,? extends E4>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, @NotNull Predicate4<? super E1,? super E2,? super E3,? super E4> pred2)
S1
- first argument of function and returned consumer/procedureS2
- second argument of function and returned consumer/procedureS3
- third argument of function and returned consumer/procedureS4
- fourth argument of function and returned consumer/procedureS5
- fifth argument of function and returned consumer/procedureS6
- sixth argument of function and returned consumer/procedureS7
- seventh argument of function and returned consumer/procedureS8
- eighth argument of function and returned consumer/procedureE1
- type of first element of intermediate tupleE2
- type of second element of intermediate tupleE3
- type of third element of intermediate tupleE4
- type of fourth element of intermediate tuplefn1
- 8-argument function returning a 4-tuplepred2
- 4-argument predicate which can use the expanded tuple elements as argumentsfn1