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

Introduction

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

Prototype

public final <S extends T> Wrapper<S> wrap(@Nullable S reference) 

Source Link

Document

Returns a wrapper of reference that implements Wrapper#equals(Object) Object.equals() such that wrap(a).equals(wrap(b)) if and only if equivalent(a, b) .

Usage

From source file:dagger2.internal.codegen.Util.java

/**
 * Wraps an {@link Optional} of a type in an {@code Optional} of a {@link Wrapper} for that type.
 *//*from w w w. j  av  a  2s . co  m*/
static <T> Optional<Equivalence.Wrapper<T>> wrapOptionalInEquivalence(Equivalence<T> equivalence,
        Optional<T> optional) {
    return optional.isPresent() ? Optional.of(equivalence.wrap(optional.get()))
            : Optional.<Equivalence.Wrapper<T>>absent();
}

---

From source file:grakn.core.graql.reasoner.utils.ReasonerUtils.java

private static <B, S extends B> Map<Equivalence.Wrapper<B>, Integer> getCardinalityMap(Collection<S> coll,
        Equivalence<B> equiv) {
    Map<Equivalence.Wrapper<B>, Integer> count = new HashMap<>();
    for (S obj : coll)
        count.merge(equiv.wrap(obj), 1, (a, b) -> a + b);
    return count;
}

---

From source file:com.b2international.commons.collections.Collections3.java

/**
 * Returns with the {@link SetDifference difference} of the two sets using the given {@link Equivalence equivalence} 
 * among the set elements. //from   w  w w .j a v  a  2s  . c  o  m
 * @param left the left set.
 * @param right the other set.
 * @param equivalence equivalence for comparing set elements between each others. 
 * @return the difference.
 */
public static <E> SetDifference<E> compare(final Set<E> left, final Set<E> right,
        final Equivalence<E> equivalence) {

    checkNotNull(left, "left");
    checkNotNull(right, "right");
    checkNotNull(equivalence, "equivalence");

    final Function<Wrapper<E>, E> unwrapFunction = new Function<Wrapper<E>, E>() {
        @Override
        public E apply(final Wrapper<E> wrapper) {
            return wrapper.get();
        }
    };

    final Function<E, Wrapper<E>> wrapFunction = new Function<E, Wrapper<E>>() {
        @Override
        public Wrapper<E> apply(final E element) {
            return equivalence.wrap(element);
        }
    };

    final Set<Wrapper<E>> leftCopy = copyOf(transform(left, wrapFunction));
    final Set<Wrapper<E>> rightCopy = copyOf(transform(right, wrapFunction));

    //TODO check identical equality
    //TODO consider empty left and/or right

    final AtomicReference<Set<Wrapper<E>>> leftDiff = new AtomicReference<>();
    final AtomicReference<Set<Wrapper<E>>> rightDiff = new AtomicReference<>();
    final AtomicReference<Set<Wrapper<E>>> intersection = new AtomicReference<>();

    final CountDownLatch latch = new CountDownLatch(3);

    new Thread(new Runnable() {
        public void run() {
            try {
                leftDiff.set(difference(leftCopy, rightCopy));
            } finally {
                latch.countDown();
            }
        }
    }, "Calculate-set-left-diff-thread").start();

    new Thread(new Runnable() {
        public void run() {
            try {
                rightDiff.set(difference(rightCopy, leftCopy));
            } finally {
                latch.countDown();
            }
        }
    }, "Calculate-set-right-diff-thread").start();
    ;

    new Thread(new Runnable() {
        public void run() {
            try {
                intersection.set(intersection(leftCopy, rightCopy));
            } finally {
                latch.countDown();
            }
        }
    }, "Calculate-set-intersection-thread").start();

    try {
        latch.await(15L, TimeUnit.MINUTES);
    } catch (final InterruptedException e) {
        throw new RuntimeException("Failed to calculate set difference.", e);
    }

    final Function<AtomicReference<Set<Wrapper<E>>>, Set<E>> toSetFunction = new Function<AtomicReference<Set<Wrapper<E>>>, Set<E>>() {
        @Override
        public Set<E> apply(final AtomicReference<Set<Wrapper<E>>> input) {
            return newHashSet(transform(input.get(), unwrapFunction));
        }
    };

    return new SetDifferenceImpl<E>(toSetFunction.apply(leftDiff), toSetFunction.apply(rightDiff),
            toSetFunction.apply(intersection));
}

---

From source file:org.gradle.util.CollectionUtils.java

public static <T> List<T> dedup(Iterable<T> source, final Equivalence<T> equivalence) {
    Iterable<Equivalence.Wrapper<T>> wrappers = Iterables.transform(source,
            new Function<T, Equivalence.Wrapper<T>>() {
                public Equivalence.Wrapper<T> apply(@Nullable T input) {
                    return equivalence.wrap(input);
                }//from   www .  j a v a  2 s.  c  o m
            });
    Set<Equivalence.Wrapper<T>> deduped = ImmutableSet.copyOf(wrappers);
    return ImmutableList.copyOf(Iterables.transform(deduped, new Function<Equivalence.Wrapper<T>, T>() {
        public T apply(Equivalence.Wrapper<T> input) {
            return input.get();
        }
    }));
}

---