Package org.apache.commons.lang3.tuple

Class MutableTriple<L,​M,​R>

  • Type Parameters:
    L - the left element type
    M - the middle element type
    R - the right element type
    All Implemented Interfaces:
    java.io.Serializable, java.lang.Comparable<Triple<L,​M,​R>>
    public class MutableTriple<L,​M,​R>
extends Triple<L,​M,​R>
    A mutable triple consisting of three Object elements.

    Not #ThreadSafe#

    Since:
    3.2
    See Also:
    Serialized Form

    • Constructor Summary

      Constructors 
      Constructor Description
      MutableTriple()
      Create a new triple instance of three nulls.
      MutableTriple​(L left, M middle, R right)
      Create a new triple instance.

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      static <L,​M,​R>
      MutableTriple<L,​M,​R>[]      		 emptyArray()
      Returns the empty array singleton that can be assigned without compiler warning.
      L getLeft()
      Gets the left element from this triple.
      M getMiddle()
      Gets the middle element from this triple.
      R getRight()
      Gets the right element from this triple.
      static <L,​M,​R>
      MutableTriple<L,​M,​R>      		 of​(L left, M middle, R right)
      Obtains a mutable triple of three objects inferring the generic types.
      static <L,​M,​R>
      MutableTriple<L,​M,​R>      		 ofNonNull​(L left, M middle, R right)
      Obtains a mutable triple of three non-null objects inferring the generic types.
      void setLeft​(L left)
      Sets the left element of the triple.
      void setMiddle​(M middle)
      Sets the middle element of the triple.
      void setRight​(R right)
      Sets the right element of the triple.

      • Methods inherited from class java.lang.Object

        getClass, notify, notifyAll, wait, wait, wait

    • Field Detail

      • EMPTY_ARRAY

        public static final MutableTriple<?,​?,​?>[] EMPTY_ARRAY
        The empty array singleton.

        Consider using emptyArray() to avoid generics warnings.

        Since:
        3.10.

      • left

        public L left
        Left object

      • middle

        public M middle
        Middle object

      • right

        public R right
        Right object

    • Constructor Detail

      • MutableTriple

        public MutableTriple()
        Create a new triple instance of three nulls.

      • MutableTriple

        public MutableTriple​(L left,
                     M middle,
                     R right)
        Create a new triple instance.
        Parameters:
        left - the left value, may be null
        middle - the middle value, may be null
        right - the right value, may be null

    • Method Detail

      • emptyArray

        public static <L,​M,​R> MutableTriple<L,​M,​R>[] emptyArray()
        Returns the empty array singleton that can be assigned without compiler warning.
        Type Parameters:
        L - the left element type
        M - the middle element type
        R - the right element type
        Returns:
        the empty array singleton that can be assigned without compiler warning.
        Since:
        3.10.

      • of

        public static <L,​M,​R> MutableTriple<L,​M,​R> of​(L left,
                                                                      M middle,
                                                                      R right)
        Obtains a mutable triple of three objects inferring the generic types.

        This factory allows the triple to be created using inference to obtain the generic types.

        Type Parameters:
        L - the left element type
        M - the middle element type
        R - the right element type
        Parameters:
        left - the left element, may be null
        middle - the middle element, may be null
        right - the right element, may be null
        Returns:
        a triple formed from the three parameters, not null

      • ofNonNull

        public static <L,​M,​R> MutableTriple<L,​M,​R> ofNonNull​(L left,
                                                                             M middle,
                                                                             R right)
        Obtains a mutable triple of three non-null objects inferring the generic types.

        This factory allows the triple to be created using inference to obtain the generic types.

        Type Parameters:
        L - the left element type
        M - the middle element type
        R - the right element type
        Parameters:
        left - the left element, may not be null
        middle - the middle element, may not be null
        right - the right element, may not be null
        Returns:
        a triple formed from the three parameters, not null
        Throws:
        java.lang.NullPointerException - if any input is null
        Since:
        3.13.0

      • getLeft

        public L getLeft()
        Gets the left element from this triple.
        Specified by:
        getLeft in class Triple<L,​M,​R>
        Returns:
        the left element, may be null

      • getMiddle

        public M getMiddle()
        Gets the middle element from this triple.
        Specified by:
        getMiddle in class Triple<L,​M,​R>
        Returns:
        the middle element, may be null

      • getRight

        public R getRight()
        Gets the right element from this triple.
        Specified by:
        getRight in class Triple<L,​M,​R>
        Returns:
        the right element, may be null

      • setLeft

        public void setLeft​(L left)
        Sets the left element of the triple.
        Parameters:
        left - the new value of the left element, may be null

      • setMiddle

        public void setMiddle​(M middle)
        Sets the middle element of the triple.
        Parameters:
        middle - the new value of the middle element, may be null

      • setRight

        public void setRight​(R right)
        Sets the right element of the triple.
        Parameters:
        right - the new value of the right element, may be null