Package com.tangosol.net

Interface AsyncNamedMap<K,V>

Type Parameters:
K - the type of the map entry keys
V - the type of the map entry values
All Known Subinterfaces:
AsyncNamedCache<K,V>
public interface AsyncNamedMap<K,V>
Asynchronous NamedMap.
Since:
20.06
Author:
Aleks Seovic 2020.06.06

  • Field Details

  • Method Details

    • getNamedMap

      NamedMap<K,V> getNamedMap()
      Return the NamedCache instance this AsyncNamedCache is based on.
      Returns:
      the NamedCache instance this AsyncNamedCache is based on

    • get

      default CompletableFuture<V> get(K key)
      Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
      Parameters:
      key - the key whose associated value is to be returned
      Returns:
      a CompletableFuture for the value to which the specified key is mapped

    • getAll

      default CompletableFuture<Map<K,V>> getAll(Collection<? extends K> colKeys)
      Get all the specified keys, if they are in the map. For each key that is in the map, that key and its corresponding value will be placed in the map that is returned by this method. The absence of a key in the returned map indicates that it was not in the map, which may imply (for maps that can load behind the scenes) that the requested data could not be loaded.
      Parameters:
      colKeys - a collection of keys that may be in the named map
      Returns:
      a CompletableFuture for a Map of keys to values for the specified keys passed in colKeys

    • getAll

      default CompletableFuture<Map<K,V>> getAll(Filter<?> filter)
      Get all the entries that satisfy the specified filter. For each entry that satisfies the filter, the key and its corresponding value will be placed in the map that is returned by this method.
      Parameters:
      filter - a Filter that determines the set of entries to return
      Returns:
      a CompletableFuture for a Map of keys to values for the specified filter

    • getAll

      default CompletableFuture<Void> getAll(Filter<?> filter, BiConsumer<? super K,? super V> callback)
      Get all the entries that satisfy the specified filter. For each entry that satisfies the filter, the key and its corresponding value will be placed in the map that is returned by this method.
      Parameters:
      filter - a Filter that determines the set of entries to return
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture for a Map of keys to values for the specified filter

    • getAll

      default CompletableFuture<Void> getAll(Filter<?> filter, Consumer<? super Map.Entry<? extends K,? extends V>> callback)
      Get all the entries that satisfy the specified filter. For each entry that satisfies the filter, the key and its corresponding value will be placed in the map that is returned by this method.
      Parameters:
      filter - a Filter that determines the set of entries to return
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture for a Map of keys to values for the specified filter

    • getAll

      default CompletableFuture<Void> getAll(Collection<? extends K> colKeys, BiConsumer<? super K,? super V> callback)
      Stream the entries associated with the specified keys to the provided callback.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Parameters:
      colKeys - a collection of keys that may be in the named map
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture that can be used to determine whether the operation completed

    • getAll

      default CompletableFuture<Void> getAll(Collection<? extends K> colKeys, Consumer<? super Map.Entry<? extends K,? extends V>> callback)
      Stream the entries associated with the specified keys to the provided callback.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Parameters:
      colKeys - a collection of keys that may be in the named map
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture that can be used to determine whether the operation completed

    • put

      default CompletableFuture<Void> put(K key, V value)
      Associates the specified value with the specified key in this map. If the map previously contained a mapping for this key, the old value is replaced.

      Invoking this method is equivalent to the following call: 

           put(oKey, oValue, CacheMap.EXPIRY_DEFAULT);
      Parameters:
      key - key with which the specified value is to be associated
      value - value to be associated with the specified key
      Returns:
      a CompletableFuture

    • putAll

      default CompletableFuture<Void> putAll(Map<? extends K,? extends V> map)
      Copies all of the mappings from the specified map to this map.
      Parameters:
      map - mappings to be added to this map
      Returns:
      a CompletableFuture

    • remove

      default CompletableFuture<V> remove(K key)
      Removes the mapping for a key from this map if it is present.
      Parameters:
      key - key whose mapping is to be removed from the map
      Returns:
      a CompletableFuture for the previous value associated with the key

    • removeAll

      default CompletableFuture<Void> removeAll(Collection<? extends K> colKeys)
      Removes all of the mappings from the specified keys from this map, if they are present in the map.
      Parameters:
      colKeys - a collection of keys that may be in the named map
      Returns:
      a CompletableFuture

    • removeAll

      default CompletableFuture<Void> removeAll(Filter<?> filter)
      Removes all of the mappings that satisfy the specified filter from this map.
      Parameters:
      filter - a Filter that determines the set of entries to remove
      Returns:
      a CompletableFuture

    • keySet

      default CompletableFuture<Set<K>> keySet()
      Return a set view of all the keys contained in this map.

      NOTE: The returned Set will contain all the keys from the cache, which for a large cache could be a very large set consuming a large amount of memory. In this case it is better to use keySet(Consumer)

      Returns:
      a complete set of keys for this map

    • keySet

      default CompletableFuture<Set<K>> keySet(Filter<?> filter)
      Return a set view of the keys contained in this map for entries that satisfy the criteria expressed by the filter.
      Parameters:
      filter - the Filter object representing the criteria that the entries of this map should satisfy
      Returns:
      a set of keys for entries that satisfy the specified criteria

    • keySet

      default CompletableFuture<Void> keySet(Consumer<? super K> callback)
      Stream the keys of all the entries contained in this map to the provided callback.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Parameters:
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture that can be used to determine whether the operation completed

    • keySet

      default CompletableFuture<Void> keySet(Filter<?> filter, Consumer<? super K> callback)
      Stream the keys for the entries that satisfy the specified filter to the provided callback.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Parameters:
      filter - the Filter object representing the criteria that the entries of this map should satisfy
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture that can be used to determine whether the operation completed

    • entrySet

      default CompletableFuture<Set<Map.Entry<K,V>>> entrySet()
      Return a set view of all the entries contained in this map. Each element in the returned set is a Map.Entry.
      Returns:
      a set of all entries in this map

    • entrySet

      default CompletableFuture<Set<Map.Entry<K,V>>> entrySet(Filter<?> filter)
      Return a set view of the entries contained in this map that satisfy the criteria expressed by the filter. Each element in the returned set is a Map.Entry.
      Parameters:
      filter - the Filter object representing the criteria that the entries of this map should satisfy
      Returns:
      a set of entries that satisfy the specified criteria

    • entrySet

      default CompletableFuture<Set<Map.Entry<K,V>>> entrySet(Filter<?> filter, Comparator<?> comparator)
      Return a set view of the entries contained in this map that satisfy the criteria expressed by the filter. Each element in the returned set is a Map.Entry. It is further guaranteed that its iterator will traverse the set in such a way that the entry values come up in ascending order, sorted by the specified Comparator or according to the natural ordering (see Comparable).
      Parameters:
      filter - the Filter object representing the criteria that the entries of this map should satisfy
      comparator - the Comparator object which imposes an ordering on entries in the resulting set; or null if the entries' values natural ordering should be used
      Returns:
      a set of entries that satisfy the specified criteria

    • entrySet

      default CompletableFuture<Void> entrySet(BiConsumer<? super K,? super V> callback)
      Stream all the entries contained in this map to the provided callback.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Parameters:
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture that can be used to determine whether the operation completed

    • entrySet

      default CompletableFuture<Void> entrySet(Consumer<? super Map.Entry<? extends K,? extends V>> callback)
      Stream all the entries contained in this map to the provided callback.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Parameters:
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture that can be used to determine whether the operation completed

    • entrySet

      default CompletableFuture<Void> entrySet(Filter<?> filter, BiConsumer<? super K,? super V> callback)
      Stream the entries that satisfy the specified filter to the provided callback.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Parameters:
      filter - the Filter object representing the criteria that the entries of this map should satisfy
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture that can be used to determine whether the operation completed

    • entrySet

      default CompletableFuture<Void> entrySet(Filter<?> filter, Consumer<? super Map.Entry<? extends K,? extends V>> callback)
      Stream the entries that satisfy the specified filter to the provided callback.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Parameters:
      filter - the Filter object representing the criteria that the entries of this map should satisfy
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture that can be used to determine whether the operation completed

    • values

      default CompletableFuture<Collection<V>> values()
      Return a collection of all the values contained in this map.
      Returns:
      a collection of all the values in this map

    • values

      default CompletableFuture<Collection<V>> values(Filter<?> filter)
      Return a collection of the values contained in this map that satisfy the criteria expressed by the filter.
      Parameters:
      filter - the Filter object representing the criteria that the entries of this map should satisfy
      Returns:
      a collection of values for entries that satisfy the specified criteria

    • values

      default CompletableFuture<Collection<V>> values(Filter<?> filter, Comparator<? super V> comparator)
      Return a collection of the values contained in this map that satisfy the criteria expressed by the filter.
      Parameters:
      filter - the Filter object representing the criteria that the entries of this map should satisfy
      comparator - the Comparator object which imposes an ordering on entries in the resulting set; or null if the entries' values natural ordering should be used
      Returns:
      a collection of values for entries that satisfy the specified criteria

    • values

      default CompletableFuture<Void> values(Consumer<? super V> callback)
      Stream the values of all the entries contained in this map to the provided callback.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Parameters:
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture that can be used to determine whether the operation completed

    • values

      default CompletableFuture<Void> values(Filter<?> filter, Consumer<? super V> callback)
      Stream the values for the entries that satisfy the specified filter to the provided callback.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Parameters:
      filter - the Filter object representing the criteria that the entries of this map should satisfy
      callback - a consumer of results as they become available
      Returns:
      a CompletableFuture that can be used to determine whether the operation completed

    • invoke

      <R> CompletableFuture<R> invoke(K key, InvocableMap.EntryProcessor<K,V,R> processor)
      Invoke the passed EntryProcessor against the Entry specified by the passed key asynchronously, returning a CompletableFuture that can be used to obtain the result of the invocation.
      Type Parameters:
      R - the type of value returned by the EntryProcessor
      Parameters:
      key - the key to process; it is not required to exist within the Map
      processor - the EntryProcessor to use to process the specified key
      Returns:
      a CompletableFuture that can be used to obtain the result of the invocation

    • invokeAll

      default <R> CompletableFuture<Map<K,R>> invokeAll(InvocableMap.EntryProcessor<K,V,R> processor)
      Invoke the passed EntryProcessor against all the entries asynchronously, returning a CompletableFuture that can be used to obtain the result of the invocation for each entry.
      Type Parameters:
      R - the type of value returned by the EntryProcessor
      Parameters:
      processor - the EntryProcessor to use to process the specified keys
      Returns:
      a CompletableFuture that can be used to obtain the result of the invocation for each entry

    • invokeAll

      <R> CompletableFuture<Map<K,R>> invokeAll(Collection<? extends K> collKeys, InvocableMap.EntryProcessor<K,V,R> processor)
      Invoke the passed EntryProcessor against the entries specified by the passed keys asynchronously, returning a CompletableFuture that can be used to obtain the result of the invocation for each entry.
      Type Parameters:
      R - the type of value returned by the EntryProcessor
      Parameters:
      collKeys - the keys to process; these keys are not required to exist within the Map
      processor - the EntryProcessor to use to process the specified keys
      Returns:
      a CompletableFuture that can be used to obtain the result of the invocation for each entry

    • invokeAll

      <R> CompletableFuture<Map<K,R>> invokeAll(Filter<?> filter, InvocableMap.EntryProcessor<K,V,R> processor)
      Invoke the passed EntryProcessor against the set of entries that are selected by the given Filter asynchronously, returning a CompletableFuture that can be used to obtain the result of the invocation for each entry.
      Type Parameters:
      R - the type of value returned by the EntryProcessor
      Parameters:
      filter - a Filter that results in the set of keys to be processed
      processor - the EntryProcessor to use to process the specified keys
      Returns:
      a CompletableFuture that can be used to obtain the result of the invocation for each entry

    • invokeAll

      default <R> CompletableFuture<Void> invokeAll(InvocableMap.EntryProcessor<K,V,R> processor, Consumer<? super Map.Entry<? extends K,? extends R>> callback)
      Invoke the passed EntryProcessor against all the entries asynchronously, returning a CompletableFuture that can be used to determine if the operation completed successfully.

      Instead of collecting and returning the complete result, this method will stream partial results of the processor execution to the specified partial result callback, which allows for a much lower memory overhead.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Type Parameters:
      R - the type of value returned by the EntryProcessor
      Parameters:
      processor - the EntryProcessor to use to process the specified keys
      callback - a user-defined callback that will be called for each partial result
      Returns:
      a CompletableFuture that can be used to determine if the operation completed successfully

    • invokeAll

      default <R> CompletableFuture<Void> invokeAll(InvocableMap.EntryProcessor<K,V,R> processor, BiConsumer<? super K,? super R> callback)
      Invoke the passed EntryProcessor against all the entries asynchronously, returning a CompletableFuture that can be used to determine if the operation completed successfully.

      Instead of collecting and returning the complete result, this method will stream partial results of the processor execution to the specified partial result callback, which allows for a much lower memory overhead.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Type Parameters:
      R - the type of value returned by the EntryProcessor
      Parameters:
      processor - the EntryProcessor to use to process the specified keys
      callback - a user-defined callback that will be called for each partial result
      Returns:
      a CompletableFuture that can be used to determine if the operation completed successfully

    • invokeAll

      <R> CompletableFuture<Void> invokeAll(Collection<? extends K> collKeys, InvocableMap.EntryProcessor<K,V,R> processor, Consumer<? super Map.Entry<? extends K,? extends R>> callback)
      Invoke the passed EntryProcessor against the entries specified by the passed keys asynchronously, returning a CompletableFuture that can be used to determine if the operation completed successfully.

      Instead of collecting and returning the complete result, this method will stream partial results of the processor execution to the specified partial result callback, which allows for a much lower memory overhead.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Type Parameters:
      R - the type of value returned by the EntryProcessor
      Parameters:
      collKeys - the keys to process; these keys are not required to exist within the Map
      processor - the EntryProcessor to use to process the specified keys
      callback - a user-defined callback that will be called for each partial result
      Returns:
      a CompletableFuture that can be used to determine if the operation completed successfully

    • invokeAll

      default <R> CompletableFuture<Void> invokeAll(Collection<? extends K> collKeys, InvocableMap.EntryProcessor<K,V,R> processor, BiConsumer<? super K,? super R> callback)
      Invoke the passed EntryProcessor against the entries specified by the passed keys asynchronously, returning a CompletableFuture that can be used to determine if the operation completed successfully.

      Instead of collecting and returning the complete result, this method will stream partial results of the processor execution to the specified partial result callback, which allows for a much lower memory overhead.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Type Parameters:
      R - the type of value returned by the EntryProcessor
      Parameters:
      collKeys - the keys to process; these keys are not required to exist within the Map
      processor - the EntryProcessor to use to process the specified keys
      callback - a user-defined callback that will be called for each partial result
      Returns:
      a CompletableFuture that can be used to determine if the operation completed successfully

    • invokeAll

      <R> CompletableFuture<Void> invokeAll(Filter<?> filter, InvocableMap.EntryProcessor<K,V,R> processor, Consumer<? super Map.Entry<? extends K,? extends R>> callback)
      Invoke the passed EntryProcessor against the set of entries that are selected by the given Filter asynchronously, returning a CompletableFuture that can be used to determine if the operation completed successfully.

      Instead of collecting and returning the complete result, this method will stream partial results of the processor execution to the specified partial result callback, which allows for a much lower memory overhead.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Type Parameters:
      R - the type of value returned by the EntryProcessor
      Parameters:
      filter - a Filter that results in the set of keys to be processed
      processor - the EntryProcessor to use to process the specified keys
      callback - a user-defined callback that will be called for each partial result
      Returns:
      a CompletableFuture that can be used to determine if the operation completed successfully

    • invokeAll

      default <R> CompletableFuture<Void> invokeAll(Filter<?> filter, InvocableMap.EntryProcessor<K,V,R> processor, BiConsumer<? super K,? super R> callback)
      Invoke the passed EntryProcessor against the set of entries that are selected by the given Filter asynchronously, returning a CompletableFuture that can be used to determine if the operation completed successfully.

      Instead of collecting and returning the complete result, this method will stream partial results of the processor execution to the specified partial result callback, which allows for a much lower memory overhead.

      Note: the callback implementation must be thread-safe as it may be called by multiple worker threads in cases where Coherence splits the operation over multiple partitions.

      Type Parameters:
      R - the type of value returned by the EntryProcessor
      Parameters:
      filter - a Filter that results in the set of keys to be processed
      processor - the EntryProcessor to use to process the specified keys
      callback - a user-defined callback that will be called for each partial result
      Returns:
      a CompletableFuture that can be used to determine if the operation completed successfully

    • aggregate

      default <R> CompletableFuture<R> aggregate(InvocableMap.EntryAggregator<? super K,? super V,R> aggregator)
      Perform an aggregating operation asynchronously against all the entries.
      Type Parameters:
      R - the type of value returned by the EntryAggregator
      Parameters:
      aggregator - the EntryAggregator that is used to aggregate across the specified entries of this Map
      Returns:
      a CompletableFuture that can be used to obtain the result of the aggregation

    • aggregate

      <R> CompletableFuture<R> aggregate(Collection<? extends K> collKeys, InvocableMap.EntryAggregator<? super K,? super V,R> aggregator)
      Perform an aggregating operation asynchronously against the entries specified by the passed keys.
      Type Parameters:
      R - the type of value returned by the EntryAggregator
      Parameters:
      collKeys - the Collection of keys that specify the entries within this Map to aggregate across
      aggregator - the EntryAggregator that is used to aggregate across the specified entries of this Map
      Returns:
      a CompletableFuture that can be used to obtain the result of the aggregation

    • aggregate

      <R> CompletableFuture<R> aggregate(Filter<?> filter, InvocableMap.EntryAggregator<? super K,? super V,R> aggregator)
      Perform an aggregating operation asynchronously against the set of entries that are selected by the given Filter.
      Type Parameters:
      R - the type of value returned by the EntryAggregator
      Parameters:
      filter - the Filter that is used to select entries within this Map to aggregate across
      aggregator - the EntryAggregator that is used to aggregate across the selected entries of this Map
      Returns:
      a CompletableFuture that can be used to obtain the result of the aggregation

    • size

      default CompletableFuture<Integer> size()
      Returns the number of key-value mappings in this map. If the map contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
      Returns:
      the number of key-value mappings in this map

    • isEmpty

      default CompletableFuture<Boolean> isEmpty()
      Returns true if this map contains no key-value mappings.
      Returns:
      true if this map contains no key-value mappings

    • clear

      default CompletableFuture<Void> clear()
      Removes all of the mappings from this map. The map will be empty after this operation completes.

    • containsKey

      default CompletableFuture<Boolean> containsKey(K key)
      Returns true if this map contains a mapping for the specified key. More formally, returns true if and only if this map contains a mapping for a key k such that (key==null ? k==null : key.equals(k)). (There can be at most one such mapping.)
      Parameters:
      key - key whose presence in this map is to be tested
      Returns:
      true if this map contains a mapping for the specified key

    • getOrDefault

      default CompletableFuture<V> getOrDefault(K key, V valueDefault)
      Returns the value to which the specified key is mapped, or valueDefault if this map contains no mapping for the key.
      Parameters:
      key - the key whose associated value is to be returned
      valueDefault - the default mapping of the key
      Returns:
      the value to which the specified key is mapped, or valueDefault if this map contains no mapping for the key

    • putIfAbsent

      default CompletableFuture<V> putIfAbsent(K key, V value)
      If the specified key is not already associated with a value (or is mapped to null) associates it with the given value and returns null, else returns the current value.
      Parameters:
      key - key with which the specified value is to be associated
      value - value to be associated with the specified key
      Returns:
      the previous value associated with the specified key, or null if there was no mapping for the key. (A null return can also indicate that the map previously associated null with the key, if the implementation supports null values.)

    • remove

      default CompletableFuture<Boolean> remove(K key, V value)
      Removes the entry for the specified key only if it is currently mapped to the specified value.
      Parameters:
      key - key with which the specified value is associated
      value - value expected to be associated with the specified key
      Returns:
      true if the value was removed

    • replace

      default CompletableFuture<V> replace(K key, V value)
      Replaces the entry for the specified key only if it is currently mapped to some value.
      Parameters:
      key - key with which the specified value is associated
      value - value to be associated with the specified key
      Returns:
      the previous value associated with the specified key, or null if there was no mapping for the key. (A null return can also indicate that the map previously associated null with the key, if the implementation supports null values.)

    • replace

      default CompletableFuture<Boolean> replace(K key, V oldValue, V newValue)
      Replaces the entry for the specified key only if currently mapped to the specified value.
      Parameters:
      key - key with which the specified value is associated
      oldValue - value expected to be associated with the specified key
      newValue - value to be associated with the specified key
      Returns:
      true if the value was replaced

    • computeIfAbsent

      default CompletableFuture<V> computeIfAbsent(K key, Remote.Function<? super K,? extends V> mappingFunction)
      Compute the value using the given mapping function and enter it into this map (unless null), if the specified key is not already associated with a value (or is mapped to null).

      If the mapping function returns null no mapping is recorded. If the function itself throws an (unchecked) exception, the exception is rethrown, and no mapping is recorded.

      The most common usage is to construct a new object serving as an initial mapped value or memoized result, as in: 

         map.computeIfAbsent(key, k -> new Value(f(k)));

      Or to implement a multi-value map, Map<K, Collection<V>>, supporting multiple values per key: 

         map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
      Note that the previous example will not work as expected if this method is called on a distributed map, as the add method will be called on the client-side copy of the collection stored on the server.
      Parameters:
      key - key with which the specified value is to be associated
      mappingFunction - the function to compute a value
      Returns:
      the current (existing or computed) value associated with the specified key, or null if the computed value is null

    • computeIfPresent

      default CompletableFuture<V> computeIfPresent(K key, Remote.BiFunction<? super K,? super V,? extends V> remappingFunction)
      Compute a new mapping given the key and its current mapped value, if the value for the specified key is present and non-null.

      If the function returns null, the mapping is removed. If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.

      Parameters:
      key - the key with which the specified value is to be associated
      remappingFunction - the function to compute a value
      Returns:
      the new value associated with the specified key, or null if none

    • compute

      default CompletableFuture<V> compute(K key, Remote.BiFunction<? super K,? super V,? extends V> remappingFunction)
      Compute a new mapping for the specified key and its current value.

      If the function returns null, the mapping is removed (or remains absent if initially absent). If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.

      Parameters:
      key - the key with which the computed value is to be associated
      remappingFunction - the function to compute a value
      Returns:
      the new value associated with the specified key, or null if none

    • merge

      default CompletableFuture<V> merge(K key, V value, Remote.BiFunction<? super V,? super V,? extends V> remappingFunction)
      If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value. Otherwise, replaces the associated value with the results of the given remapping function, or removes if the result is null.

      This method may be of use when combining multiple mapped values for a key. For example, to either create or append a String msg to a value mapping: 

         map.merge(key, msg, String::concat)
      If the function returns null the mapping is removed. If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.
      Parameters:
      key - key with which the resulting value is to be associated
      value - the non-null value to be merged with the existing value associated with the key or, if no existing value or a null value is associated with the key, to be associated with the key
      remappingFunction - the function to recompute a value if present
      Returns:
      the new value associated with the specified key, or null if no value is associated with the key

    • replaceAll

      default CompletableFuture<Map<K,Void>> replaceAll(Remote.BiFunction<? super K,? super V,? extends V> function)
      Replace each entry's value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception.
      Parameters:
      function - the function to apply to each entry

    • replaceAll

      default CompletableFuture<Map<K,Void>> replaceAll(Collection<? extends K> collKeys, Remote.BiFunction<? super K,? super V,? extends V> function)
      Replace each entry's value with the result of invoking the given function on that entry until all entries for the specified key set have been processed or the function throws an exception.
      Parameters:
      collKeys - the keys to process; these keys are not required to exist within the Map
      function - the function to apply to each entry

    • replaceAll

      default CompletableFuture<Map<K,Void>> replaceAll(Filter<?> filter, Remote.BiFunction<? super K,? super V,? extends V> function)
      Replace each entry's value with the result of invoking the given function on that entry until all entries selected by the specified filter have been processed or the function throws an exception.
      Parameters:
      filter - the filter that should be used to select entries
      function - the function to apply to each entry