|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectcom.google.common.base.Equivalence<T>
@Beta @GwtCompatible public abstract class Equivalence<T>
A strategy for determining whether two instances are considered equivalent. Examples of
equivalences are the identity equivalence and equals equivalence.
| Nested Class Summary | |
|---|---|
static class |
Equivalence.Wrapper<T>
Wraps an object so that Equivalence.Wrapper.equals(Object) and Equivalence.Wrapper.hashCode() delegate to an
Equivalence. |
| Constructor Summary | |
|---|---|
protected |
Equivalence()
Constructor for use by subclasses. |
| Method Summary | ||
|---|---|---|
protected abstract boolean |
doEquivalent(T a,
T b)
Returns true if a and b are considered equivalent. |
|
protected abstract int |
doHash(T t)
Returns a hash code for non-null object t. |
|
boolean |
equivalent(T a,
T b)
Returns true if the given objects are considered equivalent. |
|
Predicate<T> |
equivalentTo(T target)
Returns a predicate that evaluates to true if and only if the input is equivalent to target according to this equivalence relation. |
|
int |
hash(T t)
Returns a hash code for t. |
|
|
onResultOf(Function<F,? extends T> function)
Returns a new equivalence relation for F which evaluates equivalence by first applying
function to the argument, then evaluating using this. |
|
|
pairwise()
Returns an equivalence over iterables based on the equivalence of their elements. |
|
|
wrap(S reference)
Returns a wrapper of reference that implements
Object.equals() such that
wrap(this, a).equals(wrap(this, b)) if and only if this.equivalent(a, b). |
|
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
protected Equivalence()
| Method Detail |
|---|
public final boolean equivalent(@Nullable
T a,
@Nullable
T b)
true if the given objects are considered equivalent.
The equivalent method implements an equivalence relation on object references:
x, including null, equivalent(x, x) returns true.
x and y, equivalent(x, y) == equivalent(y, x).
x, y, and z, if
equivalent(x, y) returns true and equivalent(y, z) returns true, then equivalent(x, z) returns true.
x and y, multiple invocations
of equivalent(x, y) consistently return true or consistently return false (provided that neither x nor y is modified).
protected abstract boolean doEquivalent(T a,
T b)
true if a and b are considered equivalent.
Called by equivalent(T, T). a and b are not the same
object and are not nulls.
public final int hash(@Nullable
T t)
t.
The hash has the following properties:
x, multiple invocations of
hash(x} consistently return the same value provided x remains unchanged
according to the definition of the equivalence. The hash need not remain consistent from
one execution of an application to another execution of the same application.
x and y,
if equivalent(x, y), then hash(x) == hash(y). It is not necessary
that the hash be distributable accorss inequivalence. If equivalence(x, y)
is false, hash(x) == hash(y) may still be true.
hash(null) is 0.
protected abstract int doHash(T t)
t.
Called by hash(T).
public final <F> Equivalence<F> onResultOf(Function<F,? extends T> function)
F which evaluates equivalence by first applying
function to the argument, then evaluating using this. That is, for any pair of
non-null objects x and y, equivalence.onResultOf(function).equivalent(a, b) is true if and only if equivalence.equivalent(function.apply(a), function.apply(b)) is true.
For example:
Equivalence<Person> SAME_AGE = Equivalences.equals().onResultOf(GET_PERSON_AGE);
function will never be invoked with a null value.
Note that function must be consistent according to this equivalence
relation. That is, invoking Function.apply(F) multiple times for a given value must return
equivalent results.
For example, Equivalences.identity().onResultOf(Functions.toStringFunction()) is broken
because it's not guaranteed that Object.toString()) always returns the same string
instance.
public final <S extends T> Equivalence.Wrapper<S> wrap(@Nullable
S reference)
reference that implements
Object.equals() such that
wrap(this, a).equals(wrap(this, b)) if and only if this.equivalent(a, b).
@GwtCompatible(serializable=true) public final <S extends T> Equivalence<Iterable<S>> pairwise()
this. Null iterables are equivalent to one another.
Note that this method performs a similar function for equivalences as Ordering.lexicographical() does for orderings.
public final Predicate<T> equivalentTo(@Nullable
T target)
target according to this equivalence relation.
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||