org.nerd4j.utils.tuple

Class ComparableTriple<L,M,R>

java.lang.Object

org.nerd4j.utils.tuple.Triple<L,M,R>

org.nerd4j.utils.tuple.ComparableTriple<L,M,R>

Type Parameters:

L - type of the left element.

M - type of the middle element.

R - type of the right element.

All Implemented Interfaces:

Serializable, Comparable<ComparableTriple<L,M,R>>, Comparative<ComparableTriple<L,M,R>>, Emptily

public class ComparableTriple<L,M,R>
extends Triple<L,M,R>
implements Comparative<ComparableTriple<L,M,R>>

Represents an immutable and comparable triple of values.

The values of the triple can be mutable but the relation, created by this class, among three instances cannot change.

The values of the triple are addressed as: left, middle and right.

This class implements Comparable so either the values are Comparable or a suitable Comparator should be provided.

This class implements Emptily. A triple is considered to be empty if both of its values are null.

There are several factory methods that cover all the most common use cases but, if you need to se up a custom combination of comparable and non comparable values, you can use the ComparableTriple.MiddleBuilder amd ComparableTriple.FinalBuilder.

Since:

2.0.0

Author:

Massimo Coluzzi

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ComparableTriple.FinalBuilder<L,M> Implementation of the pattern builder intended to be used to create ComparableTriples with custom combination of comparable and non comparable values.
static class	ComparableTriple.MiddleBuilder<L> Implementation of the pattern builder intended to be used to create ComparableTriples with custom combination of comparable and non comparable values.

Field Summary

Fields inherited from class org.nerd4j.utils.tuple.Triple

left, middle, right

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	ComparableTriple(L left, Comparator<L> leftComparator, M middle, Comparator<M> middleComparator, R right, Comparator<R> rightComparator) Constructor with parameters.

Method Summary

Modifier and Type	Method and Description
int	compareTo(ComparableTriple<L,M,R> other)
static <L,M,R> ComparableTriple<L,M,R>	empty() Returns the singleton instance of an empty ComparableTriple.
Comparator<L>	getLeftComparator() Returns the comparator for values of type <L>.
Comparator<M>	getMiddleComparator() Returns the comparator for values of type <M>.
Comparator<R>	getRightComparator() Returns the comparator for values of type <R>.
static <L extends Comparable<L>,M extends Comparable<M>,R extends Comparable<R>> ComparableTriple<L,M,R>	of(L left, boolean leftNullLast, M middle, boolean middleNullLast, R right, boolean rightNullLast) Creates a new ComparableTriple with the given values.
static <L,M,R> ComparableTriple<L,M,R>	of(L left, Comparator<L> leftComparator, M middle, Comparator<M> middleComparator, R right, Comparator<R> rightComparator) Creates a new ComparableTriple with the given values.
static <L extends Comparable<L>,M extends Comparable<M>,R extends Comparable<R>> ComparableTriple<L,M,R>	of(L left, M middle, R right) Creates a new ComparableTriple with the given Comparable values.
static <L extends Comparable<L>,M extends Comparable<M>,R extends Comparable<R>> ComparableTriple<L,M,R>	of(Triple<L,M,R> triple) Creates a new ComparableTriple with the given Comparable values.
static <L extends Comparable<L>,M extends Comparable<M>,R extends Comparable<R>> ComparableTriple<L,M,R>	of(Triple<L,M,R> triple, boolean leftNullLast, boolean middleNullLast, boolean rightNullLast) Creates a new ComparableTriple starting from the given Triple of Comparable values and applies the given behavior for null values.
static <L,M,R> ComparableTriple<L,M,R>	of(Triple<L,M,R> triple, Comparator<L> leftComparator, Comparator<M> middleComparator, Comparator<R> rightComparator) Creates a new ComparableTriple starting from the given Triple of Comparable values and applies the given value comparators.
static <L extends Comparable<L>> ComparableTriple.MiddleBuilder<L>	withLeft(L value) Creates a new ComparableTriple.MiddleBuilder with the given left value.
static <L extends Comparable<L>> ComparableTriple.MiddleBuilder<L>	withLeft(L value, boolean nullLast) Creates a new ComparableTriple.MiddleBuilder with the given left values.
static <L> ComparableTriple.MiddleBuilder<L>	withLeft(L value, Comparator<L> comparator) Creates a new ComparableTriple.MiddleBuilder with the given left values.

Methods inherited from class org.nerd4j.utils.tuple.Triple

equals, getLeft, getMiddle, getRight, hashCode, isEmpty, toString

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.nerd4j.utils.lang.Comparative

eq, ge, gt, le, lt, ne

Constructor Detail

ComparableTriple

protected ComparableTriple(L left,
                           Comparator<L> leftComparator,
                           M middle,
                           Comparator<M> middleComparator,
                           R right,
                           Comparator<R> rightComparator)

Constructor with parameters.

This constructor is intended to be used by extending classes only.

To create a new triple use the factory methods.

Parameters:

left - the left element of the triple.

leftComparator - the Comparator for the left element.

middle - the middle element of the triple.

middleComparator - the Comparator for the middle element.

right - the right element of the triple.

rightComparator - the Comparator for the right element.

Method Detail

empty

public static <L,M,R> ComparableTriple<L,M,R> empty()

Returns the singleton instance of an empty ComparableTriple.

Type Parameters:

L - type of the element left.

M - type of the element middle.

R - type of the element right.

Returns:

singleton instance of an empty ComparableTriple.

of

public static <L extends Comparable<L>,M extends Comparable<M>,R extends Comparable<R>> ComparableTriple<L,M,R> of(L left,
                                                                                                                   M middle,
                                                                                                                   R right)

Creates a new ComparableTriple with the given Comparable values.

This implementation considers null to be less than non-null. Using this method is the same as invoking ComparableTriple.of(left,false,middle,false,right,false).

Type Parameters:

L - type of the left element.

M - type of the middle element.

R - type of the right element.

Parameters:

left - the left element of the triple.

middle - the middle element of the triple.

right - the right element of the triple.

Returns:

a new comparable triple with the given values.

of

public static <L extends Comparable<L>,M extends Comparable<M>,R extends Comparable<R>> ComparableTriple<L,M,R> of(Triple<L,M,R> triple)

Creates a new ComparableTriple with the given Comparable values.

This implementation considers null to be less than non-null. Using this method is the same as invoking ComparableTriple.of(left,false,middle,false,right,false).

This factory method is null-safe, if the given triple is null, then this method will return null.

Type Parameters:

L - type of the left element.

M - type of the middle element.

R - type of the right element.

Parameters:

triple - the source triple to make Comparable.

Returns:

a new comparable triple with the given values.

of

public static <L extends Comparable<L>,M extends Comparable<M>,R extends Comparable<R>> ComparableTriple<L,M,R> of(L left,
                                                                                                                   boolean leftNullLast,
                                                                                                                   M middle,
                                                                                                                   boolean middleNullLast,
                                                                                                                   R right,
                                                                                                                   boolean rightNullLast)

Creates a new ComparableTriple with the given values.

Type Parameters:

L - type of the left element.

M - type of the middle element.

R - type of the right element.

Parameters:

left - the left element of the triple.

leftNullLast - tells to consider null to be greater than non-null.

middle - the middle element of the triple.

middleNullLast - tells to consider null to be greater than non-null.

right - the right element of the triple.

rightNullLast - tells to consider null to be greater than non-null.

Returns:

a new comparable triple with the given values.

of

public static <L extends Comparable<L>,M extends Comparable<M>,R extends Comparable<R>> ComparableTriple<L,M,R> of(Triple<L,M,R> triple,
                                                                                                                   boolean leftNullLast,
                                                                                                                   boolean middleNullLast,
                                                                                                                   boolean rightNullLast)

Creates a new ComparableTriple starting from the given Triple of Comparable values and applies the given behavior for null values.

This factory method is null-safe, if the given triple is null, then this method will return null.

Type Parameters:

L - type of the left element.

M - type of the middle element.

R - type of the right element.

Parameters:

triple - the source triple to make Comparable.

leftNullLast - tells to consider null to be greater than non-null.

middleNullLast - tells to consider null to be greater than non-null.

rightNullLast - tells to consider null to be greater than non-null.

Returns:

a new comparable triple with the given values.

of

public static <L,M,R> ComparableTriple<L,M,R> of(L left,
                                                 Comparator<L> leftComparator,
                                                 M middle,
                                                 Comparator<M> middleComparator,
                                                 R right,
                                                 Comparator<R> rightComparator)

Creates a new ComparableTriple with the given values.

Type Parameters:

L - type of the left element.

M - type of the middle element.

R - type of the right element.

Parameters:

left - the left element of the triple.

leftComparator - comparator for values of type <L>.

middle - the middle element of the triple.

middleComparator - comparator for values of type <M>.

right - the right element of the triple.

rightComparator - comparator for values of type <R>.

Returns:

a new comparable triple with the given values.

of

public static <L,M,R> ComparableTriple<L,M,R> of(Triple<L,M,R> triple,
                                                 Comparator<L> leftComparator,
                                                 Comparator<M> middleComparator,
                                                 Comparator<R> rightComparator)

Creates a new ComparableTriple starting from the given Triple of Comparable values and applies the given value comparators.

This factory method is null-safe, if the given triple is null, then this method will return null.

Type Parameters:

L - type of the left element.

M - type of the middle element.

R - type of the right element.

Parameters:

triple - the source triple to make Comparable.

leftComparator - comparator for values of type <L>.

middleComparator - comparator for values of type <M>.

rightComparator - comparator for values of type <R>.

Returns:

a new comparable triple with the given values.

withLeft

public static <L extends Comparable<L>> ComparableTriple.MiddleBuilder<L> withLeft(L value)

Creates a new ComparableTriple.MiddleBuilder with the given left value.

This implementation considers null to be less than non-null. Using this method is the same as invoking ComparableTriple.left(value,false).

Type Parameters:

L - type of the left element.

Parameters:

value - the left element of the triple.

Returns:

a new ComparableTriple.MiddleBuilder

withLeft

public static <L extends Comparable<L>> ComparableTriple.MiddleBuilder<L> withLeft(L value,
                                                                                   boolean nullLast)

Creates a new ComparableTriple.MiddleBuilder with the given left values.

Type Parameters:

L - type of the left element.

Parameters:

value - the left element of the triple.

nullLast - tells to consider null to be greater than non-null.

Returns:

a new ComparableTriple.MiddleBuilder

withLeft

public static <L> ComparableTriple.MiddleBuilder<L> withLeft(L value,
                                                             Comparator<L> comparator)

Creates a new ComparableTriple.MiddleBuilder with the given left values.

Type Parameters:

L - type of the left element.

Parameters:

value - the left element of the triple.

comparator - comparator for values of type <L>.

Returns:

a new ComparableTriple.MiddleBuilder

compareTo

public int compareTo(ComparableTriple<L,M,R> other)

Specified by:

compareTo in interface Comparable<ComparableTriple<L,M,R>>

getLeftComparator

public Comparator<L> getLeftComparator()

Returns the comparator for values of type <L>.

Returns:

comparator for values of type <L>.

getMiddleComparator

public Comparator<M> getMiddleComparator()

Returns the comparator for values of type <M>.

Returns:

comparator for values of type <M>.

getRightComparator

public Comparator<R> getRightComparator()

Returns the comparator for values of type <R>.

Returns:

comparator for values of type <R>.