org.organicdesign.fp.collections

Interface ComparisonContext<T>

All Superinterfaces:

Comparator<T>, Equator<T>

All Known Implementing Classes:

ComparisonContext.CompCtx

public interface ComparisonContext<T>
extends Equator<T>, Comparator<T>

Implement compare() and hash() and you get a 100% compatible eq() for free. If you don't need Comparator, just use Equator. Typical implementations compare() throw an IllegalArgumentException if one parameter is null (if both are null, it's probably OK to return 0). More at eq(Object, Object). A common mistake is to implement a ComparisonContext, Equator, or Comparator as an anonymous class or lambda, then be surprised when it is can't be serialized, or is deserialized as null. These one-off classes are often singletons, which are easiest to serialize as enums. If your implementation requires generic type parameters, look at how defCompCtx() tricks the type system into using generic type parameters (correctly) with an enum.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	ComparisonContext.CompCtx

Nested classes/interfaces inherited from interface org.organicdesign.fp.collections.Equator

Equator.Comp, Equator.Equat

Method Summary

Modifier and Type	Method and Description
static <T> ComparisonContext<T>	defCompCtx()
default boolean	eq(T o1, T o2) The default implementation of this method returns false if only one parameter is null then checks if compare() returns zero.
default boolean	gt(T o1, T o2) Returns true if the first object is greater than the second.
default boolean	gte(T o1, T o2) Returns true if the first object is greater than or equal to the second.
default boolean	lt(T o1, T o2) Returns true if the first object is less than the second.
default boolean	lte(T o1, T o2) Returns true if the first object is less than or equal to the second.

Methods inherited from interface org.organicdesign.fp.collections.Equator

defaultComparator, defaultEquator, hash

Methods inherited from interface java.util.Comparator

compare, comparing, comparing, comparingDouble, comparingInt, comparingLong, equals, naturalOrder, nullsFirst, nullsLast, reversed, reverseOrder, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong

Method Detail

lt

default boolean lt(T o1,
                   T o2)

Returns true if the first object is less than the second.

lte

default boolean lte(T o1,
                    T o2)

Returns true if the first object is less than or equal to the second.

gt

default boolean gt(T o1,
                   T o2)

Returns true if the first object is greater than the second.

gte

default boolean gte(T o1,
                    T o2)

Returns true if the first object is greater than or equal to the second.

eq

default boolean eq(T o1,
                   T o2)

The default implementation of this method returns false if only one parameter is null then checks if compare() returns zero. Only null is equal to null. If we are passed only one null value, we return false (two nulls are always equal). Many correct implementations of compare(null, nonNull) throw IllegalArgumentExceptions if one argument is null because most objects cannot be meaningfully be orderd with respect to null, but that's OK because we check for nulls first, then check compare().

Specified by:

eq in interface Equator<T>

Returns:

true if this Equator considers the two objects to be equal.

defCompCtx

static <T> ComparisonContext<T> defCompCtx()