Example usage for com.google.common.base Equivalence hash

Introduction

In this page you can find the example usage for com.google.common.base Equivalence hash.

Prototype

public final int hash(@Nullable T t) 

Source Link

Document

Returns a hash code for t .

Usage

From source file:grakn.core.graql.reasoner.atom.AtomicEquivalence.java

public static <B extends Atomic, S extends B> int equivalenceHash(Stream<S> atoms, Equivalence<B> equiv) {
    int hashCode = 1;
    SortedSet<Integer> hashes = new TreeSet<>();
    atoms.forEach(atom -> hashes.add(equiv.hash(atom)));
    for (Integer hash : hashes)
        hashCode = hashCode * 37 + hash;
    return hashCode;
}

---

From source file:org.apache.marmotta.commons.sesame.model.StatementCommons.java

private static <E> Equality<E> equivalenceEquality(final Equivalence<E> equivalence) {
    return new Equality<E>() {
        private static final long serialVersionUID = 1L;

        @Override//from   www .jav a  2s  .  co m
        public int hashCodeOf(E object) {
            return equivalence.hash(object);
        }

        @Override
        public boolean areEqual(E left, E right) {
            return equivalence.equivalent(left, right);
        }

        @Override
        public int compare(E left, E right) {
            return equivalence.hash(left) - equivalence.hash(right);
        }

        @Override
        public int hashCode() {
            return equivalence.hashCode();
        }

        @Override
        public boolean equals(Object obj) {
            return obj.hashCode() == hashCode();
        }
    };
}

---

From source file:com.google.javascript.rhino.testing.TypeSubject.java

private void checkEqualityAgainst(@Nullable JSType provided, boolean expectation, Equivalence equivalence) {
    String providedString = debugStringOf(provided);
    String actualString = debugStringOf(actual());

    boolean actualEqualsProvided = equivalence.test(actual(), provided);
    if (actualEqualsProvided != expectation) {
        failWithActual(fact("Types expected to be equal", expectation), //
                fact(equivalence.stringify(actualString, providedString), actualEqualsProvided), //
                fact("provided", providedString));
    }/*from  w  w w  . j av  a2  s  .c o  m*/

    boolean providedEqualsActual = equivalence.test(provided, actual());
    if (actualEqualsProvided != providedEqualsActual) {
        failWithActual(simpleFact("Equality should be symmetric"), //
                fact(equivalence.stringify(actualString, providedString), actualEqualsProvided),
                fact(equivalence.stringify(providedString, actualString), providedEqualsActual),
                fact("provided", providedString));
    }

    if (expectation) {
        if (equivalence.hash(actual()) != equivalence.hash(provided)) {
            failWithActual(simpleFact("If two types are equal their hashcodes must also be equal"), //
                    fact("definition of equality", equivalence.stringify("actual", "provided")),
                    fact("hash of actual", equivalence.hash(actual())),
                    fact("hash of provided", equivalence.hash(provided)), fact("provided", providedString));
        }
    }
}

---