Class Triplet<A,B,C>

java.lang.Object
org.javatuples.Tuple
org.javatuples.Triplet<A,B,C>
All Implemented Interfaces:
Serializable, Comparable<Tuple>, Iterable<Object>, IValue0<A>, IValue1<B>, IValue2<C>

public final class Triplet<A,B,C> extends Tuple implements IValue0<A>, IValue1<B>, IValue2<C>

A tuple of three elements.

Since:
1.0
See Also:
  • Field Details

    • serialVersionUID

      private static final long serialVersionUID
      See Also:
    • SIZE

      private static final int SIZE
      See Also:
    • val0

      private final A val0
    • val1

      private final B val1
    • val2

      private final C val2
  • Constructor Details

    • Triplet

      public Triplet(A value0, B value1, C value2)
  • Method Details

    • with

      public static <A, B, C> Triplet<A,B,C> with(A value0, B value1, C value2)
    • fromArray

      public static <X> Triplet<X,X,X> fromArray(X[] array)

      Create tuple from array. Array has to have exactly three elements.

      Type Parameters:
      X - the array component type
      Parameters:
      array - the array to be converted to a tuple
      Returns:
      the tuple
    • fromCollection

      public static <X> Triplet<X,X,X> fromCollection(Collection<X> collection)

      Create tuple from collection. Collection has to have exactly three elements.

      Type Parameters:
      X - the collection component type
      Parameters:
      collection - the collection to be converted to a tuple
      Returns:
      the tuple
    • fromIterable

      public static <X> Triplet<X,X,X> fromIterable(Iterable<X> iterable)

      Create tuple from iterable. Iterable has to have exactly three elements.

      Type Parameters:
      X - the iterable component type
      Parameters:
      iterable - the iterable to be converted to a tuple
      Returns:
      the tuple
    • fromIterable

      public static <X> Triplet<X,X,X> fromIterable(Iterable<X> iterable, int index)

      Create tuple from iterable, starting from the specified index. Iterable can have more (or less) elements than the tuple to be created.

      Type Parameters:
      X - the iterable component type
      Parameters:
      iterable - the iterable to be converted to a tuple
      Returns:
      the tuple
    • fromIterable

      private static <X> Triplet<X,X,X> fromIterable(Iterable<X> iterable, int index, boolean exactSize)
    • getValue0

      public A getValue0()
      Specified by:
      getValue0 in interface IValue0<A>
    • getValue1

      public B getValue1()
      Specified by:
      getValue1 in interface IValue1<A>
    • getValue2

      public C getValue2()
      Specified by:
      getValue2 in interface IValue2<A>
    • getSize

      public int getSize()
      Description copied from class: Tuple

      Return the size of the tuple.

      Specified by:
      getSize in class Tuple
      Returns:
      the size of the tuple.
    • addAt0

      public <X0> Quartet<X0,A,B,C> addAt0(X0 value0)
    • addAt1

      public <X0> Quartet<A,X0,B,C> addAt1(X0 value0)
    • addAt2

      public <X0> Quartet<A,B,X0,C> addAt2(X0 value0)
    • addAt3

      public <X0> Quartet<A,B,C,X0> addAt3(X0 value0)
    • addAt0

      public <X0, X1> Quintet<X0,X1,A,B,C> addAt0(X0 value0, X1 value1)
    • addAt1

      public <X0, X1> Quintet<A,X0,X1,B,C> addAt1(X0 value0, X1 value1)
    • addAt2

      public <X0, X1> Quintet<A,B,X0,X1,C> addAt2(X0 value0, X1 value1)
    • addAt3

      public <X0, X1> Quintet<A,B,C,X0,X1> addAt3(X0 value0, X1 value1)
    • addAt0

      public <X0, X1, X2> Sextet<X0,X1,X2,A,B,C> addAt0(X0 value0, X1 value1, X2 value2)
    • addAt1

      public <X0, X1, X2> Sextet<A,X0,X1,X2,B,C> addAt1(X0 value0, X1 value1, X2 value2)
    • addAt2

      public <X0, X1, X2> Sextet<A,B,X0,X1,X2,C> addAt2(X0 value0, X1 value1, X2 value2)
    • addAt3

      public <X0, X1, X2> Sextet<A,B,C,X0,X1,X2> addAt3(X0 value0, X1 value1, X2 value2)
    • addAt0

      public <X0, X1, X2, X3> Septet<X0,X1,X2,X3,A,B,C> addAt0(X0 value0, X1 value1, X2 value2, X3 value3)
    • addAt1

      public <X0, X1, X2, X3> Septet<A,X0,X1,X2,X3,B,C> addAt1(X0 value0, X1 value1, X2 value2, X3 value3)
    • addAt2

      public <X0, X1, X2, X3> Septet<A,B,X0,X1,X2,X3,C> addAt2(X0 value0, X1 value1, X2 value2, X3 value3)
    • addAt3

      public <X0, X1, X2, X3> Septet<A,B,C,X0,X1,X2,X3> addAt3(X0 value0, X1 value1, X2 value2, X3 value3)
    • addAt0

      public <X0, X1, X2, X3, X4> Octet<X0,X1,X2,X3,X4,A,B,C> addAt0(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)
    • addAt1

      public <X0, X1, X2, X3, X4> Octet<A,X0,X1,X2,X3,X4,B,C> addAt1(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)
    • addAt2

      public <X0, X1, X2, X3, X4> Octet<A,B,X0,X1,X2,X3,X4,C> addAt2(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)
    • addAt3

      public <X0, X1, X2, X3, X4> Octet<A,B,C,X0,X1,X2,X3,X4> addAt3(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)
    • addAt0

      public <X0, X1, X2, X3, X4, X5> Ennead<X0,X1,X2,X3,X4,X5,A,B,C> addAt0(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)
    • addAt1

      public <X0, X1, X2, X3, X4, X5> Ennead<A,X0,X1,X2,X3,X4,X5,B,C> addAt1(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)
    • addAt2

      public <X0, X1, X2, X3, X4, X5> Ennead<A,B,X0,X1,X2,X3,X4,X5,C> addAt2(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)
    • addAt3

      public <X0, X1, X2, X3, X4, X5> Ennead<A,B,C,X0,X1,X2,X3,X4,X5> addAt3(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)
    • addAt0

      public <X0, X1, X2, X3, X4, X5, X6> Decade<X0,X1,X2,X3,X4,X5,X6,A,B,C> addAt0(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)
    • addAt1

      public <X0, X1, X2, X3, X4, X5, X6> Decade<A,X0,X1,X2,X3,X4,X5,X6,B,C> addAt1(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)
    • addAt2

      public <X0, X1, X2, X3, X4, X5, X6> Decade<A,B,X0,X1,X2,X3,X4,X5,X6,C> addAt2(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)
    • addAt3

      public <X0, X1, X2, X3, X4, X5, X6> Decade<A,B,C,X0,X1,X2,X3,X4,X5,X6> addAt3(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)
    • addAt0

      public <X0> Quartet<X0,A,B,C> addAt0(Unit<X0> tuple)
    • addAt1

      public <X0> Quartet<A,X0,B,C> addAt1(Unit<X0> tuple)
    • addAt2

      public <X0> Quartet<A,B,X0,C> addAt2(Unit<X0> tuple)
    • addAt3

      public <X0> Quartet<A,B,C,X0> addAt3(Unit<X0> tuple)
    • addAt0

      public <X0, X1> Quintet<X0,X1,A,B,C> addAt0(Pair<X0,X1> tuple)
    • addAt1

      public <X0, X1> Quintet<A,X0,X1,B,C> addAt1(Pair<X0,X1> tuple)
    • addAt2

      public <X0, X1> Quintet<A,B,X0,X1,C> addAt2(Pair<X0,X1> tuple)
    • addAt3

      public <X0, X1> Quintet<A,B,C,X0,X1> addAt3(Pair<X0,X1> tuple)
    • addAt0

      public <X0, X1, X2> Sextet<X0,X1,X2,A,B,C> addAt0(Triplet<X0,X1,X2> tuple)
    • addAt1

      public <X0, X1, X2> Sextet<A,X0,X1,X2,B,C> addAt1(Triplet<X0,X1,X2> tuple)
    • addAt2

      public <X0, X1, X2> Sextet<A,B,X0,X1,X2,C> addAt2(Triplet<X0,X1,X2> tuple)
    • addAt3

      public <X0, X1, X2> Sextet<A,B,C,X0,X1,X2> addAt3(Triplet<X0,X1,X2> tuple)
    • addAt0

      public <X0, X1, X2, X3> Septet<X0,X1,X2,X3,A,B,C> addAt0(Quartet<X0,X1,X2,X3> tuple)
    • addAt1

      public <X0, X1, X2, X3> Septet<A,X0,X1,X2,X3,B,C> addAt1(Quartet<X0,X1,X2,X3> tuple)
    • addAt2

      public <X0, X1, X2, X3> Septet<A,B,X0,X1,X2,X3,C> addAt2(Quartet<X0,X1,X2,X3> tuple)
    • addAt3

      public <X0, X1, X2, X3> Septet<A,B,C,X0,X1,X2,X3> addAt3(Quartet<X0,X1,X2,X3> tuple)
    • addAt0

      public <X0, X1, X2, X3, X4> Octet<X0,X1,X2,X3,X4,A,B,C> addAt0(Quintet<X0,X1,X2,X3,X4> tuple)
    • addAt1

      public <X0, X1, X2, X3, X4> Octet<A,X0,X1,X2,X3,X4,B,C> addAt1(Quintet<X0,X1,X2,X3,X4> tuple)
    • addAt2

      public <X0, X1, X2, X3, X4> Octet<A,B,X0,X1,X2,X3,X4,C> addAt2(Quintet<X0,X1,X2,X3,X4> tuple)
    • addAt3

      public <X0, X1, X2, X3, X4> Octet<A,B,C,X0,X1,X2,X3,X4> addAt3(Quintet<X0,X1,X2,X3,X4> tuple)
    • addAt0

      public <X0, X1, X2, X3, X4, X5> Ennead<X0,X1,X2,X3,X4,X5,A,B,C> addAt0(Sextet<X0,X1,X2,X3,X4,X5> tuple)
    • addAt1

      public <X0, X1, X2, X3, X4, X5> Ennead<A,X0,X1,X2,X3,X4,X5,B,C> addAt1(Sextet<X0,X1,X2,X3,X4,X5> tuple)
    • addAt2

      public <X0, X1, X2, X3, X4, X5> Ennead<A,B,X0,X1,X2,X3,X4,X5,C> addAt2(Sextet<X0,X1,X2,X3,X4,X5> tuple)
    • addAt3

      public <X0, X1, X2, X3, X4, X5> Ennead<A,B,C,X0,X1,X2,X3,X4,X5> addAt3(Sextet<X0,X1,X2,X3,X4,X5> tuple)
    • addAt0

      public <X0, X1, X2, X3, X4, X5, X6> Decade<X0,X1,X2,X3,X4,X5,X6,A,B,C> addAt0(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)
    • addAt1

      public <X0, X1, X2, X3, X4, X5, X6> Decade<A,X0,X1,X2,X3,X4,X5,X6,B,C> addAt1(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)
    • addAt2

      public <X0, X1, X2, X3, X4, X5, X6> Decade<A,B,X0,X1,X2,X3,X4,X5,X6,C> addAt2(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)
    • addAt3

      public <X0, X1, X2, X3, X4, X5, X6> Decade<A,B,C,X0,X1,X2,X3,X4,X5,X6> addAt3(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)
    • add

      public <X0> Quartet<A,B,C,X0> add(X0 value0)
    • add

      public <X0> Quartet<A,B,C,X0> add(Unit<X0> tuple)
    • add

      public <X0, X1> Quintet<A,B,C,X0,X1> add(X0 value0, X1 value1)
    • add

      public <X0, X1> Quintet<A,B,C,X0,X1> add(Pair<X0,X1> tuple)
    • add

      public <X0, X1, X2> Sextet<A,B,C,X0,X1,X2> add(X0 value0, X1 value1, X2 value2)
    • add

      public <X0, X1, X2> Sextet<A,B,C,X0,X1,X2> add(Triplet<X0,X1,X2> tuple)
    • add

      public <X0, X1, X2, X3> Septet<A,B,C,X0,X1,X2,X3> add(X0 value0, X1 value1, X2 value2, X3 value3)
    • add

      public <X0, X1, X2, X3> Septet<A,B,C,X0,X1,X2,X3> add(Quartet<X0,X1,X2,X3> tuple)
    • add

      public <X0, X1, X2, X3, X4> Octet<A,B,C,X0,X1,X2,X3,X4> add(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)
    • add

      public <X0, X1, X2, X3, X4> Octet<A,B,C,X0,X1,X2,X3,X4> add(Quintet<X0,X1,X2,X3,X4> tuple)
    • add

      public <X0, X1, X2, X3, X4, X5> Ennead<A,B,C,X0,X1,X2,X3,X4,X5> add(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)
    • add

      public <X0, X1, X2, X3, X4, X5> Ennead<A,B,C,X0,X1,X2,X3,X4,X5> add(Sextet<X0,X1,X2,X3,X4,X5> tuple)
    • add

      public <X0, X1, X2, X3, X4, X5, X6> Decade<A,B,C,X0,X1,X2,X3,X4,X5,X6> add(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)
    • add

      public <X0, X1, X2, X3, X4, X5, X6> Decade<A,B,C,X0,X1,X2,X3,X4,X5,X6> add(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)
    • setAt0

      public <X> Triplet<X,B,C> setAt0(X value)
    • setAt1

      public <X> Triplet<A,X,C> setAt1(X value)
    • setAt2

      public <X> Triplet<A,B,X> setAt2(X value)
    • removeFrom0

      public Pair<B,C> removeFrom0()
    • removeFrom1

      public Pair<A,C> removeFrom1()
    • removeFrom2

      public Pair<A,B> removeFrom2()