Class Septet<A,​B,​C,​D,​E,​F,​G>

    • Field Detail

      • 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
    • Constructor Detail

      • Septet

        public Septet​(A value0,
                      B value1,
                      C value2,
                      D value3,
                      E value4,
                      F value5,
                      G value6)
    • Method Detail

      • with

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

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

        Create tuple from array. Array has to have exactly seven 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> Septet<X,​X,​X,​X,​X,​X,​X> fromCollection​(java.util.Collection<X> collection)

        Create tuple from collection. Collection has to have exactly seven 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> Septet<X,​X,​X,​X,​X,​X,​X> fromIterable​(java.lang.Iterable<X> iterable)

        Create tuple from iterable. Iterable has to have exactly seven 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> Septet<X,​X,​X,​X,​X,​X,​X> fromIterable​(java.lang.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> Septet<X,​X,​X,​X,​X,​X,​X> fromIterable​(java.lang.Iterable<X> iterable,
                                                                                                  int index,
                                                                                                  boolean exactSize)
      • 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> Octet<X0,​A,​B,​C,​D,​E,​F,​G> addAt0​(X0 value0)
      • addAt1

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

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

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

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

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

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

        public <X0> Octet<A,​B,​C,​D,​E,​F,​G,​X0> addAt7​(X0 value0)
      • addAt0

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

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

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

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

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

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

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

        public <X0,​X1> Ennead<A,​B,​C,​D,​E,​F,​G,​X0,​X1> addAt7​(X0 value0,
                                                                                                                X1 value1)
      • addAt0

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

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

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

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

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

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

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

        public <X0,​X1,​X2> Decade<A,​B,​C,​D,​E,​F,​G,​X0,​X1,​X2> addAt7​(X0 value0,
                                                                                                                                  X1 value1,
                                                                                                                                  X2 value2)
      • addAt0

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

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

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

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

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

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

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

        public <X0> Octet<A,​B,​C,​D,​E,​F,​G,​X0> addAt7​(Unit<X0> tuple)
      • addAt0

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

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

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

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

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

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

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

        public <X0,​X1> Ennead<A,​B,​C,​D,​E,​F,​G,​X0,​X1> addAt7​(Pair<X0,​X1> tuple)
      • addAt0

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

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

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

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

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

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

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

        public <X0,​X1,​X2> Decade<A,​B,​C,​D,​E,​F,​G,​X0,​X1,​X2> addAt7​(Triplet<X0,​X1,​X2> tuple)
      • add

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

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

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

        public <X0,​X1> Ennead<A,​B,​C,​D,​E,​F,​G,​X0,​X1> add​(Pair<X0,​X1> tuple)
      • add

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

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

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

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

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

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

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

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

        public <X> Septet<A,​B,​C,​D,​E,​F,​X> setAt6​(X value)
      • removeFrom0

        public Sextet<B,​C,​D,​E,​F,​G> removeFrom0()
      • removeFrom1

        public Sextet<A,​C,​D,​E,​F,​G> removeFrom1()
      • removeFrom2

        public Sextet<A,​B,​D,​E,​F,​G> removeFrom2()
      • removeFrom3

        public Sextet<A,​B,​C,​E,​F,​G> removeFrom3()
      • removeFrom4

        public Sextet<A,​B,​C,​D,​F,​G> removeFrom4()
      • removeFrom5

        public Sextet<A,​B,​C,​D,​E,​G> removeFrom5()
      • removeFrom6

        public Sextet<A,​B,​C,​D,​E,​F> removeFrom6()