Package io.vertx.mutiny.core.shareddata

Class AsyncMap<K,V>

java.lang.Object
io.vertx.mutiny.core.shareddata.AsyncMap<K,V>
All Implemented Interfaces:
MutinyDelegate
public class AsyncMap<K,V> extends Object implements MutinyDelegate
An asynchronous map.

AsyncMap does not allow null to be used as a key or value.

NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

  • Field Details

    • __TYPE_ARG

      public static final TypeArg<AsyncMap> __TYPE_ARG

    • __typeArg_0

      public final TypeArg<K> __typeArg_0

    • __typeArg_1

      public final TypeArg<V> __typeArg_1

  • Constructor Details

    • AsyncMap

      public AsyncMap(io.vertx.core.shareddata.AsyncMap delegate)

    • AsyncMap

      public AsyncMap(Object delegate, TypeArg<K> typeArg_0, TypeArg<V> typeArg_1)

    • AsyncMap

      public AsyncMap(io.vertx.core.shareddata.AsyncMap delegate, TypeArg<K> typeArg_0, TypeArg<V> typeArg_1)

  • Method Details

    • getDelegate

      public io.vertx.core.shareddata.AsyncMap getDelegate()
      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate used by this Mutiny object of generated type

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • get

      @CheckReturnValue public io.smallrye.mutiny.Uni<V> get(K k)
      Get a value from the map, asynchronously.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • getAndAwait

      public V getAndAwait(K k)
      Blocking variant of get(K).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      k - the key
      Returns:
      the V instance produced by the operation.

    • getAndForget

      public void getAndForget(K k)
      Variant of get(K) that ignores the result of the operation.

      This method subscribes on the result of get(K), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from get(K) but you don't need to compose it with other operations.

      Parameters:
      k - the key

    • put

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> put(K k, V v)
      Put a value in the map, asynchronously.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      v - the value
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • putAndAwait

      public Void putAndAwait(K k, V v)
      Blocking variant of put(K,V).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      k - the key
      v - the value
      Returns:
      the Void instance produced by the operation.

    • putAndForget

      public void putAndForget(K k, V v)
      Variant of put(K,V) that ignores the result of the operation.

      This method subscribes on the result of put(K,V), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from put(K,V) but you don't need to compose it with other operations.

      Parameters:
      k - the key
      v - the value

    • put

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> put(K k, V v, long ttl)
      Like put(K, V) but specifying a time to live for the entry. Entry will expire and get evicted after the ttl.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      v - the value
      ttl - The time to live (in ms) for the entry
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • putAndAwait

      public Void putAndAwait(K k, V v, long ttl)
      Blocking variant of put(K,V,long).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      k - the key
      v - the value
      ttl - The time to live (in ms) for the entry
      Returns:
      the Void instance produced by the operation.

    • putAndForget

      public void putAndForget(K k, V v, long ttl)
      Variant of put(K,V,long) that ignores the result of the operation.

      This method subscribes on the result of put(K,V,long), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from put(K,V,long) but you don't need to compose it with other operations.

      Parameters:
      k - the key
      v - the value
      ttl - The time to live (in ms) for the entry

    • putIfAbsent

      @CheckReturnValue public io.smallrye.mutiny.Uni<V> putIfAbsent(K k, V v)
      Put the entry only if there is no entry with the key already present. If key already present then the existing value will be returned to the handler, otherwise null.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      v - the value
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • putIfAbsentAndAwait

      public V putIfAbsentAndAwait(K k, V v)
      Blocking variant of putIfAbsent(K,V).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      k - the key
      v - the value
      Returns:
      the V instance produced by the operation.

    • putIfAbsentAndForget

      public void putIfAbsentAndForget(K k, V v)
      Variant of putIfAbsent(K,V) that ignores the result of the operation.

      This method subscribes on the result of putIfAbsent(K,V), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from putIfAbsent(K,V) but you don't need to compose it with other operations.

      Parameters:
      k - the key
      v - the value

    • putIfAbsent

      @CheckReturnValue public io.smallrye.mutiny.Uni<V> putIfAbsent(K k, V v, long ttl)
      Link putIfAbsent(K, V) but specifying a time to live for the entry. Entry will expire and get evicted after the ttl.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      v - the value
      ttl - The time to live (in ms) for the entry
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • putIfAbsentAndAwait

      public V putIfAbsentAndAwait(K k, V v, long ttl)
      Blocking variant of putIfAbsent(K,V,long).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      k - the key
      v - the value
      ttl - The time to live (in ms) for the entry
      Returns:
      the V instance produced by the operation.

    • putIfAbsentAndForget

      public void putIfAbsentAndForget(K k, V v, long ttl)
      Variant of putIfAbsent(K,V,long) that ignores the result of the operation.

      This method subscribes on the result of putIfAbsent(K,V,long), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from putIfAbsent(K,V,long) but you don't need to compose it with other operations.

      Parameters:
      k - the key
      v - the value
      ttl - The time to live (in ms) for the entry

    • remove

      @CheckReturnValue public io.smallrye.mutiny.Uni<V> remove(K k)
      Remove a value from the map, asynchronously.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • removeAndAwait

      public V removeAndAwait(K k)
      Blocking variant of remove(K).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      k - the key
      Returns:
      the V instance produced by the operation.

    • removeAndForget

      public void removeAndForget(K k)
      Variant of remove(K) that ignores the result of the operation.

      This method subscribes on the result of remove(K), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from remove(K) but you don't need to compose it with other operations.

      Parameters:
      k - the key

    • removeIfPresent

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> removeIfPresent(K k, V v)
      Remove a value from the map, only if entry already exists with same value.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      v - the value
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • removeIfPresentAndAwait

      public Boolean removeIfPresentAndAwait(K k, V v)
      Blocking variant of removeIfPresent(K,V).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      k - the key
      v - the value
      Returns:
      the Boolean instance produced by the operation.

    • removeIfPresentAndForget

      public void removeIfPresentAndForget(K k, V v)
      Variant of removeIfPresent(K,V) that ignores the result of the operation.

      This method subscribes on the result of removeIfPresent(K,V), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from removeIfPresent(K,V) but you don't need to compose it with other operations.

      Parameters:
      k - the key
      v - the value

    • replace

      @CheckReturnValue public io.smallrye.mutiny.Uni<V> replace(K k, V v)
      Replace the entry only if it is currently mapped to some value

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      v - the new value
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • replaceAndAwait

      public V replaceAndAwait(K k, V v)
      Blocking variant of replace(K,V).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      k - the key
      v - the new value
      Returns:
      the V instance produced by the operation.

    • replaceAndForget

      public void replaceAndForget(K k, V v)
      Variant of replace(K,V) that ignores the result of the operation.

      This method subscribes on the result of replace(K,V), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from replace(K,V) but you don't need to compose it with other operations.

      Parameters:
      k - the key
      v - the new value

    • replace

      @CheckReturnValue public io.smallrye.mutiny.Uni<V> replace(K k, V v, long ttl)
      Replace the entry only if it is currently mapped to some value

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      v - the new value
      ttl - The time to live (in ms) for the entry
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • replaceAndAwait

      public V replaceAndAwait(K k, V v, long ttl)
      Blocking variant of replace(K,V,long).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      k - the key
      v - the new value
      ttl - The time to live (in ms) for the entry
      Returns:
      the V instance produced by the operation.

    • replaceAndForget

      public void replaceAndForget(K k, V v, long ttl)
      Variant of replace(K,V,long) that ignores the result of the operation.

      This method subscribes on the result of replace(K,V,long), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from replace(K,V,long) but you don't need to compose it with other operations.

      Parameters:
      k - the key
      v - the new value
      ttl - The time to live (in ms) for the entry

    • replaceIfPresent

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> replaceIfPresent(K k, V oldValue, V newValue)
      Replace the entry only if it is currently mapped to a specific value

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      oldValue - the existing value
      newValue - the new value
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • replaceIfPresentAndAwait

      public Boolean replaceIfPresentAndAwait(K k, V oldValue, V newValue)
      Blocking variant of replaceIfPresent(K,V,V).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      k - the key
      oldValue - the existing value
      newValue - the new value
      Returns:
      the Boolean instance produced by the operation.

    • replaceIfPresentAndForget

      public void replaceIfPresentAndForget(K k, V oldValue, V newValue)
      Variant of replaceIfPresent(K,V,V) that ignores the result of the operation.

      This method subscribes on the result of replaceIfPresent(K,V,V), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from replaceIfPresent(K,V,V) but you don't need to compose it with other operations.

      Parameters:
      k - the key
      oldValue - the existing value
      newValue - the new value

    • replaceIfPresent

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> replaceIfPresent(K k, V oldValue, V newValue, long ttl)
      Replace the entry only if it is currently mapped to a specific value

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      oldValue - the existing value
      newValue - the new value
      ttl - The time to live (in ms) for the entry
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • replaceIfPresentAndAwait

      public Boolean replaceIfPresentAndAwait(K k, V oldValue, V newValue, long ttl)
      Blocking variant of replaceIfPresent(K,V,V,long).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      k - the key
      oldValue - the existing value
      newValue - the new value
      ttl - The time to live (in ms) for the entry
      Returns:
      the Boolean instance produced by the operation.

    • replaceIfPresentAndForget

      public void replaceIfPresentAndForget(K k, V oldValue, V newValue, long ttl)
      Variant of replaceIfPresent(K,V,V,long) that ignores the result of the operation.

      This method subscribes on the result of replaceIfPresent(K,V,V,long), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from replaceIfPresent(K,V,V,long) but you don't need to compose it with other operations.

      Parameters:
      k - the key
      oldValue - the existing value
      newValue - the new value
      ttl - The time to live (in ms) for the entry

    • clear

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> clear()
      Clear all entries in the map

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • clearAndAwait

      public Void clearAndAwait()
      Blocking variant of clear().

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      the Void instance produced by the operation.

    • clearAndForget

      public void clearAndForget()
      Variant of clear() that ignores the result of the operation.

      This method subscribes on the result of clear(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from clear() but you don't need to compose it with other operations.

    • size

      @CheckReturnValue public io.smallrye.mutiny.Uni<Integer> size()
      Provide the number of entries in the map

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • sizeAndAwait

      public Integer sizeAndAwait()
      Blocking variant of size().

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      the Integer instance produced by the operation.

    • sizeAndForget

      public void sizeAndForget()
      Variant of size() that ignores the result of the operation.

      This method subscribes on the result of size(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from size() but you don't need to compose it with other operations.

    • keys

      @CheckReturnValue public io.smallrye.mutiny.Uni<Set<K>> keys()
      Get the keys of the map, asynchronously.

      Use this method with care as the map may contain a large number of keys, which may not fit entirely in memory of a single node. In this case, the invocation will result in an OutOfMemoryError.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • keysAndAwait

      public Set<K> keysAndAwait()
      Blocking variant of keys().

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      the Set instance produced by the operation.

    • keysAndForget

      public void keysAndForget()
      Variant of keys() that ignores the result of the operation.

      This method subscribes on the result of keys(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from keys() but you don't need to compose it with other operations.

    • values

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<V>> values()
      Get the values of the map, asynchronously.

      Use this method with care as the map may contain a large number of values, which may not fit entirely in memory of a single node. In this case, the invocation will result in an OutOfMemoryError.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • valuesAndAwait

      public List<V> valuesAndAwait()
      Blocking variant of values().

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      the List instance produced by the operation.

    • valuesAndForget

      public void valuesAndForget()
      Variant of values() that ignores the result of the operation.

      This method subscribes on the result of values(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from values() but you don't need to compose it with other operations.

    • newInstance

      public static <K, V> AsyncMap<K,V> newInstance(io.vertx.core.shareddata.AsyncMap arg)

    • newInstance

      public static <K, V> AsyncMap<K,V> newInstance(io.vertx.core.shareddata.AsyncMap arg, TypeArg<K> __typeArg_K, TypeArg<V> __typeArg_V)