java类com.google.common.collect.MapDifference的实例源码

@Override
public void updatingValues(TransactionBase tx,
    Iterator<org.apache.fluo.recipes.core.map.Update<String, Long>> updates) {
  TypedTransactionBase ttx = tl.wrap(tx);

  Map<String, Long> expectedOld = new HashMap<>();

  while (updates.hasNext()) {
    org.apache.fluo.recipes.core.map.Update<String, Long> update = updates.next();

    if (update.getOldValue().isPresent()) {
      expectedOld.put("side:" + update.getKey(), update.getOldValue().get());
    }

    ttx.mutate().row("side:" + update.getKey()).col(DSCOL).set(update.getNewValue().get());
  }

  // get last values set to verify same as passed in old value
  Map<String, Long> actualOld = Maps.transformValues(
      ttx.get().rowsString(expectedOld.keySet()).columns(ImmutableSet.of(DSCOL)).toStringMap(),
      m -> m.get(DSCOL).toLong());

  MapDifference<String, Long> diff = Maps.difference(expectedOld, actualOld);

  Assert.assertTrue(diff.toString(), diff.areEqual());

  globalUpdates.incrementAndGet();
}

public Map<String, ValueDifference<String>> getPreferenceChanges() {
    Map<String, String> currentSettings = Maps.newHashMapWithExpectedSize(keys.length);
    for (String key : keys) {
        currentSettings.put(key, preferenceStore.getString(key));
    }
    MapDifference<String, String> mapDifference = Maps.difference(currentSettings, originalSettings);
    Map<String, ValueDifference<String>> entriesDiffering = mapDifference.entriesDiffering();
    return entriesDiffering;
}

@Override
public boolean equals(final Object other) {
    if (other instanceof ParametersWrapperBase
     && other.getClass() == this.getClass()) {
            ParametersWrapperBase<?> pw = (ParametersWrapperBase<?>)other;
            Map<String,String> otherParams = pw.getParams();
            MapDifference<String,String> diff = Maps.difference(_params,otherParams);
            return diff.entriesInCommon().size() == _params.size() && diff.entriesInCommon().size() == otherParams.size();
    }
    return false;
}

private static MapDifference<String, IndexMetadata> indexesDiff(Indexes before, Indexes after)
{
    Map<String, IndexMetadata> beforeMap = new HashMap<>();
    before.forEach(i -> beforeMap.put(i.name, i));

    Map<String, IndexMetadata> afterMap = new HashMap<>();
    after.forEach(i -> afterMap.put(i.name, i));

    return Maps.difference(beforeMap, afterMap);
}

private static MapDifference<String, TriggerMetadata> triggersDiff(Triggers before, Triggers after)
{
    Map<String, TriggerMetadata> beforeMap = new HashMap<>();
    before.forEach(t -> beforeMap.put(t.name, t));

    Map<String, TriggerMetadata> afterMap = new HashMap<>();
    after.forEach(t -> afterMap.put(t.name, t));

    return Maps.difference(beforeMap, afterMap);
}

public final boolean equalsTuple(Object oo, boolean print) {
  if (oo != null && oo instanceof MapTuple) {
    MapTuple t = (MapTuple)oo;
    MapDifference<String, Object> diff = Maps.difference(t._values, this._values);
    if (diff.areEqual()) {
      return true;
    } else {
      if (print) {
        System.err.println(diff);
      }
    }
  }
  return false;
}

static <K, V> void assertMapsEqual(
    Map<K, V> expected, Map<K, V> result, Equivalence<V> valueEquivalence) {
  MapDifference<K, V> difference = Maps.difference(expected, result, valueEquivalence);
  if (!difference.areEqual()) {
    StringBuilder builder = new StringBuilder();
    builder.append("Maps differ. ");
    builder.append("Entries differing: ").append(difference.entriesDiffering()).append("\n");
    builder.append("Missing entries: ").append(difference.entriesOnlyOnLeft()).append("\n");
    builder.append("Extra entries: ").append(difference.entriesOnlyOnRight()).append("\n");
    fail(builder.toString());
  }
}

@Test
public void entries_only_on_left() {

    MapDifference<Integer, Student> mapDifference = Maps.difference(
            geometryClass, gymClass);

    Map<Integer, Student> studentsOnLeft = mapDifference
            .entriesOnlyOnLeft();

    logger.info(studentsOnLeft);

    assertThat(studentsOnLeft, hasKey(new Integer(456)));
    assertThat(studentsOnLeft, hasKey(new Integer(912)));
}

@Test
public void entries_only_on_right() {

    MapDifference<Integer, Student> mapDifference = Maps.difference(
            geometryClass, gymClass);

    Map<Integer, Student> studentsOnTheRight = mapDifference
            .entriesOnlyOnRight();

    logger.info(studentsOnTheRight);

    assertThat(studentsOnTheRight, hasKey(new Integer(478)));
    assertThat(studentsOnTheRight, hasKey(new Integer(937)));
}

public void saveSheet(SheetData sheetData, Collection<SheetData.Property> properties) {
    if (properties != null && properties.contains(SheetData.Property.aliases)) {
        // check which alias changed
        // make a diff between the stored version of aliases and the new list

        MapDifference<Alias, AreaReference> diff = Maps.difference(previousAliases, sheetData.getAliases());
        previousAliases = new HashMap<Alias, AreaReference>(sheetData.getAliases());
        workbookAliasDependencyManager.refreshAliases(sheet.getName(), diff.entriesDiffering().keySet(), diff
                .entriesOnlyOnLeft().keySet());

    }
}