Package no.digipost.tuple

Interface Hextuple<T1,T2,T3,T4,T5,T6>

Type Parameters:
T1 - The type of the first value
T2 - The type of the second value
T3 - The type of the third value
T4 - The type of the fourth value
T5 - The type of the fifth value
T6 - The type of the sixth value
All Superinterfaces:
ViewableAsHextuple<T1,T2,T3,T4,T5,T6>
public interface Hextuple<T1,T2,T3,T4,T5,T6> extends ViewableAsHextuple<T1,T2,T3,T4,T5,T6>
A hextuple is a simple composition of six arbitrary values (objects). A hextuple captures no semantics of the six values, and they are only referred to as "the first", "the second", "the third", "the fourth", "the fifth", and "the sixth" value.

  • Method Summary

    Modifier and Type
    Method
    Description
    Hextuple<T1,T2,T3,T4,T5,T6>
    asHextuple()
     
    T5
    fifth()
     
    T1
    first()
     
    static <T1, T2, T3, T4, T5, T6>
    Hextuple<T1,T2,T3,T4,T5,T6>
    flatten(Tuple<Tuple<Tuple<Tuple<Tuple<T1,T2>,T3>,T4>,T5>,T6> nestedTuple)
     
    T4
    fourth()
     
    <S1, S2, S3, S4, S5, S6>
    Hextuple<S1,S2,S3,S4,S5,S6>
    map(Function<? super T1,? extends S1> firstMapper, Function<? super T2,? extends S2> secondMapper, Function<? super T3,? extends S3> thirdMapper, Function<? super T4,? extends S4> fourthMapper, Function<? super T5,? extends S5> fifthMapper, Function<? super T6,? extends S6> sixthMapper)
    Create a new hextuple by applying a function to each element, and putting the results into a new hextuple.
    <S5> Hextuple<T1,T2,T3,T4,S5,T6>
    mapFifth(Function<? super T5,? extends S5> mapper)
    Create a new hextuple by applying a function to the fifth element, and putting the result as the fifth element of the new hextuple.
    <S1> Hextuple<S1,T2,T3,T4,T5,T6>
    mapFirst(Function<? super T1,? extends S1> mapper)
    Create a new hextuple by applying a function to the first element, and putting the result as the first element of the new hextuple.
    <S4> Hextuple<T1,T2,T3,S4,T5,T6>
    mapFourth(Function<? super T4,? extends S4> mapper)
    Create a new hextuple by applying a function to the fourth element, and putting the result as the fourth element of the new hextuple.
    <S2> Hextuple<T1,S2,T3,T4,T5,T6>
    mapSecond(Function<? super T2,? extends S2> mapper)
    Create a new hextuple by applying a function to the second element, and putting the result as the second element of the new hextuple.
    <S6> Hextuple<T1,T2,T3,T4,T5,S6>
    mapSixth(Function<? super T6,? extends S6> mapper)
    Create a new hextuple by applying a function to the sixth element, and putting the result as the sixth element of the new hextuple.
    <S3> Hextuple<T1,T2,S3,T4,T5,T6>
    mapThird(Function<? super T3,? extends S3> mapper)
    Create a new hextuple by applying a function to the third element, and putting the result as the third element of the new hextuple.
    static <T1, T2, T3, T4, T5, T6>
    Hextuple<T1,T2,T3,T4,T5,T6>
    of(T1 first, T2 second, T3 third, T4 fourth, T5 fifth, T6 sixth)
     
    T2
    second()
     
    T6
    sixth()
     
    T3
    third()
     
    <R> R
    to(HexaFunction<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,R> convertor)
    Convert this hextuple to an instance of an arbitrary type.

  • Method Details

    • of

      static <T1, T2, T3, T4, T5, T6> Hextuple<T1,T2,T3,T4,T5,T6> of(T1 first, T2 second, T3 third, T4 fourth, T5 fifth, T6 sixth)

    • flatten

      static <T1, T2, T3, T4, T5, T6> Hextuple<T1,T2,T3,T4,T5,T6> flatten(Tuple<Tuple<Tuple<Tuple<Tuple<T1,T2>,T3>,T4>,T5>,T6> nestedTuple)

    • first

      T1 first()
      Returns:
      the first value

    • second

      T2 second()
      Returns:
      the second value

    • third

      T3 third()
      Returns:
      the third value

    • fourth

      T4 fourth()
      Returns:
      the fourth value

    • fifth

      T5 fifth()
      Returns:
      the fifth value

    • sixth

      T6 sixth()
      Returns:
      the sixth value

    • mapFirst

      <S1> Hextuple<S1,T2,T3,T4,T5,T6> mapFirst(Function<? super T1,? extends S1> mapper)
      Create a new hextuple by applying a function to the first element, and putting the result as the first element of the new hextuple.
      Parameters:
      mapper - the function to apply to the first element
      Returns:
      the new hextuple

    • mapSecond

      <S2> Hextuple<T1,S2,T3,T4,T5,T6> mapSecond(Function<? super T2,? extends S2> mapper)
      Create a new hextuple by applying a function to the second element, and putting the result as the second element of the new hextuple.
      Parameters:
      mapper - the function to apply to the second element
      Returns:
      the new hextuple

    • mapThird

      <S3> Hextuple<T1,T2,S3,T4,T5,T6> mapThird(Function<? super T3,? extends S3> mapper)
      Create a new hextuple by applying a function to the third element, and putting the result as the third element of the new hextuple.
      Parameters:
      mapper - the function to apply to the third element
      Returns:
      the new hextuple

    • mapFourth

      <S4> Hextuple<T1,T2,T3,S4,T5,T6> mapFourth(Function<? super T4,? extends S4> mapper)
      Create a new hextuple by applying a function to the fourth element, and putting the result as the fourth element of the new hextuple.
      Parameters:
      mapper - the function to apply to the fourth element
      Returns:
      the new hextuple

    • mapFifth

      <S5> Hextuple<T1,T2,T3,T4,S5,T6> mapFifth(Function<? super T5,? extends S5> mapper)
      Create a new hextuple by applying a function to the fifth element, and putting the result as the fifth element of the new hextuple.
      Parameters:
      mapper - the function to apply to the fifth element
      Returns:
      the new hextuple

    • mapSixth

      <S6> Hextuple<T1,T2,T3,T4,T5,S6> mapSixth(Function<? super T6,? extends S6> mapper)
      Create a new hextuple by applying a function to the sixth element, and putting the result as the sixth element of the new hextuple.
      Parameters:
      mapper - the function to apply to the sixth element
      Returns:
      the new hextuple

    • map

      <S1, S2, S3, S4, S5, S6> Hextuple<S1,S2,S3,S4,S5,S6> map(Function<? super T1,? extends S1> firstMapper, Function<? super T2,? extends S2> secondMapper, Function<? super T3,? extends S3> thirdMapper, Function<? super T4,? extends S4> fourthMapper, Function<? super T5,? extends S5> fifthMapper, Function<? super T6,? extends S6> sixthMapper)
      Create a new hextuple by applying a function to each element, and putting the results into a new hextuple.
      Parameters:
      firstMapper - the function to apply to the first element
      secondMapper - the function to apply to the second element
      thirdMapper - the function to apply to the third element
      fourthMapper - the function to apply to the fourth element
      fifthMapper - the function to apply to the fifth element
      sixthMapper - the function to apply to the sixth element
      Returns:
      the new hextuple

    • asHextuple

      Hextuple<T1,T2,T3,T4,T5,T6> asHextuple()
      Specified by:
      asHextuple in interface ViewableAsHextuple<T1,T2,T3,T4,T5,T6>
      Returns:
      this hextuple instance

    • to

      <R> R to(HexaFunction<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,R> convertor)
      Convert this hextuple to an instance of an arbitrary type.
      Type Parameters:
      R - The type of the resulting instance
      Parameters:
      convertor - the function used to convert the contained values to a resulting compound instance.
      Returns:
      the result from the given function