Class LoadingValueReference

output/java_guava/1.4.13/LocalCache.java:3525–3644

        }

        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
    }