Class LoadingValueReference

output/java_guava/1.4.17/LocalCache.java:3540–3660

  }

  static class LoadingValueReference<K, V> implements ValueReference<K, V> {
    volatile ValueReference<K, V> oldValue;

    // TODO(fry): rename get, then extend AbstractFuture instead of containing SettableFuture
    final SettableFuture<V> futureValue = SettableFuture.create();
    final Stopwatch stopwatch = Stopwatch.createUnstarted();


    public LoadingValueReference() {
      this(LocalCache.<K, V>unset());
    }


    public LoadingValueReference(ValueReference<K, V> oldValue) {
      this.oldValue = oldValue;
    }

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

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

    @Override
    public int getWeight() {
      return oldValue.getWeight();
    }


    public boolean set(@Nullable V newValue) {
             return futureValue.set(newValue);
           }


    public boolean setException(Throwable t) {
             return futureValue.setException(t);
           }

    private ListenableFuture<V> fullyFailedFuture(Throwable t) {
              return Futures.immediateFailedFuture(t);
            }

    @Override
    public void notifyNewValue(@Nullable V newValue) {
      if (newValue != null) {
        // The pending load was clobbered by a manual write.
        // Unblock all pending gets, and have them return the new value.
        set(newValue);
      } else {
        // The pending load was removed. Delay notifications until loading completes.
        oldValue = unset();
      }

      // TODO(fry): could also cancel loading if we had a handle on its future