java.lang.Object
- io.vertx.mutiny.core.shareddata.AsyncMap<K,V>

```
public class AsyncMap<K,V>
extends Object
```
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 Summary

Fields
Modifier and Type Field Description

static TypeArg<AsyncMap> __TYPE_ARG

TypeArg<K> __typeArg_0

TypeArg<V> __typeArg_1

Constructor Summary

Constructors
Constructor	Description
`AsyncMap(io.vertx.core.shareddata.AsyncMap delegate)`
`AsyncMap(io.vertx.core.shareddata.AsyncMap delegate, TypeArg<K> typeArg_0, TypeArg<V> typeArg_1)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`io.smallrye.mutiny.Uni<Void>`	`clear()`	Clear all entries in the map
`Void`	`clearAndAwait()`	Blocking variant of `clear()`.
`boolean`	`equals(Object o)`
`io.smallrye.mutiny.Uni<V>`	`get(K k)`	Get a value from the map, asynchronously.
`V`	`getAndAwait(K k)`	Blocking variant of `io.vertx.mutiny.core.shareddata.AsyncMap#get(K)`.
`io.vertx.core.shareddata.AsyncMap`	`getDelegate()`
`int`	`hashCode()`
`static <K,V> AsyncMap<K,V>`	`newInstance(io.vertx.core.shareddata.AsyncMap arg)`
`static <K,V> AsyncMap<K,V>`	`newInstance(io.vertx.core.shareddata.AsyncMap arg, TypeArg<K> __typeArg_K, TypeArg<V> __typeArg_V)`
`io.smallrye.mutiny.Uni<Void>`	`put(K k, V v)`	Put a value in the map, asynchronously.
`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.
`Void`	`putAndAwait(K k, V v)`	Blocking variant of `io.vertx.mutiny.core.shareddata.AsyncMap#put(K,V)`.
`Void`	`putAndAwait(K k, V v, long ttl)`	Blocking variant of `io.vertx.mutiny.core.shareddata.AsyncMap#put(K,V,long)`.
`io.smallrye.mutiny.Uni<V>`	`putIfAbsent(K k, V v)`	Put the entry only if there is no entry with the key already present.
`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.
`V`	`putIfAbsentAndAwait(K k, V v)`	Blocking variant of `io.vertx.mutiny.core.shareddata.AsyncMap#putIfAbsent(K,V)`.
`V`	`putIfAbsentAndAwait(K k, V v, long ttl)`	Blocking variant of `io.vertx.mutiny.core.shareddata.AsyncMap#putIfAbsent(K,V,long)`.
`io.smallrye.mutiny.Uni<V>`	`remove(K k)`	Remove a value from the map, asynchronously.
`V`	`removeAndAwait(K k)`	Blocking variant of `io.vertx.mutiny.core.shareddata.AsyncMap#remove(K)`.
`io.smallrye.mutiny.Uni<Boolean>`	`removeIfPresent(K k, V v)`	Remove a value from the map, only if entry already exists with same value.
`Boolean`	`removeIfPresentAndAwait(K k, V v)`	Blocking variant of `io.vertx.mutiny.core.shareddata.AsyncMap#removeIfPresent(K,V)`.
`io.smallrye.mutiny.Uni<V>`	`replace(K k, V v)`	Replace the entry only if it is currently mapped to some value
`V`	`replaceAndAwait(K k, V v)`	Blocking variant of `io.vertx.mutiny.core.shareddata.AsyncMap#replace(K,V)`.
`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
`Boolean`	`replaceIfPresentAndAwait(K k, V oldValue, V newValue)`	Blocking variant of `io.vertx.mutiny.core.shareddata.AsyncMap#replaceIfPresent(K,V,V)`.
`io.smallrye.mutiny.Uni<Integer>`	`size()`	Provide the number of entries in the map
`Integer`	`sizeAndAwait()`	Blocking variant of `size()`.
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - __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 Detail
  - AsyncMap
```
public AsyncMap(io.vertx.core.shareddata.AsyncMap delegate)
```
  - AsyncMap
```
public AsyncMap(io.vertx.core.shareddata.AsyncMap delegate,
                TypeArg<K> typeArg_0,
                TypeArg<V> typeArg_1)
```
- Method Detail
  - getDelegate
```
public io.vertx.core.shareddata.AsyncMap getDelegate()
```
  - 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
```
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 io.vertx.mutiny.core.shareddata.AsyncMap#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
  - put
```
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 io.vertx.mutiny.core.shareddata.AsyncMap#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
  - put
```
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 io.vertx.mutiny.core.shareddata.AsyncMap#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
  - putIfAbsent
```
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 io.vertx.mutiny.core.shareddata.AsyncMap#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
  - putIfAbsent
```
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 io.vertx.mutiny.core.shareddata.AsyncMap#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
  - remove
```
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 io.vertx.mutiny.core.shareddata.AsyncMap#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
  - removeIfPresent
```
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 io.vertx.mutiny.core.shareddata.AsyncMap#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
  - replace
```
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 io.vertx.mutiny.core.shareddata.AsyncMap#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
  - replaceIfPresent
```
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 io.vertx.mutiny.core.shareddata.AsyncMap#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
  - clear
```
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
  - size
```
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
  - 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)
```

Modifier and Type	Field	Description
`static TypeArg<AsyncMap>`	`__TYPE_ARG`
`TypeArg<K>`	`__typeArg_0`
`TypeArg<V>`	`__typeArg_1`

Class AsyncMap<K,​V>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

__typeArg_0

__typeArg_1

Constructor Detail

AsyncMap

AsyncMap

Method Detail

getDelegate

toString

equals

hashCode

get

getAndAwait

put

putAndAwait

put

putAndAwait

putIfAbsent

putIfAbsentAndAwait

putIfAbsent

putIfAbsentAndAwait

remove

removeAndAwait

removeIfPresent

removeIfPresentAndAwait

replace

replaceAndAwait

replaceIfPresent

replaceIfPresentAndAwait

clear

clearAndAwait

size

sizeAndAwait

newInstance

newInstance

Class AsyncMap<K,V>