Class Tuple3<A,​B,​C>

  • Type Parameters:
    A - The type of the first member-field ('a').
    B - The type of the second member-field ('b').
    C - The type of the third member-field ('c').
    All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable
    public class Tuple3<A,​B,​C>
extends TupleN
implements java.io.Serializable, java.lang.Cloneable
    This simple generic-class allows for storing three objects with a single reference.

    Modifiable, Read-Write: Classes which inherit Ancestor-Class TupleN will always contains fields which have been declared without the use of the 'final' modifier. These classes are, therefore, "Mutable Tuples" - meaning their contents may be changed whenever necessary.

    Remember: The classes Ret3 and Tuple3 completely identical, with the sole difference being that Ret3 fields are all declared 'final', but the Tuple3 fields are not!
    See Also:
    Serialized Form


    • Field Summary

       
      Serializable ID
      Modifier and Type Field
      protected static long serialVersionUID
       
      Instance Fields
      Modifier and Type Field
      A a
      B b
      C c

    • Constructor Summary

      Constructors 
      Constructor
      Tuple3()
      Tuple3​(A a, B b, C c)

    • Method Summary

       
      Retrieve the Number of Fields in this Class
      Modifier and Type Method
      int n()
       
      Retrieve a Field by Field-Number
      Modifier and Type Method
      Object get​(int i)
       
      Convert this instance to an Immutable RetN instance, of the same size
      Modifier and Type Method
      Ret3<A,​B,​C> toImmutable()
       
      Methods: interface java.lang.Cloneable
      Modifier and Type Method
      Tuple3<A,​B,​C> clone()

      • Methods inherited from class java.lang.Object

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

    • Method Detail

      • get

        🡅  ðŸ¡‡  â‡ˆ  â®« 🗕  ðŸ——  ðŸ—– 
        public java.lang.Object get​(int i)
        This method will retreive the ith field of this instance. This can be useful when you wish to use the Ancestor / Parent classses: TupleN or MultiType for handling 'this' instance.

        As a reminder, the fields inside this class have all been declared public! Referencing this instance' fields, directly, will always work in place of calling any of the get(...) methods.

        Type Casting:
        This method can make for easier typing. When using either of the super-classes of this class - namely TupleN or MultiType - you simply do not have to type (into your computer's keyboard) all of the Field Generic Types (the stuff between the '<' and '>' less-than & greater-than symbols).

        However, anytime one of these ancestor classes are used instead of the actual Tuple3 instance, you will have to use one of the provided 'get' methods to retrieve a field inside the Tuple3 instance. This is because the parent-ancestor classes do not actually have any fields to retrieve.

        There are three 'get' methods provided in Root-Ancestor Class MultiType. Each of these three 'getters' allows for casting (this) sub-class' returned fields in a slightly different way. When you aren't referencing the actual instance, itself, but rather one of the two Parent-Tuple Classes, you must use one of their getters, and you will have to cast the fields that you wish to use, eventually!

        Example:
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
// No Cast Necessary
// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

// This line makes for longer typing, but DOES NOT REQUIRE A CAST TO RETRIEVE FIELDS.
// Here the example Multi-Type Identifier is used: Tuple3.

Tuple3<String, Integer, Date> ref3 = some_function_returns_3();
String neededStrField = ref3.a;


// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
// Less Keyboard-Typing (Less Eyesores), but Requires a Cast
// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

// If the Tuple3 super-class TupleN is used to reference this class data,
// YOU WILL NEED TO CAST THE FIELDS BEFORE YOU CAN THEM, AS IN THE EXAMPLES BELOW:

TupleN refN = some_function_returns3();

// Version #1: (this method) - simple 'get'
@SuppressWarnings("unchecked")
String neededStrField = (String) refN.get(1);

// Version #1: The second Method-Parameter is a 'Class<T>' Type-Parameter
// Note, again, that passing a '1' to the first parameter retrieves Tuple3.a

String neededStrField = refN.get(1, String.class);

// Version #3: "GET" (in all caps) utilizes Java "Type-Inferencing" - the Return-Type
// is specified by the left side of the assignments statement.

String needesStrField = refN.GET(1);
        Specified by:
        get in class MultiType
        Parameters:
        i - This specifies which field of the instance is being requested.

        Important: Unlike a Java array, when a '1' is passed to this parameter, it is requesting the first field in this instance. Passing a value of '0' shall cause an IndexOutOfBoundsException throw.
        Returns:
        This returns the ith field of this class.
        See Also:
        MultiType.get(int, Class), MultiType.GET(int)
        Code:
        Exact Method Body:
         // Throws Exception if i not in [1..3]
 CHECK_GET(i);

 return (i <= 2)
     ? ((i == 1) ? a : b)
     : c;

      • toImmutable

        🡅  â‡ˆ  â®« 🗕  ðŸ——  ðŸ—– 
        public Ret3<A,​B,​C> toImmutable()
        Description copied from class: TupleN
        Converts 'this' Modifiable TupleN instance into a Read-Only RetN.
        Specified by:
        toImmutable in class TupleN
        Returns:
        A RetN of the same size, which is an immutable type whose fields have been decorated with the 'final' modifier - and therefore cannot be changed once the instance has been constructed.
        Code:
        Exact Method Body:
         return new Ret3<>(this.a, this.b, this.c);