Package no.digipost.tuple

Interface Quadruple<T1,T2,T3,T4>

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
All Superinterfaces:
ViewableAsQuadruple<T1,T2,T3,T4>
public interface Quadruple<T1,T2,T3,T4> extends ViewableAsQuadruple<T1,T2,T3,T4>
A quadruple is a simple composition of four arbitrary values (objects). A quadruple captures no semantics of the four values, and they are only referred to as "the first", "the second", "the third", and "the fourth" value.

  • Method Summary

    Modifier and Type
    Method
    Description
    Quadruple<T1,T2,T3,T4>
    asQuadruple()
     
    T1
    first()
     
    static <T1, T2, T3, T4>
    Quadruple<T1,T2,T3,T4>
    flatten(Tuple<Tuple<Tuple<T1,T2>,T3>,T4> nestedTuple)
     
    T4
    fourth()
     
    <S1, S2, S3, S4>
    Quadruple<S1,S2,S3,S4>
    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)
    Create a new quadruple by applying a function to each element, and putting the results into a new quadruple.
    <S1> Quadruple<S1,T2,T3,T4>
    mapFirst(Function<? super T1,? extends S1> mapper)
    Create a new quadruple by applying a function to the first element, and putting the result as the first element of the new quadruple.
    <S4> Quadruple<T1,T2,T3,S4>
    mapFourth(Function<? super T4,? extends S4> mapper)
    Create a new quadruple by applying a function to the fourth element, and putting the result as the fourth element of the new quadruple.
    <S2> Quadruple<T1,S2,T3,T4>
    mapSecond(Function<? super T2,? extends S2> mapper)
    Create a new quadruple by applying a function to the second element, and putting the result as the second element of the new quadruple.
    <S3> Quadruple<T1,T2,S3,T4>
    mapThird(Function<? super T3,? extends S3> mapper)
    Create a new quadruple by applying a function to the third element, and putting the result as the third element of the new quadruple.
    static <T1, T2, T3, T4>
    Quadruple<T1,T2,T3,T4>
    of(T1 first, T2 second, T3 third, T4 fourth)
     
    T2
    second()
     
    T3
    third()
     
    <R> R
    to(QuadFunction<? super T1,? super T2,? super T3,? super T4,R> convertor)
    Convert this quadruple to an instance of an arbitrary type.

  • Method Details

    • of

      static <T1, T2, T3, T4> Quadruple<T1,T2,T3,T4> of(T1 first, T2 second, T3 third, T4 fourth)

    • flatten

      static <T1, T2, T3, T4> Quadruple<T1,T2,T3,T4> flatten(Tuple<Tuple<Tuple<T1,T2>,T3>,T4> 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

    • mapFirst

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

    • mapSecond

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

    • mapThird

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

    • mapFourth

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

    • map

      <S1, S2, S3, S4> Quadruple<S1,S2,S3,S4> 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)
      Create a new quadruple by applying a function to each element, and putting the results into a new quadruple.
      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
      Returns:
      the new quadruple

    • asQuadruple

      Quadruple<T1,T2,T3,T4> asQuadruple()
      Specified by:
      asQuadruple in interface ViewableAsQuadruple<T1,T2,T3,T4>
      Returns:
      this quadruple instance

    • to

      <R> R to(QuadFunction<? super T1,? super T2,? super T3,? super T4,R> convertor)
      Convert this quadruple 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