How to use

mergeWith

method

in

com.apollographql.apollo.cache.normalized.Record

/**
 * Commits new version of record to the history and invalidate snapshot version.
 */
Set<String> commit(Record record) {
 history.add(history.size(), record.clone());
 return snapshot.mergeWith(record);
}

 @NotNull @Override public Record apply(@NotNull Record record) {
  Record result = record.clone();
  result.mergeWith(journal.snapshot);
  return result;
 }
}).or(journal.snapshot.clone());

public Set<String> merge(Record apolloRecord) {
 final Record oldRecord = recordMap.get(apolloRecord.key());
 if (oldRecord == null) {
  recordMap.put(apolloRecord.key(), apolloRecord);
  return Collections.emptySet();
 } else {
  return oldRecord.mergeWith(apolloRecord);
 }
}

 /**
  * Lookups record by mutation id, if it's found removes it from the history and invalidates snapshot record.
  * Snapshot record is superposition of all record versions in the history.
  */
 Set<String> revert(UUID mutationId) {
  int recordIndex = -1;
  for (int i = 0; i < history.size(); i++) {
   if (mutationId.equals(history.get(i).mutationId())) {
    recordIndex = i;
    break;
   }
  }
  if (recordIndex == -1) {
   return Collections.emptySet();
  }
  Set<String> changedKeys = new HashSet<>();
  changedKeys.add(history.remove(recordIndex).key());
  for (int i = Math.max(0, recordIndex - 1); i < history.size(); i++) {
   Record record = history.get(i);
   if (i == Math.max(0, recordIndex - 1)) {
    snapshot = record.clone();
   } else {
    changedKeys.addAll(snapshot.mergeWith(record));
   }
  }
  return changedKeys;
 }
}

@NotNull
protected Set<String> performMerge(@NotNull final Record apolloRecord, @NotNull final CacheHeaders cacheHeaders) {
 final Record oldRecord = lruCache.getIfPresent(apolloRecord.key());
 if (oldRecord == null) {
  lruCache.put(apolloRecord.key(), apolloRecord);
  return apolloRecord.keys();
 } else {
  Set<String> changedKeys = oldRecord.mergeWith(apolloRecord);
  //re-insert to trigger new weight calculation
  lruCache.put(apolloRecord.key(), oldRecord);
  return changedKeys;
 }
}

/**
 * Commits new version of record to the history and invalidate snapshot version.
 */
Set<String> commit(Record record) {
 history.addLast(record.clone());
 return snapshot.mergeWith(record);
}

 @Nonnull @Override public Record apply(@Nonnull Record record) {
  Record result = record.clone();
  result.mergeWith(journal.snapshot);
  return result;
 }
}).or(journal.snapshot.clone());

 @Nonnull @Override public Record apply(@Nonnull Record record) {
  Record result = record.clone();
  result.mergeWith(journal.snapshot);
  return result;
 }
}).or(journal.snapshot.clone());

/**
 * Commits new version of record to the history and invalidate snapshot version.
 */
Set<String> commit(Record record) {
 history.addLast(record.clone());
 return snapshot.mergeWith(record);
}

public Set<String> merge(Record apolloRecord) {
 final Record oldRecord = recordMap.get(apolloRecord.key());
 if (oldRecord == null) {
  recordMap.put(apolloRecord.key(), apolloRecord);
  return Collections.emptySet();
 } else {
  return oldRecord.mergeWith(apolloRecord);
 }
}

public Set<String> merge(Record apolloRecord) {
 final Record oldRecord = recordMap.get(apolloRecord.key());
 if (oldRecord == null) {
  recordMap.put(apolloRecord.key(), apolloRecord);
  return Collections.emptySet();
 } else {
  return oldRecord.mergeWith(apolloRecord);
 }
}

 /**
  * Lookups record by mutation id, if it's found removes it from the history and invalidates snapshot record.
  * Snapshot record is superposition of all record versions in the history.
  */
 Set<String> revert(UUID mutationId) {
  int recordIndex = -1;
  for (int i = 0; i < history.size(); i++) {
   if (mutationId.equals(history.get(i).mutationId())) {
    recordIndex = i;
    break;
   }
  }
  if (recordIndex == -1) {
   return Collections.emptySet();
  }
  Set<String> changedKeys = new HashSet<>();
  changedKeys.add(history.remove(recordIndex).key());
  for (int i = Math.max(0, recordIndex - 1); i < history.size(); i++) {
   Record record = history.get(i);
   if (i == Math.max(0, recordIndex - 1)) {
    snapshot = record.clone();
   } else {
    changedKeys.addAll(snapshot.mergeWith(record));
   }
  }
  return changedKeys;
 }
}

 /**
  * Lookups record by mutation id, if it's found removes it from the history and invalidates snapshot record.
  * Snapshot record is superposition of all record versions in the history.
  */
 Set<String> revert(UUID mutationId) {
  int recordIndex = -1;
  for (int i = 0; i < history.size(); i++) {
   if (mutationId.equals(history.get(i).mutationId())) {
    recordIndex = i;
    break;
   }
  }
  if (recordIndex == -1) {
   return Collections.emptySet();
  }
  Set<String> changedKeys = new HashSet<>();
  changedKeys.add(history.remove(recordIndex).key());
  for (int i = Math.max(0, recordIndex - 1); i < history.size(); i++) {
   Record record = history.get(i);
   if (i == Math.max(0, recordIndex - 1)) {
    snapshot = record.clone();
   } else {
    changedKeys.addAll(snapshot.mergeWith(record));
   }
  }
  return changedKeys;
 }
}

@Nonnull @Override
public Set<String> merge(@Nonnull final Record apolloRecord, @Nonnull final CacheHeaders cacheHeaders) {
 if (cacheHeaders.hasHeader(GraphQLCacheHeaders.DO_NOT_STORE)) {
  return Collections.emptySet();
 }
 //noinspection ResultOfMethodCallIgnored
 nextCache().apply(new Action<NormalizedCache>() {
  @Override public void apply(@Nonnull NormalizedCache cache) {
   cache.merge(apolloRecord, cacheHeaders);
  }
 });
 final Record oldRecord = lruCache.getIfPresent(apolloRecord.key());
 if (oldRecord == null) {
  lruCache.put(apolloRecord.key(), apolloRecord);
  return Collections.emptySet();
 } else {
  Set<String> changedKeys = oldRecord.mergeWith(apolloRecord);
  //re-insert to trigger new weight calculation
  lruCache.put(apolloRecord.key(), oldRecord);
  return changedKeys;
 }
}

@Nonnull @Override
public Set<String> merge(@Nonnull final Record apolloRecord, @Nonnull final CacheHeaders cacheHeaders) {
 if (cacheHeaders.hasHeader(GraphQLCacheHeaders.DO_NOT_STORE)) {
  return Collections.emptySet();
 }
 //noinspection ResultOfMethodCallIgnored
 nextCache().apply(new Action<NormalizedCache>() {
  @Override public void apply(@Nonnull NormalizedCache cache) {
   cache.merge(apolloRecord, cacheHeaders);
  }
 });
 final Record oldRecord = lruCache.getIfPresent(apolloRecord.key());
 if (oldRecord == null) {
  lruCache.put(apolloRecord.key(), apolloRecord);
  return Collections.emptySet();
 } else {
  Set<String> changedKeys = oldRecord.mergeWith(apolloRecord);
  //re-insert to trigger new weight calculation
  lruCache.put(apolloRecord.key(), oldRecord);
  return changedKeys;
 }
}

@Nonnull public Set<String> merge(@Nonnull final Record apolloRecord, @Nonnull final CacheHeaders cacheHeaders) {
 if (cacheHeaders.hasHeader(DO_NOT_STORE)) {
  return Collections.emptySet();
 }
 //noinspection ResultOfMethodCallIgnored
 Optional<NormalizedCache> normalizedCacheOptional = nextCache().apply(new Action<NormalizedCache>() {
  @Override
  public void apply(@Nonnull NormalizedCache cache) {
   cache.merge(apolloRecord, cacheHeaders);
  }
 });
 Optional<Record> optionalOldRecord = selectRecordForKey(apolloRecord.key());
 Set<String> changedKeys;
 if (!optionalOldRecord.isPresent()) {
  createRecord(apolloRecord.key(), recordFieldAdapter.toJson(apolloRecord.fields()));
  changedKeys = Collections.emptySet();
 } else {
  Record oldRecord = optionalOldRecord.get();
  changedKeys = oldRecord.mergeWith(apolloRecord);
  if (!changedKeys.isEmpty()) {
   updateRecord(oldRecord.key(), recordFieldAdapter.toJson(oldRecord.fields()));
  }
 }
 return changedKeys;
}