de.caff.generics.tuple

## Class NTuple4<T1,T2,T3,T4>

- java.lang.Object
- - de.caff.generics.tuple.ITuple4.Base<T1,T2,T3,T4>
  - - de.caff.generics.tuple.NTuple4<T1,T2,T3,T4>

- Type Parameters:
    `T1` - type of first element
    `T2` - type of second element
    `T3` - type of third element
    `T4` - type of fourth element
  All Implemented Interfaces:
    ITuple4<T1,T2,T3,T4>, java.io.Serializable

      public class NTuple4<T1,T2,T3,T4>
      extends ITuple4.Base<T1,T2,T3,T4>
      implements java.io.Serializable

  Immutable tuple with 4 nullable elements. 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).
  Since:
    November 17, 2021
  Author:
    Rammi
  See Also:
    `Tuple4`, Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface de.caff.generics.tuple.ITuple4

      `ITuple4.Base<T1,T2,T3,T4>`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `NTuple4(T1 e1, T2 e2, T3 e3, T4 e4)` Constructor.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `T1` | `_1()` Get the first element.
    `NTuple2<T1,T2>` | `_12()` Create a new 2-tuple from this one where the elements are ordered: 1st, 2nd.
    `NTuple3<T1,T2,T3>` | `_123()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 3rd.
    `NTuple3<T1,T2,T4>` | `_124()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 4th.
    `NTuple4<T1,T2,T4,T3>` | `_1243()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 3rd.
    `NTuple2<T1,T3>` | `_13()` Create a new 2-tuple from this one where the elements are ordered: 1st, 3rd.
    `NTuple3<T1,T3,T2>` | `_132()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 2nd.
    `NTuple4<T1,T3,T2,T4>` | `_1324()` Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 2nd, 4th.
    `NTuple3<T1,T3,T4>` | `_134()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 4th.
    `NTuple4<T1,T3,T4,T2>` | `_1342()` Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 2nd.
    `NTuple2<T1,T4>` | `_14()` Create a new 2-tuple from this one where the elements are ordered: 1st, 4th.
    `NTuple3<T1,T4,T2>` | `_142()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 2nd.
    `NTuple4<T1,T4,T2,T3>` | `_1423()` Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 2nd, 3rd.
    `NTuple3<T1,T4,T3>` | `_143()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 3rd.
    `NTuple4<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.
    `NTuple2<T2,T1>` | `_21()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 1st.
    `NTuple3<T2,T1,T3>` | `_213()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 3rd.
    `NTuple4<T2,T1,T3,T4>` | `_2134()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 3rd, 4th.
    `NTuple3<T2,T1,T4>` | `_214()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 4th.
    `NTuple4<T2,T1,T4,T3>` | `_2143()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 4th, 3rd.
    `NTuple2<T2,T3>` | `_23()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 3rd.
    `NTuple3<T2,T3,T1>` | `_231()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 1st.
    `NTuple4<T2,T3,T1,T4>` | `_2314()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 1st, 4th.
    `NTuple3<T2,T3,T4>` | `_234()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 4th.
    `NTuple4<T2,T3,T4,T1>` | `_2341()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 1st.
    `NTuple2<T2,T4>` | `_24()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 4th.
    `NTuple3<T2,T4,T1>` | `_241()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 1st.
    `NTuple4<T2,T4,T1,T3>` | `_2413()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 1st, 3rd.
    `NTuple3<T2,T4,T3>` | `_243()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 3rd.
    `NTuple4<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.
    `NTuple2<T3,T1>` | `_31()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 1st.
    `NTuple3<T3,T1,T2>` | `_312()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 2nd.
    `NTuple4<T3,T1,T2,T4>` | `_3124()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 2nd, 4th.
    `NTuple3<T3,T1,T4>` | `_314()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 4th.
    `NTuple4<T3,T1,T4,T2>` | `_3142()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 4th, 2nd.
    `NTuple2<T3,T2>` | `_32()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 2nd.
    `NTuple3<T3,T2,T1>` | `_321()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 1st.
    `NTuple4<T3,T2,T1,T4>` | `_3214()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 1st, 4th.
    `NTuple3<T3,T2,T4>` | `_324()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 4th.
    `NTuple4<T3,T2,T4,T1>` | `_3241()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 4th, 1st.
    `NTuple2<T3,T4>` | `_34()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 4th.
    `NTuple3<T3,T4,T1>` | `_341()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 1st.
    `NTuple4<T3,T4,T1,T2>` | `_3412()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 1st, 2nd.
    `NTuple3<T3,T4,T2>` | `_342()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 2nd.
    `NTuple4<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.
    `NTuple2<T4,T1>` | `_41()` Create a new 2-tuple from this one where the elements are ordered: 4th, 1st.
    `NTuple3<T4,T1,T2>` | `_412()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 2nd.
    `NTuple4<T4,T1,T2,T3>` | `_4123()` Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 2nd, 3rd.
    `NTuple3<T4,T1,T3>` | `_413()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 3rd.
    `NTuple4<T4,T1,T3,T2>` | `_4132()` Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 3rd, 2nd.
    `NTuple2<T4,T2>` | `_42()` Create a new 2-tuple from this one where the elements are ordered: 4th, 2nd.
    `NTuple3<T4,T2,T1>` | `_421()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 1st.
    `NTuple4<T4,T2,T1,T3>` | `_4213()` Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 1st, 3rd.
    `NTuple3<T4,T2,T3>` | `_423()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 3rd.
    `NTuple4<T4,T2,T3,T1>` | `_4231()` Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 3rd, 1st.
    `NTuple2<T4,T3>` | `_43()` Create a new 2-tuple from this one where the elements are ordered: 4th, 3rd.
    `NTuple3<T4,T3,T1>` | `_431()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 1st.
    `NTuple4<T4,T3,T1,T2>` | `_4312()` Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 1st, 2nd.
    `NTuple3<T4,T3,T2>` | `_432()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 2nd.
    `NTuple4<T4,T3,T2,T1>` | `_4321()` Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 2nd, 1st.
    `NTuple4<T1,T2,T3,T4>` | `frozen()` Convert this into an object of a concrete tuple implementation.
    `<T> NTuple5<T,T1,T2,T3,T4>` | `i1(T e1)` Create a 5-tuple from this 4-tuple by inserting a new first element.
    `<T> NTuple5<T1,T,T2,T3,T4>` | `i2(T e2)` Create a 5-tuple from this 4-tuple by inserting a new second element.
    `<T> NTuple5<T1,T2,T,T3,T4>` | `i3(T e3)` Create a 5-tuple from this 4-tuple by inserting a new third element.
    `<T> NTuple5<T1,T2,T3,T,T4>` | `i4(T e4)` Create a 5-tuple from this 4-tuple by inserting a new fourth element.
    `<T> NTuple5<T1,T2,T3,T4,T>` | `i5(T e5)` Create a 5-tuple from this 4-tuple by adding a new fifth element.
    `java.lang.String` | `toString()`
    `<E1> NTuple4<E1,T2,T3,T4>` | `x1(E1 e1)` Create a 4-tuple from this one where the first element is exchanged.
    `<E1,E2> NTuple4<E1,E2,T3,T4>` | `x12(E1 e1, E2 e2)` Create a 4-tuple from this one where the first and second elements are exchanged.
    `<E1,E2,E3> NTuple4<E1,E2,E3,T4>` | `x123(E1 e1, E2 e2, E3 e3)` Create a 4-tuple from this one where the first, second, and thirdelements are exchanged.
    `<E1,E2,E4> NTuple4<E1,E2,T3,E4>` | `x124(E1 e1, E2 e2, E4 e4)` Create a 4-tuple from this one where the first, second, and fourthelements are exchanged.
    `<E1,E3> NTuple4<E1,T2,E3,T4>` | `x13(E1 e1, E3 e3)` Create a 4-tuple from this one where the first and third elements are exchanged.
    `<E1,E3,E4> NTuple4<E1,T2,E3,E4>` | `x134(E1 e1, E3 e3, E4 e4)` Create a 4-tuple from this one where the first, third, and fourthelements are exchanged.
    `<E1,E4> NTuple4<E1,T2,T3,E4>` | `x14(E1 e1, E4 e4)` Create a 4-tuple from this one where the first and fourth elements are exchanged.
    `<E2> NTuple4<T1,E2,T3,T4>` | `x2(E2 e2)` Create a 4-tuple from this one where the second element is exchanged.
    `<E2,E3> NTuple4<T1,E2,E3,T4>` | `x23(E2 e2, E3 e3)` Create a 4-tuple from this one where the second and third elements are exchanged.
    `<E2,E3,E4> NTuple4<T1,E2,E3,E4>` | `x234(E2 e2, E3 e3, E4 e4)` Create a 4-tuple from this one where the second, third, and fourthelements are exchanged.
    `<E2,E4> NTuple4<T1,E2,T3,E4>` | `x24(E2 e2, E4 e4)` Create a 4-tuple from this one where the second and fourth elements are exchanged.
    `<E3> NTuple4<T1,T2,E3,T4>` | `x3(E3 e3)` Create a 4-tuple from this one where the third element is exchanged.
    `<E3,E4> NTuple4<T1,T2,E3,E4>` | `x34(E3 e3, E4 e4)` Create a 4-tuple from this one where the third and fourth elements are exchanged.
    `<E4> NTuple4<T1,T2,T3,E4>` | `x4(E4 e4)` Create a 4-tuple from this one where the fourth element is exchanged.

    - ### Methods inherited from class de.caff.generics.tuple.ITuple4.Base

      `asBase, equals, hashCode`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface de.caff.generics.tuple.ITuple4

      `concat1, concat2, concat3, concat4, concat5, concat6, concat7, concat8, concatPred1, concatPred2, concatPred3, concatPred4, concatPred5, concatPred6, concatPred7, concatPred8, concatProc1, concatProc2, concatProc3, concatProc4, concatProc5, concatProc6, concatProc7, concatProc8, equals, frozenNotNull, hash, invoke, sendTo, testBy, toString, toString, view`

- - ### Constructor Detail

    - #### NTuple4

          public NTuple4(@Nullable
                         T1 e1,
                         @Nullable
                         T2 e2,
                         @Nullable
                         T3 e3,
                         @Nullable
                         T4 e4)

      Constructor.
      Parameters:
        `e1` - first element
        `e2` - second element
        `e3` - third element
        `e4` - fourth element

  - ### Method Detail

    - #### _1

          @Nullable
          public T1 _1()

      Description copied from interface: `ITuple4`
      Get the first element.
      Specified by:
        `_1` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        first element

    - #### _2

          @Nullable
          public T2 _2()

      Description copied from interface: `ITuple4`
      Get the second element.
      Specified by:
        `_2` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        second element

    - #### _3

          @Nullable
          public T3 _3()

      Description copied from interface: `ITuple4`
      Get the third element.
      Specified by:
        `_3` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        third element

    - #### _4

          @Nullable
          public T4 _4()

      Description copied from interface: `ITuple4`
      Get the fourth element.
      Specified by:
        `_4` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        fourth element

    - #### _1243

          @NotNull
          public NTuple4<T1,T2,T4,T3> _1243()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 3rd.
      Specified by:
        `_1243` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _1423

          @NotNull
          public NTuple4<T1,T4,T2,T3> _1423()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 2nd, 3rd.
      Specified by:
        `_1423` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _4123

          @NotNull
          public NTuple4<T4,T1,T2,T3> _4123()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 2nd, 3rd.
      Specified by:
        `_4123` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _4132

          @NotNull
          public NTuple4<T4,T1,T3,T2> _4132()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 4th, 1st, 3rd, 2nd.
      Specified by:
        `_4132` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _1432

          @NotNull
          public NTuple4<T1,T4,T3,T2> _1432()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 3rd, 2nd.
      Specified by:
        `_1432` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _1342

          @NotNull
          public NTuple4<T1,T3,T4,T2> _1342()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 2nd.
      Specified by:
        `_1342` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _1324

          @NotNull
          public NTuple4<T1,T3,T2,T4> _1324()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 2nd, 4th.
      Specified by:
        `_1324` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _3124

          @NotNull
          public NTuple4<T3,T1,T2,T4> _3124()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 2nd, 4th.
      Specified by:
        `_3124` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _3142

          @NotNull
          public NTuple4<T3,T1,T4,T2> _3142()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 3rd, 1st, 4th, 2nd.
      Specified by:
        `_3142` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _3412

          @NotNull
          public NTuple4<T3,T4,T1,T2> _3412()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 1st, 2nd.
      Specified by:
        `_3412` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _4312

          @NotNull
          public NTuple4<T4,T3,T1,T2> _4312()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 1st, 2nd.
      Specified by:
        `_4312` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _4321

          @NotNull
          public NTuple4<T4,T3,T2,T1> _4321()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 4th, 3rd, 2nd, 1st.
      Specified by:
        `_4321` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _3421

          @NotNull
          public NTuple4<T3,T4,T2,T1> _3421()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 2nd, 1st.
      Specified by:
        `_3421` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _3241

          @NotNull
          public NTuple4<T3,T2,T4,T1> _3241()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 4th, 1st.
      Specified by:
        `_3241` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _3214

          @NotNull
          public NTuple4<T3,T2,T1,T4> _3214()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 3rd, 2nd, 1st, 4th.
      Specified by:
        `_3214` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _2314

          @NotNull
          public NTuple4<T2,T3,T1,T4> _2314()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 1st, 4th.
      Specified by:
        `_2314` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _2341

          @NotNull
          public NTuple4<T2,T3,T4,T1> _2341()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 1st.
      Specified by:
        `_2341` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _2431

          @NotNull
          public NTuple4<T2,T4,T3,T1> _2431()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 3rd, 1st.
      Specified by:
        `_2431` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _4231

          @NotNull
          public NTuple4<T4,T2,T3,T1> _4231()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 3rd, 1st.
      Specified by:
        `_4231` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _4213

          @NotNull
          public NTuple4<T4,T2,T1,T3> _4213()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 4th, 2nd, 1st, 3rd.
      Specified by:
        `_4213` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _2413

          @NotNull
          public NTuple4<T2,T4,T1,T3> _2413()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 1st, 3rd.
      Specified by:
        `_2413` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _2143

          @NotNull
          public NTuple4<T2,T1,T4,T3> _2143()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 4th, 3rd.
      Specified by:
        `_2143` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _2134

          @NotNull
          public NTuple4<T2,T1,T3,T4> _2134()

      Description copied from interface: `ITuple4`
      Create a new 4-tuple from this one where the elements are ordered: 2nd, 1st, 3rd, 4th.
      Specified by:
        `_2134` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _123

          @NotNull
          public NTuple3<T1,T2,T3> _123()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 3rd.
      Specified by:
        `_123` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _132

          @NotNull
          public NTuple3<T1,T3,T2> _132()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 2nd.
      Specified by:
        `_132` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _312

          @NotNull
          public NTuple3<T3,T1,T2> _312()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 2nd.
      Specified by:
        `_312` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _321

          @NotNull
          public NTuple3<T3,T2,T1> _321()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 1st.
      Specified by:
        `_321` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _231

          @NotNull
          public NTuple3<T2,T3,T1> _231()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 1st.
      Specified by:
        `_231` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _213

          @NotNull
          public NTuple3<T2,T1,T3> _213()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 3rd.
      Specified by:
        `_213` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _124

          @NotNull
          public NTuple3<T1,T2,T4> _124()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 4th.
      Specified by:
        `_124` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _142

          @NotNull
          public NTuple3<T1,T4,T2> _142()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 2nd.
      Specified by:
        `_142` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _412

          @NotNull
          public NTuple3<T4,T1,T2> _412()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 2nd.
      Specified by:
        `_412` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _421

          @NotNull
          public NTuple3<T4,T2,T1> _421()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 1st.
      Specified by:
        `_421` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _241

          @NotNull
          public NTuple3<T2,T4,T1> _241()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 1st.
      Specified by:
        `_241` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _214

          @NotNull
          public NTuple3<T2,T1,T4> _214()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 4th.
      Specified by:
        `_214` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _134

          @NotNull
          public NTuple3<T1,T3,T4> _134()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 4th.
      Specified by:
        `_134` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _143

          @NotNull
          public NTuple3<T1,T4,T3> _143()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 3rd.
      Specified by:
        `_143` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _413

          @NotNull
          public NTuple3<T4,T1,T3> _413()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 3rd.
      Specified by:
        `_413` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _431

          @NotNull
          public NTuple3<T4,T3,T1> _431()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 1st.
      Specified by:
        `_431` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _341

          @NotNull
          public NTuple3<T3,T4,T1> _341()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 1st.
      Specified by:
        `_341` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _314

          @NotNull
          public NTuple3<T3,T1,T4> _314()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 4th.
      Specified by:
        `_314` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _234

          @NotNull
          public NTuple3<T2,T3,T4> _234()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 4th.
      Specified by:
        `_234` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _243

          @NotNull
          public NTuple3<T2,T4,T3> _243()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 3rd.
      Specified by:
        `_243` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _423

          @NotNull
          public NTuple3<T4,T2,T3> _423()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 3rd.
      Specified by:
        `_423` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _432

          @NotNull
          public NTuple3<T4,T3,T2> _432()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 2nd.
      Specified by:
        `_432` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _342

          @NotNull
          public NTuple3<T3,T4,T2> _342()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 2nd.
      Specified by:
        `_342` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _324

          @NotNull
          public NTuple3<T3,T2,T4> _324()

      Description copied from interface: `ITuple4`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 4th.
      Specified by:
        `_324` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _12

          @NotNull
          public NTuple2<T1,T2> _12()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 1st, 2nd.
      Specified by:
        `_12` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _21

          @NotNull
          public NTuple2<T2,T1> _21()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 2nd, 1st.
      Specified by:
        `_21` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _13

          @NotNull
          public NTuple2<T1,T3> _13()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 1st, 3rd.
      Specified by:
        `_13` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _31

          @NotNull
          public NTuple2<T3,T1> _31()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 3rd, 1st.
      Specified by:
        `_31` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _23

          @NotNull
          public NTuple2<T2,T3> _23()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 2nd, 3rd.
      Specified by:
        `_23` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _32

          @NotNull
          public NTuple2<T3,T2> _32()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 3rd, 2nd.
      Specified by:
        `_32` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _14

          @NotNull
          public NTuple2<T1,T4> _14()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 1st, 4th.
      Specified by:
        `_14` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _41

          @NotNull
          public NTuple2<T4,T1> _41()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 4th, 1st.
      Specified by:
        `_41` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _24

          @NotNull
          public NTuple2<T2,T4> _24()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 2nd, 4th.
      Specified by:
        `_24` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _42

          @NotNull
          public NTuple2<T4,T2> _42()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 4th, 2nd.
      Specified by:
        `_42` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _34

          @NotNull
          public NTuple2<T3,T4> _34()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 3rd, 4th.
      Specified by:
        `_34` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### _43

          @NotNull
          public NTuple2<T4,T3> _43()

      Description copied from interface: `ITuple4`
      Create a new 2-tuple from this one where the elements are ordered: 4th, 3rd.
      Specified by:
        `_43` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        reordered tuple

    - #### frozen

          @NotNull
          public NTuple4<T1,T2,T3,T4> frozen()

      Description copied from interface: `ITuple4`
      Convert this into an object of a concrete tuple implementation. This is useful because implementations may just be a view of something else. This method makes sure to decouple the tuple from the viewed object. The resulting tuple may contain `null` elements, see `ITuple4.frozenNotNull()` for a method which returns tuples which don't have nullable elements.
      Specified by:
        `frozen` in interface `ITuple4<T1,T2,T3,T4>`
      Returns:
        standalone tuple object

    - #### x1

          @NotNull
          public <E1> NTuple4<E1,T2,T3,T4> x1(@Nullable
                                                       E1 e1)

      Create a 4-tuple from this one where the first element is exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
      Parameters:
        `e1` - new first element
      Returns:
        tuple with exchanged element

    - #### x2

          @NotNull
          public <E2> NTuple4<T1,E2,T3,T4> x2(@Nullable
                                                       E2 e2)

      Create a 4-tuple from this one where the second element is exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
      Parameters:
        `e2` - new second element
      Returns:
        tuple with exchanged element

    - #### x3

          @NotNull
          public <E3> NTuple4<T1,T2,E3,T4> x3(@Nullable
                                                       E3 e3)

      Create a 4-tuple from this one where the third element is exchanged.
      Type Parameters:
        `E3` - type of exchanged third element
      Parameters:
        `e3` - new third element
      Returns:
        tuple with exchanged element

    - #### x4

          @NotNull
          public <E4> NTuple4<T1,T2,T3,E4> x4(@Nullable
                                                       E4 e4)

      Create a 4-tuple from this one where the fourth element is exchanged.
      Type Parameters:
        `E4` - type of exchanged fourth element
      Parameters:
        `e4` - new fourth element
      Returns:
        tuple with exchanged element

    - #### x12

          @NotNull
          public <E1,E2> NTuple4<E1,E2,T3,T4> x12(@Nullable
                                                           E1 e1,
                                                           @Nullable
                                                           E2 e2)

      Create a 4-tuple from this one where the first and second elements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
      Parameters:
        `e1` - new first element
        `e2` - new second element
      Returns:
        tuple with exchanged elements

    - #### x13

          @NotNull
          public <E1,E3> NTuple4<E1,T2,E3,T4> x13(@Nullable
                                                           E1 e1,
                                                           @Nullable
                                                           E3 e3)

      Create a 4-tuple from this one where the first and third elements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E3` - type of exchanged third element
      Parameters:
        `e1` - new first element
        `e3` - new third element
      Returns:
        tuple with exchanged elements

    - #### x23

          @NotNull
          public <E2,E3> NTuple4<T1,E2,E3,T4> x23(@Nullable
                                                           E2 e2,
                                                           @Nullable
                                                           E3 e3)

      Create a 4-tuple from this one where the second and third elements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
      Parameters:
        `e2` - new second element
        `e3` - new third element
      Returns:
        tuple with exchanged elements

    - #### x14

          @NotNull
          public <E1,E4> NTuple4<E1,T2,T3,E4> x14(@Nullable
                                                           E1 e1,
                                                           @Nullable
                                                           E4 e4)

      Create a 4-tuple from this one where the first and fourth elements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E4` - type of exchanged fourth element
      Parameters:
        `e1` - new first element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x24

          @NotNull
          public <E2,E4> NTuple4<T1,E2,T3,E4> x24(@Nullable
                                                           E2 e2,
                                                           @Nullable
                                                           E4 e4)

      Create a 4-tuple from this one where the second and fourth elements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E4` - type of exchanged fourth element
      Parameters:
        `e2` - new second element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x34

          @NotNull
          public <E3,E4> NTuple4<T1,T2,E3,E4> x34(@Nullable
                                                           E3 e3,
                                                           @Nullable
                                                           E4 e4)

      Create a 4-tuple from this one where the third and fourth elements are exchanged.
      Type Parameters:
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
      Parameters:
        `e3` - new third element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x123

          @NotNull
          public <E1,E2,E3> NTuple4<E1,E2,E3,T4> x123(@Nullable
                                                               E1 e1,
                                                               @Nullable
                                                               E2 e2,
                                                               @Nullable
                                                               E3 e3)

      Create a 4-tuple from this one where the first, second, and thirdelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e3` - new third element
      Returns:
        tuple with exchanged elements

    - #### x124

          @NotNull
          public <E1,E2,E4> NTuple4<E1,E2,T3,E4> x124(@Nullable
                                                               E1 e1,
                                                               @Nullable
                                                               E2 e2,
                                                               @Nullable
                                                               E4 e4)

      Create a 4-tuple from this one where the first, second, and fourthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E4` - type of exchanged fourth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x134

          @NotNull
          public <E1,E3,E4> NTuple4<E1,T2,E3,E4> x134(@Nullable
                                                               E1 e1,
                                                               @Nullable
                                                               E3 e3,
                                                               @Nullable
                                                               E4 e4)

      Create a 4-tuple from this one where the first, third, and fourthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
      Parameters:
        `e1` - new first element
        `e3` - new third element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x234

          @NotNull
          public <E2,E3,E4> NTuple4<T1,E2,E3,E4> x234(@Nullable
                                                               E2 e2,
                                                               @Nullable
                                                               E3 e3,
                                                               @Nullable
                                                               E4 e4)

      Create a 4-tuple from this one where the second, third, and fourthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
      Parameters:
        `e2` - new second element
        `e3` - new third element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### i1

          @NotNull
          public <T> NTuple5<T,T1,T2,T3,T4> i1(@Nullable
                                                        T e1)

      Create a 5-tuple from this 4-tuple by inserting a new first element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e1` - new element
      Returns:
        5-tuple

    - #### i2

          @NotNull
          public <T> NTuple5<T1,T,T2,T3,T4> i2(@Nullable
                                                        T e2)

      Create a 5-tuple from this 4-tuple by inserting a new second element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e2` - new element
      Returns:
        5-tuple

    - #### i3

          @NotNull
          public <T> NTuple5<T1,T2,T,T3,T4> i3(@Nullable
                                                        T e3)

      Create a 5-tuple from this 4-tuple by inserting a new third element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e3` - new element
      Returns:
        5-tuple

    - #### i4

          @NotNull
          public <T> NTuple5<T1,T2,T3,T,T4> i4(@Nullable
                                                        T e4)

      Create a 5-tuple from this 4-tuple by inserting a new fourth element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e4` - new element
      Returns:
        5-tuple

    - #### i5

          @NotNull
          public <T> NTuple5<T1,T2,T3,T4,T> i5(@Nullable
                                                        T e5)

      Create a 5-tuple from this 4-tuple by adding a new fifth element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e5` - new element
      Returns:
        5-tuple

    - #### toString

          @NotNull
          public java.lang.String toString()

      Overrides:
        `toString` in class `ITuple4.Base<T1,T2,T3,T4>`