org.nlpcn.commons.lang.util.tuples

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

java.lang.Object

org.nlpcn.commons.lang.util.tuples.Tuple

org.nlpcn.commons.lang.util.tuples.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

Author:

Daniel Fernández

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
Octet(A value0, B value1, C value2, D value3, E value4, F value5, G value6, H value7)

Method Summary

Modifier and Type	Method and Description
<X0,X1> Decade<A,B,C,D,E,F,G,H,X0,X1>	add(Pair<X0,X1> tuple)
<X0> Ennead<A,B,C,D,E,F,G,H,X0>	add(Unit<X0> tuple)
<X0> Ennead<A,B,C,D,E,F,G,H,X0>	add(X0 value0)
<X0,X1> Decade<A,B,C,D,E,F,G,H,X0,X1>	add(X0 value0, X1 value1)
<X0,X1> Decade<X0,X1,A,B,C,D,E,F,G,H>	addAt0(Pair<X0,X1> tuple)
<X0> Ennead<X0,A,B,C,D,E,F,G,H>	addAt0(Unit<X0> tuple)
<X0> Ennead<X0,A,B,C,D,E,F,G,H>	addAt0(X0 value0)
<X0,X1> Decade<X0,X1,A,B,C,D,E,F,G,H>	addAt0(X0 value0, X1 value1)
<X0,X1> Decade<A,X0,X1,B,C,D,E,F,G,H>	addAt1(Pair<X0,X1> tuple)
<X0> Ennead<A,X0,B,C,D,E,F,G,H>	addAt1(Unit<X0> tuple)
<X0> Ennead<A,X0,B,C,D,E,F,G,H>	addAt1(X0 value0)
<X0,X1> Decade<A,X0,X1,B,C,D,E,F,G,H>	addAt1(X0 value0, X1 value1)
<X0,X1> Decade<A,B,X0,X1,C,D,E,F,G,H>	addAt2(Pair<X0,X1> tuple)
<X0> Ennead<A,B,X0,C,D,E,F,G,H>	addAt2(Unit<X0> tuple)
<X0> Ennead<A,B,X0,C,D,E,F,G,H>	addAt2(X0 value0)
<X0,X1> Decade<A,B,X0,X1,C,D,E,F,G,H>	addAt2(X0 value0, X1 value1)
<X0,X1> Decade<A,B,C,X0,X1,D,E,F,G,H>	addAt3(Pair<X0,X1> tuple)
<X0> Ennead<A,B,C,X0,D,E,F,G,H>	addAt3(Unit<X0> tuple)
<X0> Ennead<A,B,C,X0,D,E,F,G,H>	addAt3(X0 value0)
<X0,X1> Decade<A,B,C,X0,X1,D,E,F,G,H>	addAt3(X0 value0, X1 value1)
<X0,X1> Decade<A,B,C,D,X0,X1,E,F,G,H>	addAt4(Pair<X0,X1> tuple)
<X0> Ennead<A,B,C,D,X0,E,F,G,H>	addAt4(Unit<X0> tuple)
<X0> Ennead<A,B,C,D,X0,E,F,G,H>	addAt4(X0 value0)
<X0,X1> Decade<A,B,C,D,X0,X1,E,F,G,H>	addAt4(X0 value0, X1 value1)
<X0,X1> Decade<A,B,C,D,E,X0,X1,F,G,H>	addAt5(Pair<X0,X1> tuple)
<X0> Ennead<A,B,C,D,E,X0,F,G,H>	addAt5(Unit<X0> tuple)
<X0> Ennead<A,B,C,D,E,X0,F,G,H>	addAt5(X0 value0)
<X0,X1> Decade<A,B,C,D,E,X0,X1,F,G,H>	addAt5(X0 value0, X1 value1)
<X0,X1> Decade<A,B,C,D,E,F,X0,X1,G,H>	addAt6(Pair<X0,X1> tuple)
<X0> Ennead<A,B,C,D,E,F,X0,G,H>	addAt6(Unit<X0> tuple)
<X0> Ennead<A,B,C,D,E,F,X0,G,H>	addAt6(X0 value0)
<X0,X1> Decade<A,B,C,D,E,F,X0,X1,G,H>	addAt6(X0 value0, X1 value1)
<X0,X1> Decade<A,B,C,D,E,F,G,X0,X1,H>	addAt7(Pair<X0,X1> tuple)
<X0> Ennead<A,B,C,D,E,F,G,X0,H>	addAt7(Unit<X0> tuple)
<X0> Ennead<A,B,C,D,E,F,G,X0,H>	addAt7(X0 value0)
<X0,X1> Decade<A,B,C,D,E,F,G,X0,X1,H>	addAt7(X0 value0, X1 value1)
<X0,X1> Decade<A,B,C,D,E,F,G,H,X0,X1>	addAt8(Pair<X0,X1> tuple)
<X0> Ennead<A,B,C,D,E,F,G,H,X0>	addAt8(Unit<X0> tuple)
<X0> Ennead<A,B,C,D,E,F,G,H,X0>	addAt8(X0 value0)
<X0,X1> Decade<A,B,C,D,E,F,G,H,X0,X1>	addAt8(X0 value0, X1 value1)
static <X> Octet<X,X,X,X,X,X,X,X>	fromArray(X[] array) Create tuple from array.
static <X> Octet<X,X,X,X,X,X,X,X>	fromCollection(Collection<X> collection) Create tuple from collection.
static <X> Octet<X,X,X,X,X,X,X,X>	fromIterable(Iterable<X> iterable) Create tuple from iterable.
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.
int	getSize() Return the size of the tuple.
A	getValue0()
B	getValue1()
C	getValue2()
D	getValue3()
E	getValue4()
F	getValue5()
G	getValue6()
H	getValue7()
Septet<B,C,D,E,F,G,H>	removeFrom0()
Septet<A,C,D,E,F,G,H>	removeFrom1()
Septet<A,B,D,E,F,G,H>	removeFrom2()
Septet<A,B,C,E,F,G,H>	removeFrom3()
Septet<A,B,C,D,F,G,H>	removeFrom4()
Septet<A,B,C,D,E,G,H>	removeFrom5()
Septet<A,B,C,D,E,F,H>	removeFrom6()
Septet<A,B,C,D,E,F,G>	removeFrom7()
<X> Octet<X,B,C,D,E,F,G,H>	setAt0(X value)
<X> Octet<A,X,C,D,E,F,G,H>	setAt1(X value)
<X> Octet<A,B,X,D,E,F,G,H>	setAt2(X value)
<X> Octet<A,B,C,X,E,F,G,H>	setAt3(X value)
<X> Octet<A,B,C,D,X,F,G,H>	setAt4(X value)
<X> Octet<A,B,C,D,E,X,G,H>	setAt5(X value)
<X> Octet<A,B,C,D,E,F,X,H>	setAt6(X value)
<X> Octet<A,B,C,D,E,F,G,X>	setAt7(X value)
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)

Methods inherited from class org.nlpcn.commons.lang.util.tuples.Tuple

compareTo, contains, containsAll, containsAll, equals, getValue, hashCode, indexOf, iterator, lastIndexOf, toArray, toList, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Constructor Detail

Octet

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

Method Detail

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

getValue0

public A getValue0()

Specified by:

getValue0 in interface IValue0<A>

getValue1

public B getValue1()

Specified by:

getValue1 in interface IValue1<B>

getValue2

public C getValue2()

Specified by:

getValue2 in interface IValue2<C>

getValue3

public D getValue3()

Specified by:

getValue3 in interface IValue3<D>

getValue4

public E getValue4()

Specified by:

getValue4 in interface IValue4<E>

getValue5

public F getValue5()

Specified by:

getValue5 in interface IValue5<F>

getValue6

public G getValue6()

Specified by:

getValue6 in interface IValue6<G>

getValue7

public H getValue7()

Specified by:

getValue7 in interface IValue7<H>

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()