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.

Author:
Tim Fox
Implementation Requirements:
Implementations of the interface must handle ClusterSerializable implementing objects.
See Also:
  • AsyncMap

  • 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<K,V> delegate)
      Create a new instance of AsyncMap delegating to the given (non-null) instance of AsyncMap.

    • AsyncMap

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

    • AsyncMap

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

  • Method Details

    • getDelegate

      public io.vertx.core.shareddata.AsyncMap<K,V> getDelegate()
      Get the delegate instance.

      This method returns the instance on which this shim is delegating the calls. And so, give you access to the bare API.

      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate instance

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#get(K)

    • getAndAwait

      public V getAndAwait(K k)
      Get a value from the map, asynchronously.

      Unlike the bare Vert.x variant, this method returns a AsyncMap. This method awaits indefinitely 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 operation result
      See Also:
      • io.vertx.core.shareddata.AsyncMap#get(K)

    • getAndForget

      public AsyncMap<K,V> getAndForget(K k)
      Get a value from the map, asynchronously.

      Unlike the bare Vert.x variant, this method ignores the AsyncMap result or any failure.

      Parameters:
      k - the key
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#get(K)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      v - the value
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#put(K, V)

    • putAndAwait

      public void putAndAwait(K k, V v)
      Put a value in the map, asynchronously.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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
      See Also:
      • io.vertx.core.shareddata.AsyncMap#put(K, V)

    • putAndForget

      public AsyncMap<K,V> putAndForget(K k, V v)
      Put a value in the map, asynchronously.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      k - the key
      v - the value
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#put(K, V)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#put(K, V, long)

    • putAndAwait

      public void putAndAwait(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 Void. This method awaits indefinitely 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
      See Also:
      • io.vertx.core.shareddata.AsyncMap#put(K, V, long)

    • putAndForget

      public AsyncMap<K,V> putAndForget(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 ignores the Void result or any failure.

      Parameters:
      k - the key
      v - the value
      ttl - The time to live (in ms) for the entry
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#put(K, V, long)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      v - the value
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#putIfAbsent(K, V)

    • putIfAbsentAndAwait

      public V putIfAbsentAndAwait(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 AsyncMap. This method awaits indefinitely 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 operation result
      See Also:
      • io.vertx.core.shareddata.AsyncMap#putIfAbsent(K, V)

    • putIfAbsentAndForget

      public AsyncMap<K,V> putIfAbsentAndForget(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 ignores the AsyncMap result or any failure.

      Parameters:
      k - the key
      v - the value
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#putIfAbsent(K, V)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#putIfAbsent(K, V, long)

    • putIfAbsentAndAwait

      public V putIfAbsentAndAwait(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 AsyncMap. This method awaits indefinitely 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 operation result
      See Also:
      • io.vertx.core.shareddata.AsyncMap#putIfAbsent(K, V, long)

    • putIfAbsentAndForget

      public AsyncMap<K,V> putIfAbsentAndForget(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 ignores the AsyncMap result or any failure.

      Parameters:
      k - the key
      v - the value
      ttl - The time to live (in ms) for the entry
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#putIfAbsent(K, V, long)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#remove(K)

    • removeAndAwait

      public V removeAndAwait(K k)
      Remove a value from the map, asynchronously.

      Unlike the bare Vert.x variant, this method returns a AsyncMap. This method awaits indefinitely 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 operation result
      See Also:
      • io.vertx.core.shareddata.AsyncMap#remove(K)

    • removeAndForget

      public AsyncMap<K,V> removeAndForget(K k)
      Remove a value from the map, asynchronously.

      Unlike the bare Vert.x variant, this method ignores the AsyncMap result or any failure.

      Parameters:
      k - the key
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#remove(K)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      v - the value
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#removeIfPresent(K, V)

    • removeIfPresentAndAwait

      public Boolean removeIfPresentAndAwait(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 Boolean. This method awaits indefinitely 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 operation result
      See Also:
      • io.vertx.core.shareddata.AsyncMap#removeIfPresent(K, V)

    • removeIfPresentAndForget

      public AsyncMap<K,V> removeIfPresentAndForget(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 ignores the Boolean result or any failure.

      Parameters:
      k - the key
      v - the value
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#removeIfPresent(K, V)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      v - the new value
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replace(K, V)

    • replaceAndAwait

      public V replaceAndAwait(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 AsyncMap. This method awaits indefinitely 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 operation result
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replace(K, V)

    • replaceAndForget

      public AsyncMap<K,V> replaceAndForget(K k, V v)
      Replace the entry only if it is currently mapped to some value

      Unlike the bare Vert.x variant, this method ignores the AsyncMap result or any failure.

      Parameters:
      k - the key
      v - the new value
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replace(K, V)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replace(K, V, long)

    • replaceAndAwait

      public V replaceAndAwait(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 AsyncMap. This method awaits indefinitely 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 operation result
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replace(K, V, long)

    • replaceAndForget

      public AsyncMap<K,V> replaceAndForget(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 ignores the AsyncMap result or any failure.

      Parameters:
      k - the key
      v - the new value
      ttl - The time to live (in ms) for the entry
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replace(K, V, long)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      k - the key
      oldValue - the existing value
      newValue - the new value
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replaceIfPresent(K, V, V)

    • replaceIfPresentAndAwait

      public Boolean replaceIfPresentAndAwait(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 Boolean. This method awaits indefinitely 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 operation result
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replaceIfPresent(K, V, V)

    • replaceIfPresentAndForget

      public AsyncMap<K,V> replaceIfPresentAndForget(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 ignores the Boolean result or any failure.

      Parameters:
      k - the key
      oldValue - the existing value
      newValue - the new value
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replaceIfPresent(K, V, V)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replaceIfPresent(K, V, V, long)

    • replaceIfPresentAndAwait

      public Boolean replaceIfPresentAndAwait(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 Boolean. This method awaits indefinitely 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 operation result
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replaceIfPresent(K, V, V, long)

    • replaceIfPresentAndForget

      public AsyncMap<K,V> replaceIfPresentAndForget(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 ignores the Boolean result or any failure.

      Parameters:
      k - the key
      oldValue - the existing value
      newValue - the new value
      ttl - The time to live (in ms) for the entry
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.shareddata.AsyncMap#replaceIfPresent(K, V, V, long)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • AsyncMap.clear()

    • clearAndAwait

      public void clearAndAwait()
      Clear all entries in the map

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • AsyncMap.clear()

    • clearAndForget

      public AsyncMap<K,V> clearAndForget()
      Clear all entries in the map

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • AsyncMap.clear()

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • AsyncMap.size()

    • sizeAndAwait

      public Integer sizeAndAwait()
      Provide the number of entries in the map

      Unlike the bare Vert.x variant, this method returns a Integer. This method awaits indefinitely 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 operation result
      See Also:
      • AsyncMap.size()

    • sizeAndForget

      public AsyncMap<K,V> sizeAndForget()
      Provide the number of entries in the map

      Unlike the bare Vert.x variant, this method ignores the Integer result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • AsyncMap.size()

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • AsyncMap.keys()

    • keysAndAwait

      public Set<K> keysAndAwait()
      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 Set<K>. This method awaits indefinitely 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 operation result
      See Also:
      • AsyncMap.keys()

    • keysAndForget

      public AsyncMap<K,V> keysAndForget()
      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 ignores the Set<K> result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • AsyncMap.keys()

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • AsyncMap.values()

    • valuesAndAwait

      public List<V> valuesAndAwait()
      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 List<V>. This method awaits indefinitely 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 operation result
      See Also:
      • AsyncMap.values()

    • valuesAndForget

      public AsyncMap<K,V> valuesAndForget()
      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 ignores the List<V> result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • AsyncMap.values()

    • newInstance

      public static <K, V> AsyncMap<K,V> newInstance(io.vertx.core.shareddata.AsyncMap<K,V> delegate)
      Creates a new instance of the AsyncMap.

    • newInstance

      public static <K, V> AsyncMap<K,V> newInstance(io.vertx.core.shareddata.AsyncMap<K,V> delegate, TypeArg<K> typeArg_0, TypeArg<V> typeArg_1)
      Creates a new instance of the AsyncMap.

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

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

    • toString

      public String toString()
      Overrides:
      toString in class Object