Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

org.javatuples
Class Pair<A,B>

Object
  extended by org.javatuples.Tuple
      extended by org.javatuples.Pair<A,B>
All Implemented Interfaces:
Serializable, Comparable<Tuple>, Iterable<Object>, IValue0<A>, IValue1<B>
public final class Pair<A,B>
extends Tuple
implements IValue0<A>, IValue1<B>

A tuple of two elements.

Since:
1.0
Author:
Daniel Fernández
See Also:
Serialized Form

Constructor Summary
Pair(A value0, B value1)
           
 
Method Summary
<X0,X1,X2,X3,X4,X5,X6,X7>
Decade<A,B,X0,X1,X2,X3,X4,X5,X6,X7>
add(Octet<X0,X1,X2,X3,X4,X5,X6,X7> tuple)
           
<X0,X1> Quartet<A,B,X0,X1>
add(Pair<X0,X1> tuple)
           
<X0,X1,X2,X3>
Sextet<A,B,X0,X1,X2,X3>
add(Quartet<X0,X1,X2,X3> tuple)
           
<X0,X1,X2,X3,X4>
Septet<A,B,X0,X1,X2,X3,X4>
add(Quintet<X0,X1,X2,X3,X4> tuple)
           
<X0,X1,X2,X3,X4,X5,X6>
Ennead<A,B,X0,X1,X2,X3,X4,X5,X6>
add(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)
           
<X0,X1,X2,X3,X4,X5>
Octet<A,B,X0,X1,X2,X3,X4,X5>
add(Sextet<X0,X1,X2,X3,X4,X5> tuple)
           
<X0,X1,X2> Quintet<A,B,X0,X1,X2>
add(Triplet<X0,X1,X2> tuple)
           
<X0> Triplet<A,B,X0>
add(Unit<X0> tuple)
           
<X0> Triplet<A,B,X0>
add(X0 value0)
           
<X0,X1> Quartet<A,B,X0,X1>
add(X0 value0, X1 value1)
           
<X0,X1,X2> Quintet<A,B,X0,X1,X2>
add(X0 value0, X1 value1, X2 value2)
           
<X0,X1,X2,X3>
Sextet<A,B,X0,X1,X2,X3>
add(X0 value0, X1 value1, X2 value2, X3 value3)
           
<X0,X1,X2,X3,X4>
Septet<A,B,X0,X1,X2,X3,X4>
add(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)
           
<X0,X1,X2,X3,X4,X5>
Octet<A,B,X0,X1,X2,X3,X4,X5>
add(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)
           
<X0,X1,X2,X3,X4,X5,X6>
Ennead<A,B,X0,X1,X2,X3,X4,X5,X6>
add(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)
           
<X0,X1,X2,X3,X4,X5,X6,X7>
Decade<A,B,X0,X1,X2,X3,X4,X5,X6,X7>
add(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6, X7 value7)
           
<X0,X1,X2,X3,X4,X5,X6,X7>
Decade<X0,X1,X2,X3,X4,X5,X6,X7,A,B>
addAt0(Octet<X0,X1,X2,X3,X4,X5,X6,X7> tuple)
           
<X0,X1> Quartet<X0,X1,A,B>
addAt0(Pair<X0,X1> tuple)
           
<X0,X1,X2,X3>
Sextet<X0,X1,X2,X3,A,B>
addAt0(Quartet<X0,X1,X2,X3> tuple)
           
<X0,X1,X2,X3,X4>
Septet<X0,X1,X2,X3,X4,A,B>
addAt0(Quintet<X0,X1,X2,X3,X4> tuple)
           
<X0,X1,X2,X3,X4,X5,X6>
Ennead<X0,X1,X2,X3,X4,X5,X6,A,B>
addAt0(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)
           
<X0,X1,X2,X3,X4,X5>
Octet<X0,X1,X2,X3,X4,X5,A,B>
addAt0(Sextet<X0,X1,X2,X3,X4,X5> tuple)
           
<X0,X1,X2> Quintet<X0,X1,X2,A,B>
addAt0(Triplet<X0,X1,X2> tuple)
           
<X0> Triplet<X0,A,B>
addAt0(Unit<X0> tuple)
           
<X0> Triplet<X0,A,B>
addAt0(X0 value0)
           
<X0,X1> Quartet<X0,X1,A,B>
addAt0(X0 value0, X1 value1)
           
<X0,X1,X2> Quintet<X0,X1,X2,A,B>
addAt0(X0 value0, X1 value1, X2 value2)
           
<X0,X1,X2,X3>
Sextet<X0,X1,X2,X3,A,B>
addAt0(X0 value0, X1 value1, X2 value2, X3 value3)
           
<X0,X1,X2,X3,X4>
Septet<X0,X1,X2,X3,X4,A,B>
addAt0(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)
           
<X0,X1,X2,X3,X4,X5>
Octet<X0,X1,X2,X3,X4,X5,A,B>
addAt0(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)
           
<X0,X1,X2,X3,X4,X5,X6>
Ennead<X0,X1,X2,X3,X4,X5,X6,A,B>
addAt0(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)
           
<X0,X1,X2,X3,X4,X5,X6,X7>
Decade<X0,X1,X2,X3,X4,X5,X6,X7,A,B>
addAt0(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6, X7 value7)
           
<X0,X1,X2,X3,X4,X5,X6,X7>
Decade<A,X0,X1,X2,X3,X4,X5,X6,X7,B>
addAt1(Octet<X0,X1,X2,X3,X4,X5,X6,X7> tuple)
           
<X0,X1> Quartet<A,X0,X1,B>
addAt1(Pair<X0,X1> tuple)
           
<X0,X1,X2,X3>
Sextet<A,X0,X1,X2,X3,B>
addAt1(Quartet<X0,X1,X2,X3> tuple)
           
<X0,X1,X2,X3,X4>
Septet<A,X0,X1,X2,X3,X4,B>
addAt1(Quintet<X0,X1,X2,X3,X4> tuple)
           
<X0,X1,X2,X3,X4,X5,X6>
Ennead<A,X0,X1,X2,X3,X4,X5,X6,B>
addAt1(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)
           
<X0,X1,X2,X3,X4,X5>
Octet<A,X0,X1,X2,X3,X4,X5,B>
addAt1(Sextet<X0,X1,X2,X3,X4,X5> tuple)
           
<X0,X1,X2> Quintet<A,X0,X1,X2,B>
addAt1(Triplet<X0,X1,X2> tuple)
           
<X0> Triplet<A,X0,B>
addAt1(Unit<X0> tuple)
           
<X0> Triplet<A,X0,B>
addAt1(X0 value0)
           
<X0,X1> Quartet<A,X0,X1,B>
addAt1(X0 value0, X1 value1)
           
<X0,X1,X2> Quintet<A,X0,X1,X2,B>
addAt1(X0 value0, X1 value1, X2 value2)
           
<X0,X1,X2,X3>
Sextet<A,X0,X1,X2,X3,B>
addAt1(X0 value0, X1 value1, X2 value2, X3 value3)
           
<X0,X1,X2,X3,X4>
Septet<A,X0,X1,X2,X3,X4,B>
addAt1(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)
           
<X0,X1,X2,X3,X4,X5>
Octet<A,X0,X1,X2,X3,X4,X5,B>
addAt1(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)
           
<X0,X1,X2,X3,X4,X5,X6>
Ennead<A,X0,X1,X2,X3,X4,X5,X6,B>
addAt1(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)
           
<X0,X1,X2,X3,X4,X5,X6,X7>
Decade<A,X0,X1,X2,X3,X4,X5,X6,X7,B>
addAt1(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6, X7 value7)
           
<X0,X1,X2,X3,X4,X5,X6,X7>
Decade<A,B,X0,X1,X2,X3,X4,X5,X6,X7>
addAt2(Octet<X0,X1,X2,X3,X4,X5,X6,X7> tuple)
           
<X0,X1> Quartet<A,B,X0,X1>
addAt2(Pair<X0,X1> tuple)
           
<X0,X1,X2,X3>
Sextet<A,B,X0,X1,X2,X3>
addAt2(Quartet<X0,X1,X2,X3> tuple)
           
<X0,X1,X2,X3,X4>
Septet<A,B,X0,X1,X2,X3,X4>
addAt2(Quintet<X0,X1,X2,X3,X4> tuple)
           
<X0,X1,X2,X3,X4,X5,X6>
Ennead<A,B,X0,X1,X2,X3,X4,X5,X6>
addAt2(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)
           
<X0,X1,X2,X3,X4,X5>
Octet<A,B,X0,X1,X2,X3,X4,X5>
addAt2(Sextet<X0,X1,X2,X3,X4,X5> tuple)
           
<X0,X1,X2> Quintet<A,B,X0,X1,X2>
addAt2(Triplet<X0,X1,X2> tuple)
           
<X0> Triplet<A,B,X0>
addAt2(Unit<X0> tuple)
           
<X0> Triplet<A,B,X0>
addAt2(X0 value0)
           
<X0,X1> Quartet<A,B,X0,X1>
addAt2(X0 value0, X1 value1)
           
<X0,X1,X2> Quintet<A,B,X0,X1,X2>
addAt2(X0 value0, X1 value1, X2 value2)
           
<X0,X1,X2,X3>
Sextet<A,B,X0,X1,X2,X3>
addAt2(X0 value0, X1 value1, X2 value2, X3 value3)
           
<X0,X1,X2,X3,X4>
Septet<A,B,X0,X1,X2,X3,X4>
addAt2(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)
           
<X0,X1,X2,X3,X4,X5>
Octet<A,B,X0,X1,X2,X3,X4,X5>
addAt2(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)
           
<X0,X1,X2,X3,X4,X5,X6>
Ennead<A,B,X0,X1,X2,X3,X4,X5,X6>
addAt2(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)
           
<X0,X1,X2,X3,X4,X5,X6,X7>
Decade<A,B,X0,X1,X2,X3,X4,X5,X6,X7>
addAt2(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6, X7 value7)
           
static
<X> Pair<X,X>
fromArray(X[] array)
           Create tuple from array.
static
<X> Pair<X,X>
fromCollection(Collection<X> collection)
           Create tuple from collection.
static
<X> Pair<X,X>
fromIterable(Iterable<X> iterable)
           Create tuple from iterable.
static
<X> Pair<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()
           
 Unit<B> removeFrom0()
           
 Unit<A> removeFrom1()
           
<X> Pair<X,B>
setAt0(X value)
           
<X> Pair<A,X>
setAt1(X value)
           
static
<A,B> Pair<A,B>
with(A value0, B value1)
           
 
Methods inherited from class org.javatuples.Tuple
compareTo, contains, containsAll, containsAll, equals, getValue, hashCode, indexOf, iterator, lastIndexOf, toArray, toList, toString
 
Methods inherited from class Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
 

Constructor Detail

Pair

public Pair(A value0,
            B value1)
Method Detail

with

public static <A,B> Pair<A,B> with(A value0,
                                   B value1)

fromArray

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

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

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

Create tuple from iterable. Iterable has to have exactly two 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> Pair<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>

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> Triplet<X0,A,B> addAt0(X0 value0)

addAt1

public <X0> Triplet<A,X0,B> addAt1(X0 value0)

addAt2

public <X0> Triplet<A,B,X0> addAt2(X0 value0)

addAt0

public <X0,X1> Quartet<X0,X1,A,B> addAt0(X0 value0,
                                         X1 value1)

addAt1

public <X0,X1> Quartet<A,X0,X1,B> addAt1(X0 value0,
                                         X1 value1)

addAt2

public <X0,X1> Quartet<A,B,X0,X1> addAt2(X0 value0,
                                         X1 value1)

addAt0

public <X0,X1,X2> Quintet<X0,X1,X2,A,B> addAt0(X0 value0,
                                               X1 value1,
                                               X2 value2)

addAt1

public <X0,X1,X2> Quintet<A,X0,X1,X2,B> addAt1(X0 value0,
                                               X1 value1,
                                               X2 value2)

addAt2

public <X0,X1,X2> Quintet<A,B,X0,X1,X2> addAt2(X0 value0,
                                               X1 value1,
                                               X2 value2)

addAt0

public <X0,X1,X2,X3> Sextet<X0,X1,X2,X3,A,B> addAt0(X0 value0,
                                                    X1 value1,
                                                    X2 value2,
                                                    X3 value3)

addAt1

public <X0,X1,X2,X3> Sextet<A,X0,X1,X2,X3,B> addAt1(X0 value0,
                                                    X1 value1,
                                                    X2 value2,
                                                    X3 value3)

addAt2

public <X0,X1,X2,X3> Sextet<A,B,X0,X1,X2,X3> addAt2(X0 value0,
                                                    X1 value1,
                                                    X2 value2,
                                                    X3 value3)

addAt0

public <X0,X1,X2,X3,X4> Septet<X0,X1,X2,X3,X4,A,B> addAt0(X0 value0,
                                                          X1 value1,
                                                          X2 value2,
                                                          X3 value3,
                                                          X4 value4)

addAt1

public <X0,X1,X2,X3,X4> Septet<A,X0,X1,X2,X3,X4,B> addAt1(X0 value0,
                                                          X1 value1,
                                                          X2 value2,
                                                          X3 value3,
                                                          X4 value4)

addAt2

public <X0,X1,X2,X3,X4> Septet<A,B,X0,X1,X2,X3,X4> addAt2(X0 value0,
                                                          X1 value1,
                                                          X2 value2,
                                                          X3 value3,
                                                          X4 value4)

addAt0

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

addAt1

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

addAt2

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

addAt0

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

addAt1

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

addAt2

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

addAt0

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

addAt1

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

addAt2

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

addAt0

public <X0> Triplet<X0,A,B> addAt0(Unit<X0> tuple)

addAt1

public <X0> Triplet<A,X0,B> addAt1(Unit<X0> tuple)

addAt2

public <X0> Triplet<A,B,X0> addAt2(Unit<X0> tuple)

addAt0

public <X0,X1> Quartet<X0,X1,A,B> addAt0(Pair<X0,X1> tuple)

addAt1

public <X0,X1> Quartet<A,X0,X1,B> addAt1(Pair<X0,X1> tuple)

addAt2

public <X0,X1> Quartet<A,B,X0,X1> addAt2(Pair<X0,X1> tuple)

addAt0

public <X0,X1,X2> Quintet<X0,X1,X2,A,B> addAt0(Triplet<X0,X1,X2> tuple)

addAt1

public <X0,X1,X2> Quintet<A,X0,X1,X2,B> addAt1(Triplet<X0,X1,X2> tuple)

addAt2

public <X0,X1,X2> Quintet<A,B,X0,X1,X2> addAt2(Triplet<X0,X1,X2> tuple)

addAt0

public <X0,X1,X2,X3> Sextet<X0,X1,X2,X3,A,B> addAt0(Quartet<X0,X1,X2,X3> tuple)

addAt1

public <X0,X1,X2,X3> Sextet<A,X0,X1,X2,X3,B> addAt1(Quartet<X0,X1,X2,X3> tuple)

addAt2

public <X0,X1,X2,X3> Sextet<A,B,X0,X1,X2,X3> addAt2(Quartet<X0,X1,X2,X3> tuple)

addAt0

public <X0,X1,X2,X3,X4> Septet<X0,X1,X2,X3,X4,A,B> addAt0(Quintet<X0,X1,X2,X3,X4> tuple)

addAt1

public <X0,X1,X2,X3,X4> Septet<A,X0,X1,X2,X3,X4,B> addAt1(Quintet<X0,X1,X2,X3,X4> tuple)

addAt2

public <X0,X1,X2,X3,X4> Septet<A,B,X0,X1,X2,X3,X4> addAt2(Quintet<X0,X1,X2,X3,X4> tuple)

addAt0

public <X0,X1,X2,X3,X4,X5> Octet<X0,X1,X2,X3,X4,X5,A,B> addAt0(Sextet<X0,X1,X2,X3,X4,X5> tuple)

addAt1

public <X0,X1,X2,X3,X4,X5> Octet<A,X0,X1,X2,X3,X4,X5,B> addAt1(Sextet<X0,X1,X2,X3,X4,X5> tuple)

addAt2

public <X0,X1,X2,X3,X4,X5> Octet<A,B,X0,X1,X2,X3,X4,X5> addAt2(Sextet<X0,X1,X2,X3,X4,X5> tuple)

addAt0

public <X0,X1,X2,X3,X4,X5,X6> Ennead<X0,X1,X2,X3,X4,X5,X6,A,B> addAt0(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)

addAt1

public <X0,X1,X2,X3,X4,X5,X6> Ennead<A,X0,X1,X2,X3,X4,X5,X6,B> addAt1(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)

addAt2

public <X0,X1,X2,X3,X4,X5,X6> Ennead<A,B,X0,X1,X2,X3,X4,X5,X6> addAt2(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)

addAt0

public <X0,X1,X2,X3,X4,X5,X6,X7> Decade<X0,X1,X2,X3,X4,X5,X6,X7,A,B> addAt0(Octet<X0,X1,X2,X3,X4,X5,X6,X7> tuple)

addAt1

public <X0,X1,X2,X3,X4,X5,X6,X7> Decade<A,X0,X1,X2,X3,X4,X5,X6,X7,B> addAt1(Octet<X0,X1,X2,X3,X4,X5,X6,X7> tuple)

addAt2

public <X0,X1,X2,X3,X4,X5,X6,X7> Decade<A,B,X0,X1,X2,X3,X4,X5,X6,X7> addAt2(Octet<X0,X1,X2,X3,X4,X5,X6,X7> tuple)

add

public <X0> Triplet<A,B,X0> add(X0 value0)

add

public <X0> Triplet<A,B,X0> add(Unit<X0> tuple)

add

public <X0,X1> Quartet<A,B,X0,X1> add(X0 value0,
                                      X1 value1)

add

public <X0,X1> Quartet<A,B,X0,X1> add(Pair<X0,X1> tuple)

add

public <X0,X1,X2> Quintet<A,B,X0,X1,X2> add(X0 value0,
                                            X1 value1,
                                            X2 value2)

add

public <X0,X1,X2> Quintet<A,B,X0,X1,X2> add(Triplet<X0,X1,X2> tuple)

add

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

add

public <X0,X1,X2,X3> Sextet<A,B,X0,X1,X2,X3> add(Quartet<X0,X1,X2,X3> tuple)

add

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

add

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

add

public <X0,X1,X2,X3,X4,X5> Octet<A,B,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> Octet<A,B,X0,X1,X2,X3,X4,X5> add(Sextet<X0,X1,X2,X3,X4,X5> tuple)

add

public <X0,X1,X2,X3,X4,X5,X6> Ennead<A,B,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> Ennead<A,B,X0,X1,X2,X3,X4,X5,X6> add(Septet<X0,X1,X2,X3,X4,X5,X6> tuple)

add

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

add

public <X0,X1,X2,X3,X4,X5,X6,X7> Decade<A,B,X0,X1,X2,X3,X4,X5,X6,X7> add(Octet<X0,X1,X2,X3,X4,X5,X6,X7> tuple)

setAt0

public <X> Pair<X,B> setAt0(X value)

setAt1

public <X> Pair<A,X> setAt1(X value)

removeFrom0

public Unit<B> removeFrom0()

removeFrom1

public Unit<A> removeFrom1()
Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD
Copyright © 2012 The JAVATUPLES team. All Rights Reserved.