Interface LocalAsyncCache<K,​V>

    • Field Summary

      Fields 
      Modifier and Type Field Description
      static java.util.logging.Logger logger  
    • Method Summary

      All Methods Instance Methods Abstract Methods Default Methods 
      Modifier and Type Method Description
      LocalCache<K,​java.util.concurrent.CompletableFuture<V>> cache()
      Returns the backing LocalCache data store.
      default java.util.concurrent.CompletableFuture<java.util.Map<K,​V>> composeResult​(java.util.Map<K,​java.util.concurrent.CompletableFuture<V>> futures)
      Returns a future that waits for all of the dependent futures to complete and returns the combined mapping if successful.
      default java.util.concurrent.CompletableFuture<V> get​(@NonNull K key, @NonNull java.util.function.Function<? super K,​? extends V> mappingFunction)
      Returns the future associated with key in this cache, obtaining that value from mappingFunction if necessary.
      default java.util.concurrent.CompletableFuture<V> get​(K key, java.util.function.BiFunction<? super K,​java.util.concurrent.Executor,​java.util.concurrent.CompletableFuture<V>> mappingFunction)
      Returns the future associated with key in this cache, obtaining that value from mappingFunction if necessary.
      default java.util.concurrent.CompletableFuture<V> get​(K key, java.util.function.BiFunction<? super K,​java.util.concurrent.Executor,​java.util.concurrent.CompletableFuture<V>> mappingFunction, boolean recordStats)  
      default java.util.concurrent.CompletableFuture<java.util.Map<K,​V>> getAll​(java.lang.Iterable<? extends @NonNull K> keys, java.util.function.BiFunction<java.lang.Iterable<? extends K>,​java.util.concurrent.Executor,​java.util.concurrent.CompletableFuture<java.util.Map<K,​V>>> mappingFunction)
      Returns the future of a map of the values associated with keys, creating or retrieving those values if necessary.
      default java.util.concurrent.CompletableFuture<java.util.Map<K,​V>> getAll​(java.lang.Iterable<? extends @NonNull K> keys, java.util.function.Function<java.lang.Iterable<? extends K>,​java.util.Map<K,​V>> mappingFunction)
      Returns the future of a map of the values associated with keys, creating or retrieving those values if necessary.
      default @Nullable java.util.concurrent.CompletableFuture<V> getIfPresent​(@NonNull java.lang.Object key)
      Returns the future associated with key in this cache, or null if there is no cached future for key.
      default void handleCompletion​(K key, java.util.concurrent.CompletableFuture<V> valueFuture, long startTime, boolean recordMiss)  
      Policy<K,​V> policy()
      Returns the policy supported by this implementation and its configuration.
      default void put​(K key, java.util.concurrent.CompletableFuture<V> valueFuture)
      Associates value with key in this cache.
    • Field Detail

      • logger

        static final java.util.logging.Logger logger
    • Method Detail

      • cache

        LocalCache<K,​java.util.concurrent.CompletableFuture<V>> cache()
        Returns the backing LocalCache data store.
      • policy

        Policy<K,​V> policy()
        Returns the policy supported by this implementation and its configuration.
      • getIfPresent

        default @Nullable java.util.concurrent.CompletableFuture<V> getIfPresent​(@NonNull java.lang.Object key)
        Description copied from interface: AsyncCache
        Returns the future associated with key in this cache, or null if there is no cached future for key.
        Specified by:
        getIfPresent in interface AsyncCache<K,​V>
        Parameters:
        key - key whose associated value is to be returned
        Returns:
        the current (existing or computed) future value to which the specified key is mapped, or null if this cache contains no mapping for the key
      • get

        default java.util.concurrent.CompletableFuture<V> get​(@NonNull K key,
                                                              @NonNull java.util.function.Function<? super K,​? extends V> mappingFunction)
        Description copied from interface: AsyncCache
        Returns the future associated with key in this cache, obtaining that value from mappingFunction if necessary. This method provides a simple substitute for the conventional "if cached, return; otherwise create, cache and return" pattern.

        If the specified key is not already associated with a value, attempts to compute its value asynchronously and enters it into this cache unless null. The entire method invocation is performed atomically, so the function is applied at most once per key. If the asynchronous computation fails, the entry will be automatically removed from this cache.

        Warning: as with CacheLoader.load(K), mappingFunction must not attempt to update any other mappings of this cache.

        Specified by:
        get in interface AsyncCache<K,​V>
        Parameters:
        key - key with which the specified value is to be associated
        mappingFunction - the function to asynchronously compute a value
        Returns:
        the current (existing or computed) future value associated with the specified key
      • get

        default java.util.concurrent.CompletableFuture<V> get​(K key,
                                                              java.util.function.BiFunction<? super K,​java.util.concurrent.Executor,​java.util.concurrent.CompletableFuture<V>> mappingFunction)
        Description copied from interface: AsyncCache
        Returns the future associated with key in this cache, obtaining that value from mappingFunction if necessary. This method provides a simple substitute for the conventional "if cached, return; otherwise create, cache and return" pattern.

        If the specified key is not already associated with a value, attempts to compute its value asynchronously and enters it into this cache unless null. The entire method invocation is performed atomically, so the function is applied at most once per key. If the asynchronous computation fails, the entry will be automatically removed from this cache.

        Warning: as with CacheLoader.load(K), mappingFunction must not attempt to update any other mappings of this cache.

        Specified by:
        get in interface AsyncCache<K,​V>
        Parameters:
        key - key with which the specified value is to be associated
        mappingFunction - the function to asynchronously compute a value
        Returns:
        the current (existing or computed) future value associated with the specified key
      • get

        default java.util.concurrent.CompletableFuture<V> get​(K key,
                                                              java.util.function.BiFunction<? super K,​java.util.concurrent.Executor,​java.util.concurrent.CompletableFuture<V>> mappingFunction,
                                                              boolean recordStats)
      • getAll

        default java.util.concurrent.CompletableFuture<java.util.Map<K,​V>> getAll​(java.lang.Iterable<? extends @NonNull K> keys,
                                                                                        java.util.function.Function<java.lang.Iterable<? extends K>,​java.util.Map<K,​V>> mappingFunction)
        Description copied from interface: AsyncCache
        Returns the future of a map of the values associated with keys, creating or retrieving those values if necessary. The returned map contains entries that were already cached, combined with newly loaded entries; it will never contain null keys or values. If the any of the asynchronous computations fail, those entries will be automatically removed from this cache.

        A single request to the mappingFunction is performed for all keys which are not already present in the cache. If another call to AsyncCache.get(K, java.util.function.Function<? super K, ? extends V>) tries to load the value for a key in keys, that thread retrieves a future that is completed by this bulk computation. Any loaded values for keys that were not specifically requested will not be returned, but will be stored in the cache. Note that multiple threads can concurrently load values for distinct keys.

        Note that duplicate elements in keys, as determined by Object.equals(java.lang.Object), will be ignored.

        Specified by:
        getAll in interface AsyncCache<K,​V>
        Parameters:
        keys - the keys whose associated values are to be returned
        mappingFunction - the function to asynchronously compute the values
        Returns:
        the future containing an unmodifiable mapping of keys to values for the specified keys in this cache
      • getAll

        default java.util.concurrent.CompletableFuture<java.util.Map<K,​V>> getAll​(java.lang.Iterable<? extends @NonNull K> keys,
                                                                                        java.util.function.BiFunction<java.lang.Iterable<? extends K>,​java.util.concurrent.Executor,​java.util.concurrent.CompletableFuture<java.util.Map<K,​V>>> mappingFunction)
        Description copied from interface: AsyncCache
        Returns the future of a map of the values associated with keys, creating or retrieving those values if necessary. The returned map contains entries that were already cached, combined with newly loaded entries; it will never contain null keys or values. If the any of the asynchronous computations fail, those entries will be automatically removed from this cache.

        A single request to the mappingFunction is performed for all keys which are not already present in the cache. If another call to AsyncCache.get(K, java.util.function.Function<? super K, ? extends V>) tries to load the value for a key in keys, that thread retrieves a future that is completed by this bulk computation. Any loaded values for keys that were not specifically requested will not be returned, but will be stored in the cache. Note that multiple threads can concurrently load values for distinct keys.

        Note that duplicate elements in keys, as determined by Object.equals(java.lang.Object), will be ignored.

        Specified by:
        getAll in interface AsyncCache<K,​V>
        Parameters:
        keys - the keys whose associated values are to be returned
        mappingFunction - the function to asynchronously compute the values
        Returns:
        the future containing an unmodifiable mapping of keys to values for the specified keys in this cache
      • composeResult

        default java.util.concurrent.CompletableFuture<java.util.Map<K,​V>> composeResult​(java.util.Map<K,​java.util.concurrent.CompletableFuture<V>> futures)
        Returns a future that waits for all of the dependent futures to complete and returns the combined mapping if successful. If any future fails then it is automatically removed from the cache if still present.
      • put

        default void put​(K key,
                         java.util.concurrent.CompletableFuture<V> valueFuture)
        Description copied from interface: AsyncCache
        Associates value with key in this cache. If the cache previously contained a value associated with key, the old value is replaced by value. If the asynchronous computation fails, the entry will be automatically removed.

        Prefer AsyncCache.get(Object, Function) when using the conventional "if cached, return; otherwise create, cache and return" pattern.

        Specified by:
        put in interface AsyncCache<K,​V>
        Parameters:
        key - key with which the specified value is to be associated
        valueFuture - value to be associated with the specified key
      • handleCompletion

        default void handleCompletion​(K key,
                                      java.util.concurrent.CompletableFuture<V> valueFuture,
                                      long startTime,
                                      boolean recordMiss)