Package io.vertx.reactivex.core.shareddata

## Class AsyncMap<K,​V>

- java.lang.Object
- - io.vertx.reactivex.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 RX-ified interface using Vert.x codegen.

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static io.vertx.lang.rx.TypeArg<AsyncMap>` | `__TYPE_ARG` |
    `io.vertx.lang.rx.TypeArg<K>` | `__typeArg_0` |
    `io.vertx.lang.rx.TypeArg<V>` | `__typeArg_1` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `AsyncMap​(AsyncMap delegate)` |
    `AsyncMap​(Object delegate, io.vertx.lang.rx.TypeArg<K> typeArg_0, io.vertx.lang.rx.TypeArg<V> typeArg_1)` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | `clear()` | Clear all entries in the map
    `boolean` | `equals​(Object o)` |
    `Future<V>` | `get​(K k)` | Get a value from the map, asynchronously.
    `AsyncMap` | `getDelegate()` |
    `int` | `hashCode()` |
    `Future<Set<K>>` | `keys()` | Get the keys of the map, asynchronously.
    `static <K,​V> AsyncMap<K,​V>` | `newInstance​(AsyncMap arg)` |
    `static <K,​V> AsyncMap<K,​V>` | `newInstance​(AsyncMap arg, io.vertx.lang.rx.TypeArg<K> __typeArg_K, io.vertx.lang.rx.TypeArg<V> __typeArg_V)` |
    `Future<Void>` | `put​(K k, V v)` | Put a value in the map, asynchronously.
    `Future<Void>` | `put​(K k, V v, long ttl)` | Like `put(K, V)` but specifying a time to live for the entry.
    `Future<V>` | `putIfAbsent​(K k, V v)` | Put the entry only if there is no entry with the key already present.
    `Future<V>` | `putIfAbsent​(K k, V v, long ttl)` | Link `putIfAbsent(K, V)` but specifying a time to live for the entry.
    `Future<V>` | `remove​(K k)` | Remove a value from the map, asynchronously.
    `Future<Boolean>` | `removeIfPresent​(K k, V v)` | Remove a value from the map, only if entry already exists with same value.
    `Future<V>` | `replace​(K k, V v)` | Replace the entry only if it is currently mapped to some value
    `Future<V>` | `replace​(K k, V v, long ttl)` | Replace the entry only if it is currently mapped to some value
    `Future<Boolean>` | `replaceIfPresent​(K k, V oldValue, V newValue)` | Replace the entry only if it is currently mapped to a specific value
    `Future<Boolean>` | `replaceIfPresent​(K k, V oldValue, V newValue, long ttl)` | Replace the entry only if it is currently mapped to a specific value
    `Completable` | `rxClear()` | Clear all entries in the map
    `Maybe<V>` | `rxGet​(K k)` | Get a value from the map, asynchronously.
    `Single<Set<K>>` | `rxKeys()` | Get the keys of the map, asynchronously.
    `Completable` | `rxPut​(K k, V v)` | Put a value in the map, asynchronously.
    `Completable` | `rxPut​(K k, V v, long ttl)` | Like `put(K, V)` but specifying a time to live for the entry.
    `Maybe<V>` | `rxPutIfAbsent​(K k, V v)` | Put the entry only if there is no entry with the key already present.
    `Maybe<V>` | `rxPutIfAbsent​(K k, V v, long ttl)` | Link `putIfAbsent(K, V)` but specifying a time to live for the entry.
    `Maybe<V>` | `rxRemove​(K k)` | Remove a value from the map, asynchronously.
    `Single<Boolean>` | `rxRemoveIfPresent​(K k, V v)` | Remove a value from the map, only if entry already exists with same value.
    `Maybe<V>` | `rxReplace​(K k, V v)` | Replace the entry only if it is currently mapped to some value
    `Maybe<V>` | `rxReplace​(K k, V v, long ttl)` | Replace the entry only if it is currently mapped to some value
    `Single<Boolean>` | `rxReplaceIfPresent​(K k, V oldValue, V newValue)` | Replace the entry only if it is currently mapped to a specific value
    `Single<Boolean>` | `rxReplaceIfPresent​(K k, V oldValue, V newValue, long ttl)` | Replace the entry only if it is currently mapped to a specific value
    `Single<Integer>` | `rxSize()` | Provide the number of entries in the map
    `Single<List<V>>` | `rxValues()` | Get the values of the map, asynchronously.
    `Future<Integer>` | `size()` | Provide the number of entries in the map
    `String` | `toString()` |
    `Future<List<V>>` | `values()` | Get the values of the map, asynchronously.

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<AsyncMap> __TYPE_ARG

    - #### __typeArg_0

          public final io.vertx.lang.rx.TypeArg<K> __typeArg_0

    - #### __typeArg_1

          public final io.vertx.lang.rx.TypeArg<V> __typeArg_1

  - ### Constructor Detail

    - #### AsyncMap

          public AsyncMap​(AsyncMap delegate)

    - #### AsyncMap

          public AsyncMap​(Object delegate,
                          io.vertx.lang.rx.TypeArg<K> typeArg_0,
                          io.vertx.lang.rx.TypeArg<V> typeArg_1)

  - ### Method Detail

    - #### 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`

    - #### getDelegate

          public AsyncMap getDelegate()

    - #### get

          public Future<V> get​(K k)

      Get a value from the map, asynchronously.
      Parameters:
        `k` - the key
      Returns:
        a future notified some time later with the async result.

    - #### rxGet

          public Maybe<V> rxGet​(K k)

      Get a value from the map, asynchronously.
      Parameters:
        `k` - the key
      Returns:
        a future notified some time later with the async result.

    - #### put

          public Future<Void> put​(K k,
                                  V v)

      Put a value in the map, asynchronously.
      Parameters:
        `k` - the key
        `v` - the value
      Returns:
        a future notified some time later with the async result.

    - #### rxPut

          public Completable rxPut​(K k,
                                   V v)

      Put a value in the map, asynchronously.
      Parameters:
        `k` - the key
        `v` - the value
      Returns:
        a future notified some time later with the async result.

    - #### put

          public Future<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.
      Parameters:
        `k` - the key
        `v` - the value
        `ttl` - The time to live (in ms) for the entry
      Returns:
        a future notified some time later with the async result.

    - #### rxPut

          public Completable rxPut​(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.
      Parameters:
        `k` - the key
        `v` - the value
        `ttl` - The time to live (in ms) for the entry
      Returns:
        a future notified some time later with the async result.

    - #### putIfAbsent

          public Future<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.
      Parameters:
        `k` - the key
        `v` - the value
      Returns:
        a future notified some time later with the async result.

    - #### rxPutIfAbsent

          public Maybe<V> rxPutIfAbsent​(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.
      Parameters:
        `k` - the key
        `v` - the value
      Returns:
        a future notified some time later with the async result.

    - #### putIfAbsent

          public Future<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.
      Parameters:
        `k` - the key
        `v` - the value
        `ttl` - The time to live (in ms) for the entry
      Returns:
        a future notified some time later with the async result.

    - #### rxPutIfAbsent

          public Maybe<V> rxPutIfAbsent​(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.
      Parameters:
        `k` - the key
        `v` - the value
        `ttl` - The time to live (in ms) for the entry
      Returns:
        a future notified some time later with the async result.

    - #### remove

          public Future<V> remove​(K k)

      Remove a value from the map, asynchronously.
      Parameters:
        `k` - the key
      Returns:
        a future notified some time later with the async result.

    - #### rxRemove

          public Maybe<V> rxRemove​(K k)

      Remove a value from the map, asynchronously.
      Parameters:
        `k` - the key
      Returns:
        a future notified some time later with the async result.

    - #### removeIfPresent

          public Future<Boolean> removeIfPresent​(K k,
                                                 V v)

      Remove a value from the map, only if entry already exists with same value.
      Parameters:
        `k` - the key
        `v` - the value
      Returns:
        a future notified some time later with the async result.

    - #### rxRemoveIfPresent

          public Single<Boolean> rxRemoveIfPresent​(K k,
                                                   V v)

      Remove a value from the map, only if entry already exists with same value.
      Parameters:
        `k` - the key
        `v` - the value
      Returns:
        a future notified some time later with the async result.

    - #### replace

          public Future<V> replace​(K k,
                                   V v)

      Replace the entry only if it is currently mapped to some value
      Parameters:
        `k` - the key
        `v` - the new value
      Returns:
        a future notified some time later with the async result.

    - #### rxReplace

          public Maybe<V> rxReplace​(K k,
                                    V v)

      Replace the entry only if it is currently mapped to some value
      Parameters:
        `k` - the key
        `v` - the new value
      Returns:
        a future notified some time later with the async result.

    - #### replace

          public Future<V> replace​(K k,
                                   V v,
                                   long ttl)

      Replace the entry only if it is currently mapped to some value
      Parameters:
        `k` - the key
        `v` - the new value
        `ttl` - The time to live (in ms) for the entry
      Returns:
        a future notified some time later with the previous value

    - #### rxReplace

          public Maybe<V> rxReplace​(K k,
                                    V v,
                                    long ttl)

      Replace the entry only if it is currently mapped to some value
      Parameters:
        `k` - the key
        `v` - the new value
        `ttl` - The time to live (in ms) for the entry
      Returns:
        a future notified some time later with the previous value

    - #### replaceIfPresent

          public Future<Boolean> replaceIfPresent​(K k,
                                                  V oldValue,
                                                  V newValue)

      Replace the entry only if it is currently mapped to a specific value
      Parameters:
        `k` - the key
        `oldValue` - the existing value
        `newValue` - the new value
      Returns:
        a future notified some time later with the async result.

    - #### rxReplaceIfPresent

          public Single<Boolean> rxReplaceIfPresent​(K k,
                                                    V oldValue,
                                                    V newValue)

      Replace the entry only if it is currently mapped to a specific value
      Parameters:
        `k` - the key
        `oldValue` - the existing value
        `newValue` - the new value
      Returns:
        a future notified some time later with the async result.

    - #### replaceIfPresent

          public Future<Boolean> replaceIfPresent​(K k,
                                                  V oldValue,
                                                  V newValue,
                                                  long ttl)

      Replace the entry only if it is currently mapped to a specific value
      Parameters:
        `k` - the key
        `oldValue` - the existing value
        `newValue` - the new value
        `ttl` - The time to live (in ms) for the entry
      Returns:
        a future notified some time later with the async result.

    - #### rxReplaceIfPresent

          public Single<Boolean> rxReplaceIfPresent​(K k,
                                                    V oldValue,
                                                    V newValue,
                                                    long ttl)

      Replace the entry only if it is currently mapped to a specific value
      Parameters:
        `k` - the key
        `oldValue` - the existing value
        `newValue` - the new value
        `ttl` - The time to live (in ms) for the entry
      Returns:
        a future notified some time later with the async result.

    - #### clear

          public Future<Void> clear()

      Clear all entries in the map
      Returns:
        a future notified some time later with the async result.

    - #### rxClear

          public Completable rxClear()

      Clear all entries in the map
      Returns:
        a future notified some time later with the async result.

    - #### size

          public Future<Integer> size()

      Provide the number of entries in the map
      Returns:
        a future notified some time later with the async result.

    - #### rxSize

          public Single<Integer> rxSize()

      Provide the number of entries in the map
      Returns:
        a future notified some time later with the async result.

    - #### keys

          public Future<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`.

      Returns:
        a future notified some time later with the async result.

    - #### rxKeys

          public Single<Set<K>> rxKeys()

      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`.

      Returns:
        a future notified some time later with the async result.

    - #### values

          public Future<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`.

      Returns:
        a future notified some time later with the async result.

    - #### rxValues

          public Single<List<V>> rxValues()

      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`.

      Returns:
        a future notified some time later with the async result.

    - #### newInstance

          public static <K,​V> AsyncMap<K,​V> newInstance​(AsyncMap arg)

    - #### newInstance

          public static <K,​V> AsyncMap<K,​V> newInstance​(AsyncMap arg,
                                                                    io.vertx.lang.rx.TypeArg<K> __typeArg_K,
                                                                    io.vertx.lang.rx.TypeArg<V> __typeArg_V)