com.google.common.base.Equivalence Java Examples

private static <K, V> void doDifference(Map<? extends K, ? extends V> left, Map<? extends K, ? extends V> right, Equivalence<? super V> valueEquivalence, Map<K, V> onlyOnLeft, Map<K, V> onlyOnRight, Map<K, V> onBoth, Map<K, MapDifference.ValueDifference<V>> differences) {
  for (Entry<? extends K, ? extends V> entry : left.entrySet()) {
    K leftKey = entry.getKey();
    V leftValue = entry.getValue();
    if (right.containsKey(leftKey)) {
      V rightValue = onlyOnRight.remove(leftKey);
      if (valueEquivalence.equivalent(leftValue, rightValue)) {
        onBoth.put(leftKey, leftValue);
      } else {
        differences.put(leftKey, ValueDifferenceImpl.create(leftValue, rightValue));
      }
    } else {
      onlyOnLeft.put(leftKey, leftValue);
    }
  }
}
 

private Set<ReasonerQueryImpl> getAllNeighbours(ReasonerQueryImpl entryQuery) {
    Set<ReasonerQueryImpl> neighbours = new HashSet<>();
    Set<Equivalence.Wrapper<ReasonerQueryImpl>> visitedQueries = new HashSet<>();
    Stack<Equivalence.Wrapper<ReasonerQueryImpl>> queryStack = new Stack<>();

    Multimap<ReasonerQueryImpl, ReasonerQueryImpl> neighbourMap = immediateNeighbourMap();

    neighbourMap.get(entryQuery).stream().map(q -> equality().wrap(q)).forEach(queryStack::push);
    while (!queryStack.isEmpty()) {
        Equivalence.Wrapper<ReasonerQueryImpl> wrappedQuery = queryStack.pop();
        ReasonerQueryImpl query = wrappedQuery.get();
        if (!visitedQueries.contains(wrappedQuery) && query != null) {
            neighbourMap.get(query).stream()
                    .peek(neighbours::add)
                    .flatMap(q -> neighbourMap.get(q).stream())
                    .map(q -> equality().wrap(q))
                    .filter(q -> !visitedQueries.contains(q))
                    .filter(q -> !queryStack.contains(q))
                    .forEach(queryStack::add);
            visitedQueries.add(wrappedQuery);
        }
    }
    return neighbours;
}
 

private static <K, V> void doDifference(
    Map<? extends K, ? extends V> left,
    Map<? extends K, ? extends V> right,
    Equivalence<? super V> valueEquivalence,
    Map<K, V> onlyOnLeft,
    Map<K, V> onlyOnRight,
    Map<K, V> onBoth,
    Map<K, MapDifference.ValueDifference<V>> differences) {
  for (Entry<? extends K, ? extends V> entry : left.entrySet()) {
    K leftKey = entry.getKey();
    V leftValue = entry.getValue();
    if (right.containsKey(leftKey)) {
      V rightValue = onlyOnRight.remove(leftKey);
      if (valueEquivalence.equivalent(leftValue, rightValue)) {
        onBoth.put(leftKey, leftValue);
      } else {
        differences.put(leftKey, ValueDifferenceImpl.create(leftValue, rightValue));
      }
    } else {
      onlyOnLeft.put(leftKey, leftValue);
    }
  }
}
 

ComputingSerializationProxy(
    Strength keyStrength,
    Strength valueStrength,
    Equivalence<Object> keyEquivalence,
    Equivalence<Object> valueEquivalence,
    int concurrencyLevel,
    ConcurrentMap<K, V> delegate,
    Function<? super K, ? extends V> computingFunction) {
  super(
      keyStrength,
      valueStrength,
      keyEquivalence,
      valueEquivalence,
      concurrencyLevel,
      delegate);
  this.computingFunction = computingFunction;
}
 

private static <K, V> void doDifference(Map<? extends K, ? extends V> left, Map<? extends K, ? extends V> right, Equivalence<? super V> valueEquivalence, Map<K, V> onlyOnLeft, Map<K, V> onlyOnRight, Map<K, V> onBoth, Map<K, MapDifference.ValueDifference<V>> differences) {
  for (Entry<? extends K, ? extends V> entry : left.entrySet()) {
    K leftKey = entry.getKey();
    V leftValue = entry.getValue();
    if (right.containsKey(leftKey)) {
      V rightValue = onlyOnRight.remove(leftKey);
      if (valueEquivalence.equivalent(leftValue, rightValue)) {
        onBoth.put(leftKey, leftValue);
      } else {
        differences.put(leftKey, ValueDifferenceImpl.create(leftValue, rightValue));
      }
    } else {
      onlyOnLeft.put(leftKey, leftValue);
    }
  }
}
 

private ManualSerializationProxy(
    Strength keyStrength,
    Strength valueStrength,
    Equivalence<Object> keyEquivalence,
    Equivalence<Object> valueEquivalence,
    long expireAfterWriteNanos,
    long expireAfterAccessNanos,
    long maxWeight,
    Weigher<K, V> weigher,
    int concurrencyLevel,
    RemovalListener<? super K, ? super V> removalListener,
    Ticker ticker,
    CacheLoader<? super K, V> loader) {
  this.keyStrength = keyStrength;
  this.valueStrength = valueStrength;
  this.keyEquivalence = keyEquivalence;
  this.valueEquivalence = valueEquivalence;
  this.expireAfterWriteNanos = expireAfterWriteNanos;
  this.expireAfterAccessNanos = expireAfterAccessNanos;
  this.maxWeight = maxWeight;
  this.weigher = weigher;
  this.concurrencyLevel = concurrencyLevel;
  this.removalListener = removalListener;
  this.ticker = (ticker == Ticker.systemTicker() || ticker == NULL_TICKER) ? null : ticker;
  this.loader = loader;
}
 

/**
 * Wraps an {@link Optional} of a type in an {@code Optional} of a {@link Equivalence.Wrapper} for
 * that type.
 */
// TODO(ronshapiro): this is used in AutoFactory and Dagger, consider moving it into auto-common.
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();
}
 

static
private void checkEquivalence(boolean result, double expectedValue, double actualValue, int tolerance){
	Equivalence<Object> equivalence = new RealNumberEquivalence(tolerance);

	assertEquals(result, equivalence.equivalent(expectedValue, actualValue));
	assertEquals(result, equivalence.equivalent(Double.toString(expectedValue), actualValue));
}
 

static <K, V> void assertMapsEqual(
    Map<K, V> expected, Map<K, V> result, Equivalence<V> valueEquivalence) {
  MapDifference<K, V> diff = Maps.difference(expected, result, valueEquivalence);
  if (!diff.areEqual()) {
    fail(
        String.format(
            "Maps differ. Entries differing: %s%nMissing entries: %s%nExtra entries: %s%n",
            diff.entriesDiffering(), diff.entriesOnlyOnLeft(), diff.entriesOnlyOnRight()));
  }
}
 

private boolean isBaseEquivalent(Object obj, Equivalence<Atomic> equivalence){
    if (obj == null || this.getClass() != obj.getClass()) return false;
    if (obj == this) return true;
    AttributeAtom that = (AttributeAtom) obj;
    return equivalence.equivalent(this.attributeIsa(), that.attributeIsa())
            && equivalence.equivalent(this.ownerIsa(), that.ownerIsa());
}
 

private boolean predicateBindingsEquivalent(VariablePredicate that, Equivalence<Atomic> equiv){
    IdPredicate thisPredicate = this.getIdPredicate(this.getVarName());
    IdPredicate thatPredicate = that.getIdPredicate(that.getVarName());
    IdPredicate thisRefPredicate = this.getIdPredicate(this.getPredicate());
    IdPredicate thatRefPredicate = that.getIdPredicate(that.getPredicate());
    return (
            (thisPredicate == null) ?
            thisPredicate == thatPredicate :
            equiv.equivalent(thisPredicate, thatPredicate)
    ) && (
            (thisRefPredicate == null) ?
            (thisRefPredicate == thatRefPredicate) :
            equiv.equivalent(thisRefPredicate, thatRefPredicate)
    );
}
 

static
private Batch createBatch(Evaluator evaluator, List<? extends Map<FieldName, ?>> input, List<? extends Map<FieldName, ?>> output, Predicate<ResultField> predicate, Equivalence<Object> equivalence){
	Batch batch = new Batch(){

		@Override
		public Evaluator getEvaluator(){
			return evaluator;
		}

		@Override
		public List<? extends Map<FieldName, ?>> getInput(){
			return input;
		}

		@Override
		public List<? extends Map<FieldName, ?>> getOutput(){
			return output;
		}

		@Override
		public Predicate<ResultField> getPredicate(){
			return predicate;
		}

		@Override
		public Equivalence<Object> getEquivalence(){
			return equivalence;
		}

		@Override
		public void close(){
		}
	};

	return batch;
}
 

FieldDescriptor create(TypeElement owner, VariableElement element) {
  String name = element.getSimpleName().toString();
  TypeMirror type = types.asMemberOf((DeclaredType) owner.asType(), element);
  TypeMirror fieldType = Utils.replaceTypeVariablesWithUpperBounds(types, type);
  Equivalence.Wrapper<TypeMirror> wrappedType = MoreTypes.equivalence().wrap(fieldType);
  boolean isVisible = Visibility.ofElement(element) != Visibility.PRIVATE;
  boolean isNullable =
      Utils.getAnnotationWithSimpleName(element, NON_NULL_ANNOTATION_NAME) == null
      && Utils.getAnnotationWithSimpleName(element, NOT_NULL_ANNOTATION_NAME) == null;
  return new AutoValue_FieldDescriptor(element, name, wrappedType, isVisible, isNullable);
}
 

SerializationProxy(
    Strength keyStrength,
    Strength valueStrength,
    Equivalence<Object> keyEquivalence,
    Equivalence<Object> valueEquivalence,
    int concurrencyLevel,
    ConcurrentMap<K, V> delegate) {
  super(
      keyStrength,
      valueStrength,
      keyEquivalence,
      valueEquivalence,
      concurrencyLevel,
      delegate);
}
 

ProxyGenerator(
    TypeName outerClassTypeName,
    ImmutableList<TypeVariableName> typeVariableNames,
    ImmutableList<PropertyMirror> propertyMirrors,
    ImmutableMap<Equivalence.Wrapper<TypeMirror>, Serializer> serializersMap) {
  this.outerClassTypeName = outerClassTypeName;
  this.typeVariableNames = typeVariableNames;
  this.propertyMirrors = propertyMirrors;
  this.serializersMap = serializersMap;
}
 

/**
 * @param a first operand
 * @param b second operand
 * @param equiv equivalence on the basis of which the collections shall be compared
 * @param <B> collection base type
 * @param <S> collection super type
 * @return true iff the given Collections contain equivalent elements with exactly the same cardinalities.
 */
public static <B, S extends B> boolean isEquivalentCollection(Collection<S> a, Collection<S> b,  Equivalence<B> equiv) {
    if (a.size() != b.size()) {
        return false;
    } else {
        Map<Equivalence.Wrapper<B>, Integer> mapA = getCardinalityMap(a, equiv);
        Map<Equivalence.Wrapper<B>, Integer> mapB = getCardinalityMap(b, equiv);
        if (mapA.size() != mapB.size()) {
            return false;
        } else {
            return mapA.keySet().stream().allMatch(k -> mapA.get(k).equals(mapB.get(k)));
        }
    }
}
 

protected ArchiveBatch createBatch(String name, String dataset, Class<? extends Converter<? extends RExp>> converterClazz){
	Predicate<ResultField> predicate = (resultField -> true);
	Equivalence<Object> equivalence = getEquivalence();

	ConverterTestBatch batch = (ConverterTestBatch)createBatch(name, dataset, predicate, equivalence);
	batch.setConverterClazz(converterClazz);

	return batch;
}
 

private Optional<RequestResolver> getOwningResolver(ProvisionBinding provisionBinding) {
  Optional<Equivalence.Wrapper<AnnotationMirror>> bindingScope =
      provisionBinding.wrappedScope();
  for (RequestResolver requestResolver : getResolverLineage()) {
    if (bindingScope.equals(requestResolver.targetScope)
        || requestResolver.explicitProvisionBindings.containsValue(provisionBinding)) {
      return Optional.of(requestResolver);
    }
  }
  return Optional.absent();
}
 

/**
 * Tests whether a given parameter can be given to a static method like
 * {@code ImmutableMap.copyOf} to produce a value that can be assigned to the given target type.
 *
 * <p>For example, suppose we have this method in {@code ImmutableMap}:<br>
 * {@code static <K, V> ImmutableMap<K, V> copyOf(Map<? extends K, ? extends V>)}<br>
 * and we want to know if we can do this:
 *
 * <pre>
 * {@code ImmutableMap<String, Integer> actualParameter = ...;}
 * {@code ImmutableMap<String, Number> target = ImmutableMap.copyOf(actualParameter);}
 * </pre>
 *
 * We will infer {@code K=String}, {@code V=Number} based on the target type, and then rewrite the
 * formal parameter type from<br>
 * {@code Map<? extends K, ? extends V>} to<br>
 * {@code Map<? extends String, ? extends Number>}. Then we can check whether
 * {@code actualParameter} is assignable to that.
 *
 * <p>The logic makes some simplifying assumptions, which are met for the {@code copyOf} and
 * {@code of} methods that we use this for. The method must be static, it must have exactly one
 * parameter, and it must have type parameters without bounds that are the same as the type
 * parameters of its return type. We can see that these assumptions are met for the
 * {@code ImmutableMap.copyOf} example above.
 */
static boolean canAssignStaticMethodResult(
    ExecutableElement method,
    TypeMirror actualParameterType,
    TypeMirror targetType,
    Types typeUtils) {
  if (!targetType.getKind().equals(TypeKind.DECLARED)
      || !method.getModifiers().contains(Modifier.STATIC)
      || method.getParameters().size() != 1) {
    return false;
  }
  List<? extends TypeParameterElement> typeParameters = method.getTypeParameters();
  List<? extends TypeMirror> targetTypeArguments =
      MoreTypes.asDeclared(targetType).getTypeArguments();
  if (typeParameters.size() != targetTypeArguments.size()) {
    return false;
  }
  Map<Equivalence.Wrapper<TypeVariable>, TypeMirror> typeVariables = new LinkedHashMap<>();
  for (int i = 0; i < typeParameters.size(); i++) {
    TypeVariable v = MoreTypes.asTypeVariable(typeParameters.get(i).asType());
    typeVariables.put(MoreTypes.equivalence().wrap(v), targetTypeArguments.get(i));
  }
  TypeMirror formalParameterType = method.getParameters().get(0).asType();
  SubstitutionVisitor substitutionVisitor = new SubstitutionVisitor(typeVariables, typeUtils);
  TypeMirror substitutedParameterType = substitutionVisitor.visit(formalParameterType, null);
  if (substitutedParameterType.getKind().equals(TypeKind.WILDCARD)) {
    // If the target type is Optional<? extends Foo> then <T> T Optional.of(T) will give us
    // ? extends Foo here, and typeUtils.isAssignable will return false. But we can in fact
    // give a Foo as an argument, so we just replace ? extends Foo with Foo.
    WildcardType wildcard = MoreTypes.asWildcard(substitutedParameterType);
    if (wildcard.getExtendsBound() != null) {
      substitutedParameterType = wildcard.getExtendsBound();
    }
  }
  return typeUtils.isAssignable(actualParameterType, substitutedParameterType);
}
 

/**
 * @param entryQuery query for which candidates are to be determined
 * @param plan current plan
 * @return set of candidate queries for this query
 */
QuerySet getCandidates(ReasonerQueryImpl entryQuery, QueryList plan){
    Equivalence.Wrapper<ReasonerQueryImpl> query = equality().wrap(entryQuery);
    Set<Equivalence.Wrapper<ReasonerQueryImpl>> availableQueries = this.wrappedStream()
            .filter(q -> !(plan.contains(q) || q.equals(query)))
            .collect(Collectors.toSet());

    Set<Equivalence.Wrapper<ReasonerQueryImpl>> availableImmediateNeighbours = this.getImmediateNeighbours(query).stream()
            .filter(availableQueries::contains)
            .collect(Collectors.toSet());

    Set<Variable> subbedVars = plan.stream()
            .flatMap(q -> q.getVarNames().stream())
            .collect(Collectors.toSet());

    Set<Equivalence.Wrapper<ReasonerQueryImpl>> availableImmediateNeighboursFromSubs = availableQueries.stream()
            .map(Equivalence.Wrapper::get)
            .filter(Objects::nonNull)
            .filter(q -> !Sets.intersection(q.getVarNames(), subbedVars).isEmpty())
            .map(q -> equality().wrap(q))
            .collect(Collectors.toSet());

    return QuerySet.create(
            this.isQueryDisconnected(query)?
                    availableQueries :
                    this.isQueryReachable(query, availableQueries)?
                            Sets.union(availableImmediateNeighbours, availableImmediateNeighboursFromSubs): availableQueries
    );
}
 

RelationshipTester(Equivalence<? super T> equivalence, String relationshipName, String hashName,
		ItemReporter itemReporter) {
	this.equivalence = checkNotNull(equivalence);
	this.relationshipName = checkNotNull(relationshipName);
	this.hashName = checkNotNull(hashName);
	this.itemReporter = checkNotNull(itemReporter);
}
 

private Equivalence<BrowseNode<Integer>> getIdentity(final Repository repository) {
  Optional<BrowseNodeFacet> browseNodeFacet = repository.optionalFacet(BrowseNodeFacet.class);
  if (browseNodeFacet.isPresent()) {
    return Equivalence.equals().onResultOf(input -> browseNodeFacet.get().browseNodeIdentity().apply(input));
  }
  else {
    return Equivalence.equals().onResultOf(BrowseNode::getName);
  }
}
 

AbstractSerializationProxy(
    Strength keyStrength,
    Strength valueStrength,
    Equivalence<Object> keyEquivalence,
    Equivalence<Object> valueEquivalence,
    int concurrencyLevel,
    ConcurrentMap<K, V> delegate) {
  this.keyStrength = keyStrength;
  this.valueStrength = valueStrength;
  this.keyEquivalence = keyEquivalence;
  this.valueEquivalence = valueEquivalence;
  this.concurrencyLevel = concurrencyLevel;
  this.delegate = delegate;
}
 

/**
 * Sets a custom {@code Equivalence} strategy for comparing keys.
 *
 * <p>By default, the map uses {@link Equivalence#identity} to determine key equality when
 * {@link #weakKeys} is specified, and {@link Equivalence#equals()} otherwise. The only place this
 * is used is in {@link Interners.WeakInterner}.
 */

@CanIgnoreReturnValue
@GwtIncompatible // To be supported
MapMaker keyEquivalence(Equivalence<Object> equivalence) {
  checkState(keyEquivalence == null, "key equivalence was already set to %s", keyEquivalence);
  keyEquivalence = checkNotNull(equivalence);
  this.useCustomMap = true;
  return this;
}
 

ProvisionBinding forComponent(TypeElement componentDefinitionType) {
  checkNotNull(componentDefinitionType);
  return new AutoValue_ProvisionBinding(
      keyFactory.forComponent(componentDefinitionType.asType()),
      componentDefinitionType,
      ImmutableSet.<DependencyRequest>of(),
      Optional.<String>absent(),
      false /* no non-default parameter types */,
      Optional.<DeclaredType>absent(),
      Optional.<TypeElement>absent(),
      Kind.COMPONENT,
      Provides.Type.UNIQUE,
      Optional.<Equivalence.Wrapper<AnnotationMirror>>absent(),
      Optional.<DependencyRequest>absent());
}
 

@Test public void forInjectConstructorWithResolvedType() {
  TypeElement typeElement =
      compilationRule.getElements().getTypeElement(InjectedClass.class.getCanonicalName());
  ExecutableElement constructor =
      Iterables.getOnlyElement(ElementFilter.constructorsIn(typeElement.getEnclosedElements()));
  assertThat(
      keyFactory.forInjectConstructorWithResolvedType(constructor.getEnclosingElement().asType()))
      .isEqualTo(new AutoValue_Key(
          Optional.<Equivalence.Wrapper<AnnotationMirror>>absent(),
          MoreTypes.equivalence().wrap(typeElement.asType())));
}
 

@Override
protected ArchiveBatch createBatch(String name, String dataset, Predicate<ResultField> predicate, Equivalence<Object> equivalence){
	ArchiveBatch result = new ConverterTestBatch(name, dataset, predicate, equivalence){

		@Override
		public IntegrationTest getIntegrationTest(){
			return ConverterTest.this;
		}

		@Override
		public PMML getPMML() throws Exception {

			try(InputStream is = open("/rds/" + getName() + getDataset() + ".rds")){
				RExpParser parser = new RExpParser(is);

				RExp rexp = parser.parse();

				Converter<RExp> converter = createConverter(rexp);

				PMML pmml = converter.encodePMML();

				validatePMML(pmml);

				return pmml;
			}
		}
	};

	return result;
}
 

@Test public void forProducesMethod_sets() {
  TypeElement setElement = elements.getTypeElement(Set.class.getCanonicalName());
  TypeMirror stringType = elements.getTypeElement(String.class.getCanonicalName()).asType();
  TypeMirror setOfStringsType = types.getDeclaredType(setElement, stringType);
  TypeElement moduleElement =
      elements.getTypeElement(SetProducesMethodsModule.class.getCanonicalName());
  for (ExecutableElement producesMethod
      : ElementFilter.methodsIn(moduleElement.getEnclosedElements())) {
    assertThat(keyFactory.forProducesMethod(
        (ExecutableType) producesMethod.asType(), producesMethod))
        .isEqualTo(new AutoValue_Key(
                Optional.<Equivalence.Wrapper<AnnotationMirror>>absent(),
                MoreTypes.equivalence().wrap(setOfStringsType)));
  }
}
 

static
private void checkEquivalence(boolean result, float expectedValue, float actualValue, int tolerance){
	Equivalence<Object> equivalence = new RealNumberEquivalence(tolerance);

	assertEquals(result, equivalence.equivalent(expectedValue, actualValue));
	assertEquals(result, equivalence.equivalent((double)expectedValue, actualValue));
	assertEquals(result, equivalence.equivalent(Float.toString(expectedValue), actualValue));
	assertEquals(result, equivalence.equivalent(Double.toString(expectedValue), actualValue));
}
 

private List<String> setPermissionList(List<Permission> newer, List<Permission> older) {
    Timestamp now = new Timestamp(System.currentTimeMillis());
    List<String> remarks = Lists.newArrayList();
    List<Permission> changes = Lists.newArrayList();

    Map<String, Permission> infoMap = mapByRtxId(newer);
    Map<String, Permission> originInfoMap = mapByRtxId(older);

    MapDifference<String, Permission> difference = Maps.difference(infoMap, originInfoMap, new Equivalence<Permission>() {
        @Override
        protected boolean doEquivalent(Permission a, Permission b) {
            return a.getPermission() == b.getPermission() && a.getRtxId().equals(b.getRtxId());
        }

        @Override
        protected int doHash(Permission permissionInfo) {
            return Objects.hashCode(permissionInfo.getRtxId(), permissionInfo.getPermission());
        }
    });

    dealOnlyOnLeft(changes, remarks, infoMap, difference, now);
    dealDifference(changes, remarks, infoMap, originInfoMap, difference, now);

    if (!changes.isEmpty() && changes.get(0).processChange(permissionDao, changes)) {
        logger.info("change permissions successOf, {}", changes);
    }

    return remarks;
}