Class Octet<A,B,C,D,E,F,G,H>

java.lang.Object
org.javatuples.Tuple
org.javatuples.Octet<A,B,C,D,E,F,G,H>
All Implemented Interfaces:
Serializable, Comparable<Tuple>, Iterable<Object>, IValue0<A>, IValue1<B>, IValue2<C>, IValue3<D>, IValue4<E>, IValue5<F>, IValue6<G>, IValue7<H>

public final class Octet<A,B,C,D,E,F,G,H> extends Tuple implements IValue0<A>, IValue1<B>, IValue2<C>, IValue3<D>, IValue4<E>, IValue5<F>, IValue6<G>, IValue7<H>

A tuple of eight 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
    • val3

      private final D val3
    • val4

      private final E val4
    • val5

      private final F val5
    • val6

      private final G val6
    • val7

      private final H val7
  • Constructor Details

    • Octet

      public Octet(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7)
  • Method Details

    • with

      public static <A, B, C, D, E, F, G, H> Octet<A,B,C,D,E,F,G,H> with(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7)
    • fromArray

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

      Create tuple from array. Array has to have exactly eight 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> Octet<X,X,X,X,X,X,X,X> fromCollection(Collection<X> collection)

      Create tuple from collection. Collection has to have exactly eight 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> Octet<X,X,X,X,X,X,X,X> fromIterable(Iterable<X> iterable)

      Create tuple from iterable. Iterable has to have exactly eight 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> Octet<X,X,X,X,X,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> Octet<X,X,X,X,X,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>
    • getValue3

      public D getValue3()
      Specified by:
      getValue3 in interface IValue3<A>
    • getValue4

      public E getValue4()
      Specified by:
      getValue4 in interface IValue4<A>
    • getValue5

      public F getValue5()
      Specified by:
      getValue5 in interface IValue5<A>
    • getValue6

      public G getValue6()
      Specified by:
      getValue6 in interface IValue6<A>
    • getValue7

      public H getValue7()
      Specified by:
      getValue7 in interface IValue7<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> Ennead<X0,A,B,C,D,E,F,G,H> addAt0(X0 value0)
    • addAt1

      public <X0> Ennead<A,X0,B,C,D,E,F,G,H> addAt1(X0 value0)
    • addAt2

      public <X0> Ennead<A,B,X0,C,D,E,F,G,H> addAt2(X0 value0)
    • addAt3

      public <X0> Ennead<A,B,C,X0,D,E,F,G,H> addAt3(X0 value0)
    • addAt4

      public <X0> Ennead<A,B,C,D,X0,E,F,G,H> addAt4(X0 value0)
    • addAt5

      public <X0> Ennead<A,B,C,D,E,X0,F,G,H> addAt5(X0 value0)
    • addAt6

      public <X0> Ennead<A,B,C,D,E,F,X0,G,H> addAt6(X0 value0)
    • addAt7

      public <X0> Ennead<A,B,C,D,E,F,G,X0,H> addAt7(X0 value0)
    • addAt8

      public <X0> Ennead<A,B,C,D,E,F,G,H,X0> addAt8(X0 value0)
    • addAt0

      public <X0, X1> Decade<X0,X1,A,B,C,D,E,F,G,H> addAt0(X0 value0, X1 value1)
    • addAt1

      public <X0, X1> Decade<A,X0,X1,B,C,D,E,F,G,H> addAt1(X0 value0, X1 value1)
    • addAt2

      public <X0, X1> Decade<A,B,X0,X1,C,D,E,F,G,H> addAt2(X0 value0, X1 value1)
    • addAt3

      public <X0, X1> Decade<A,B,C,X0,X1,D,E,F,G,H> addAt3(X0 value0, X1 value1)
    • addAt4

      public <X0, X1> Decade<A,B,C,D,X0,X1,E,F,G,H> addAt4(X0 value0, X1 value1)
    • addAt5

      public <X0, X1> Decade<A,B,C,D,E,X0,X1,F,G,H> addAt5(X0 value0, X1 value1)
    • addAt6

      public <X0, X1> Decade<A,B,C,D,E,F,X0,X1,G,H> addAt6(X0 value0, X1 value1)
    • addAt7

      public <X0, X1> Decade<A,B,C,D,E,F,G,X0,X1,H> addAt7(X0 value0, X1 value1)
    • addAt8

      public <X0, X1> Decade<A,B,C,D,E,F,G,H,X0,X1> addAt8(X0 value0, X1 value1)
    • addAt0

      public <X0> Ennead<X0,A,B,C,D,E,F,G,H> addAt0(Unit<X0> tuple)
    • addAt1

      public <X0> Ennead<A,X0,B,C,D,E,F,G,H> addAt1(Unit<X0> tuple)
    • addAt2

      public <X0> Ennead<A,B,X0,C,D,E,F,G,H> addAt2(Unit<X0> tuple)
    • addAt3

      public <X0> Ennead<A,B,C,X0,D,E,F,G,H> addAt3(Unit<X0> tuple)
    • addAt4

      public <X0> Ennead<A,B,C,D,X0,E,F,G,H> addAt4(Unit<X0> tuple)
    • addAt5

      public <X0> Ennead<A,B,C,D,E,X0,F,G,H> addAt5(Unit<X0> tuple)
    • addAt6

      public <X0> Ennead<A,B,C,D,E,F,X0,G,H> addAt6(Unit<X0> tuple)
    • addAt7

      public <X0> Ennead<A,B,C,D,E,F,G,X0,H> addAt7(Unit<X0> tuple)
    • addAt8

      public <X0> Ennead<A,B,C,D,E,F,G,H,X0> addAt8(Unit<X0> tuple)
    • addAt0

      public <X0, X1> Decade<X0,X1,A,B,C,D,E,F,G,H> addAt0(Pair<X0,X1> tuple)
    • addAt1

      public <X0, X1> Decade<A,X0,X1,B,C,D,E,F,G,H> addAt1(Pair<X0,X1> tuple)
    • addAt2

      public <X0, X1> Decade<A,B,X0,X1,C,D,E,F,G,H> addAt2(Pair<X0,X1> tuple)
    • addAt3

      public <X0, X1> Decade<A,B,C,X0,X1,D,E,F,G,H> addAt3(Pair<X0,X1> tuple)
    • addAt4

      public <X0, X1> Decade<A,B,C,D,X0,X1,E,F,G,H> addAt4(Pair<X0,X1> tuple)
    • addAt5

      public <X0, X1> Decade<A,B,C,D,E,X0,X1,F,G,H> addAt5(Pair<X0,X1> tuple)
    • addAt6

      public <X0, X1> Decade<A,B,C,D,E,F,X0,X1,G,H> addAt6(Pair<X0,X1> tuple)
    • addAt7

      public <X0, X1> Decade<A,B,C,D,E,F,G,X0,X1,H> addAt7(Pair<X0,X1> tuple)
    • addAt8

      public <X0, X1> Decade<A,B,C,D,E,F,G,H,X0,X1> addAt8(Pair<X0,X1> tuple)
    • add

      public <X0> Ennead<A,B,C,D,E,F,G,H,X0> add(X0 value0)
    • add

      public <X0> Ennead<A,B,C,D,E,F,G,H,X0> add(Unit<X0> tuple)
    • add

      public <X0, X1> Decade<A,B,C,D,E,F,G,H,X0,X1> add(X0 value0, X1 value1)
    • add

      public <X0, X1> Decade<A,B,C,D,E,F,G,H,X0,X1> add(Pair<X0,X1> tuple)
    • setAt0

      public <X> Octet<X,B,C,D,E,F,G,H> setAt0(X value)
    • setAt1

      public <X> Octet<A,X,C,D,E,F,G,H> setAt1(X value)
    • setAt2

      public <X> Octet<A,B,X,D,E,F,G,H> setAt2(X value)
    • setAt3

      public <X> Octet<A,B,C,X,E,F,G,H> setAt3(X value)
    • setAt4

      public <X> Octet<A,B,C,D,X,F,G,H> setAt4(X value)
    • setAt5

      public <X> Octet<A,B,C,D,E,X,G,H> setAt5(X value)
    • setAt6

      public <X> Octet<A,B,C,D,E,F,X,H> setAt6(X value)
    • setAt7

      public <X> Octet<A,B,C,D,E,F,G,X> setAt7(X value)
    • removeFrom0

      public Septet<B,C,D,E,F,G,H> removeFrom0()
    • removeFrom1

      public Septet<A,C,D,E,F,G,H> removeFrom1()
    • removeFrom2

      public Septet<A,B,D,E,F,G,H> removeFrom2()
    • removeFrom3

      public Septet<A,B,C,E,F,G,H> removeFrom3()
    • removeFrom4

      public Septet<A,B,C,D,F,G,H> removeFrom4()
    • removeFrom5

      public Septet<A,B,C,D,E,G,H> removeFrom5()
    • removeFrom6

      public Septet<A,B,C,D,E,F,H> removeFrom6()
    • removeFrom7

      public Septet<A,B,C,D,E,F,G> removeFrom7()