return resource == null ? null : resource.getMetaData().getLastModified().getTime();
    }

    @Override
    public boolean isUpToDate(String resource, @Nullable Long oldValue) {
        String[] parts = resource.split(";");
        if (!rootUriAsString.equals(parts[0])) {
            // not the same provider
            return false;
        }

   */
  @CanIgnoreReturnValue
  public final double getAndAccumulate(int i, double x, DoubleBinaryOperator accumulatorFunction) {
    checkNotNull(accumulatorFunction);
    return getAndUpdate(i, oldValue -> accumulatorFunction.applyAsDouble(oldValue, x));
  }

  /**
   * Atomically updates the element at index {@code i} with the results of applying the given
   * function to the current and given values.
   *

            }
        }
        return newMap;
    }

    protected XmlNode transform(XmlNode node) {
        if (node != null) {
            String oldValue = node.getValue();
            String newValue = transform(oldValue);
            Map<String, String> oldAttrs = node.getAttributes();
            Map<String, String> newAttrs = transform(oldAttrs, this::transform);

  public V put(K key, V value) {
    checkNotNull(key);
    checkNotNull(value);
    Timestamped<V> oldValue = cachingHashMap.put(key, new Timestamped<V>(value, ticker));
    if (oldValue == null) {
      return null;
    }
    alertListenerIfPresent(key, oldValue.getValue(), RemovalCause.REPLACED);
    return oldValue.getValue();
  }

  @CanIgnoreReturnValue
  @Override
  public V remove(Object key) {

      @ParametricNullness C column,
      V value,
      BinaryOperator<V> mergeFunction) {
    checkNotNull(value);
    V oldValue = table.get(row, column);
    if (oldValue == null) {
      table.put(row, column, value);
    } else {
      V newValue = mergeFunction.apply(oldValue, value);
      if (newValue == null) {
        table.remove(row, column);
      } else {
        table.put(row, column, newValue);

internal
class VintageEnvironmentChangeTracker : EnvironmentChangeTracker {

    override fun systemPropertyChanged(key: Any, value: Any?, consumer: String?) {}

    override fun systemPropertyLoaded(key: Any, value: Any?, oldValue: Any?) {}

    override fun systemPropertyOverridden(key: Any) {}

  }

  public void testPutAndGetInstance() {
    assertNull(map.putInstance(Integer.class, Integer.valueOf(5)));

    Integer oldValue = map.putInstance(Integer.class, Integer.valueOf(7));
    assertEquals(5, (int) oldValue);

    Integer newValue = map.getInstance(Integer.class);
    assertEquals(7, (int) newValue);
    assertEquals(7, (int) map.getInstance(TypeToken.of(Integer.class)));

    }

    public LoadingValueReference(@CheckForNull ValueReference<K, V> oldValue) {
      this.oldValue = (oldValue == null) ? LocalCache.unset() : oldValue;
    }

    @Override
    public boolean isLoading() {
      return true;
    }

    @Override
    public boolean isActive() {
      return oldValue.isActive();
    }

    @Override
    public int getWeight() {

    /**
     * System properties loaded from included build/buildSrc gradle.properties
     * */
    void systemPropertyLoaded(Object key, @Nullable Object value, @Nullable Object oldValue);

    /**
     * System properties overridden by passing CLI argument
     * */
    void systemPropertyOverridden(Object key);

      cellRowIndices[i] = requireNonNull(rowIndex.get(rowKey));
      Map<C, V> thisRow = requireNonNull(rows.get(rowKey));
      cellColumnInRowIndices[i] = thisRow.size();
      V oldValue = thisRow.put(columnKey, value);
      checkNoDuplicate(rowKey, columnKey, oldValue, value);
      requireNonNull(columns.get(columnKey)).put(rowKey, value);
    }
    this.cellRowIndices = cellRowIndices;
    this.cellColumnInRowIndices = cellColumnInRowIndices;