io.vertx.rxjava.core.shareddata

## Class AsyncMap<K,V>

- java.lang.Object
- - io.vertx.rxjava.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 and 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 and 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 and Description
    --- | ---
    `void` | `clear()` Clear all entries in the map
    `void` | `clear(Handler<AsyncResult<Void>> resultHandler)` Clear all entries in the map
    `boolean` | `equals(Object o)`
    `void` | `get(K k)` Get a value from the map, asynchronously.
    `void` | `get(K k, Handler<AsyncResult<V>> resultHandler)` Get a value from the map, asynchronously.
    `AsyncMap` | `getDelegate()`
    `int` | `hashCode()`
    `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)`
    `void` | `put(K k, V v)` Put a value in the map, asynchronously.
    `void` | `put(K k, V v, Handler<AsyncResult<Void>> completionHandler)` Put a value in the map, asynchronously.
    `void` | `put(K k, V v, long ttl)` Like `put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but specifying a time to live for the entry.
    `void` | `put(K k, V v, long ttl, Handler<AsyncResult<Void>> completionHandler)` Like `put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but specifying a time to live for the entry.
    `void` | `putIfAbsent(K k, V v)` Put the entry only if there is no entry with the key already present.
    `void` | `putIfAbsent(K k, V v, Handler<AsyncResult<V>> completionHandler)` Put the entry only if there is no entry with the key already present.
    `void` | `putIfAbsent(K k, V v, long ttl)` Link `putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>)` but specifying a time to live for the entry.
    `void` | `putIfAbsent(K k, V v, long ttl, Handler<AsyncResult<V>> completionHandler)` Link `putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>)` but specifying a time to live for the entry.
    `void` | `remove(K k)` Remove a value from the map, asynchronously.
    `void` | `remove(K k, Handler<AsyncResult<V>> resultHandler)` Remove a value from the map, asynchronously.
    `void` | `removeIfPresent(K k, V v)` Remove a value from the map, only if entry already exists with same value.
    `void` | `removeIfPresent(K k, V v, Handler<AsyncResult<Boolean>> resultHandler)` Remove a value from the map, only if entry already exists with same value.
    `void` | `replace(K k, V v)` Replace the entry only if it is currently mapped to some value
    `void` | `replace(K k, V v, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `void` | `replace(K k, V v, long ttl)` Replace the entry only if it is currently mapped to some value
    `void` | `replace(K k, V v, long ttl, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `void` | `replaceIfPresent(K k, V oldValue, V newValue)` Replace the entry only if it is currently mapped to a specific value
    `void` | `replaceIfPresent(K k, V oldValue, V newValue, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `void` | `replaceIfPresent(K k, V oldValue, V newValue, long ttl)` Replace the entry only if it is currently mapped to a specific value
    `void` | `replaceIfPresent(K k, V oldValue, V newValue, long ttl, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `Single<Void>` | `rxClear()` Clear all entries in the map
    `Single<V>` | `rxGet(K k)` Get a value from the map, asynchronously.
    `Single<Void>` | `rxPut(K k, V v)` Put a value in the map, asynchronously.
    `Single<Void>` | `rxPut(K k, V v, long ttl)` Like `put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but specifying a time to live for the entry.
    `Single<V>` | `rxPutIfAbsent(K k, V v)` Put the entry only if there is no entry with the key already present.
    `Single<V>` | `rxPutIfAbsent(K k, V v, long ttl)` Link `putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>)` but specifying a time to live for the entry.
    `Single<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.
    `Single<V>` | `rxReplace(K k, V v)` Replace the entry only if it is currently mapped to some value
    `Single<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
    `void` | `size()` Provide the number of entries in the map
    `void` | `size(Handler<AsyncResult<Integer>> resultHandler)` Provide the number of entries in the map
    `String` | `toString()`

    - ### 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 void get(K k,
                          Handler<AsyncResult<V>> resultHandler)

      Get a value from the map, asynchronously.
      Parameters:
        `k` - the key
        `resultHandler` - - this will be called some time later with the async result.

    - #### get

          public void get(K k)

      Get a value from the map, asynchronously.
      Parameters:
        `k` - the key

    - #### rxGet

          public Single<V> rxGet(K k)

      Get a value from the map, asynchronously.
      Parameters:
        `k` - the key
      Returns:

    - #### put

          public void put(K k,
                          V v,
                          Handler<AsyncResult<Void>> completionHandler)

      Put a value in the map, asynchronously.
      Parameters:
        `k` - the key
        `v` - the value
        `completionHandler` - - this will be called some time later to signify the value has been put

    - #### put

          public void put(K k,
                          V v)

      Put a value in the map, asynchronously.
      Parameters:
        `k` - the key
        `v` - the value

    - #### rxPut

          public Single<Void> rxPut(K k,
                                    V v)

      Put a value in the map, asynchronously.
      Parameters:
        `k` - the key
        `v` - the value
      Returns:

    - #### put

          public void put(K k,
                          V v,
                          long ttl,
                          Handler<AsyncResult<Void>> completionHandler)

      Like `put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` 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
        `completionHandler` - the handler

    - #### put

          public void put(K k,
                          V v,
                          long ttl)

      Like `put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` 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

    - #### rxPut

          public Single<Void> rxPut(K k,
                                    V v,
                                    long ttl)

      Like `put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` 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:

    - #### putIfAbsent

          public void putIfAbsent(K k,
                                  V v,
                                  Handler<AsyncResult<V>> completionHandler)

      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
        `completionHandler` - the handler

    - #### putIfAbsent

          public void 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

    - #### rxPutIfAbsent

          public Single<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:

    - #### putIfAbsent

          public void putIfAbsent(K k,
                                  V v,
                                  long ttl,
                                  Handler<AsyncResult<V>> completionHandler)

      Link `putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<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
        `completionHandler` - the handler

    - #### putIfAbsent

          public void putIfAbsent(K k,
                                  V v,
                                  long ttl)

      Link `putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<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

    - #### rxPutIfAbsent

          public Single<V> rxPutIfAbsent(K k,
                                         V v,
                                         long ttl)

      Link `putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<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:

    - #### remove

          public void remove(K k,
                             Handler<AsyncResult<V>> resultHandler)

      Remove a value from the map, asynchronously.
      Parameters:
        `k` - the key
        `resultHandler` - - this will be called some time later to signify the value has been removed

    - #### remove

          public void remove(K k)

      Remove a value from the map, asynchronously.
      Parameters:
        `k` - the key

    - #### rxRemove

          public Single<V> rxRemove(K k)

      Remove a value from the map, asynchronously.
      Parameters:
        `k` - the key
      Returns:

    - #### removeIfPresent

          public void removeIfPresent(K k,
                                      V v,
                                      Handler<AsyncResult<Boolean>> resultHandler)

      Remove a value from the map, only if entry already exists with same value.
      Parameters:
        `k` - the key
        `v` - the value
        `resultHandler` - - this will be called some time later to signify the value has been removed

    - #### removeIfPresent

          public void 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

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

    - #### replace

          public void replace(K k,
                              V v,
                              Handler<AsyncResult<V>> resultHandler)

      Replace the entry only if it is currently mapped to some value
      Parameters:
        `k` - the key
        `v` - the new value
        `resultHandler` - the result handler will be passed the previous value

    - #### replace

          public void 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

    - #### rxReplace

          public Single<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:

    - #### replace

          public void replace(K k,
                              V v,
                              long ttl,
                              Handler<AsyncResult<V>> resultHandler)

      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
        `resultHandler` - the result handler will be passed the previous value

    - #### replace

          public void 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

    - #### rxReplace

          public Single<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:

    - #### replaceIfPresent

          public void replaceIfPresent(K k,
                                       V oldValue,
                                       V newValue,
                                       Handler<AsyncResult<Boolean>> resultHandler)

      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
        `resultHandler` - the result handler

    - #### replaceIfPresent

          public void 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

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

    - #### replaceIfPresent

          public void replaceIfPresent(K k,
                                       V oldValue,
                                       V newValue,
                                       long ttl,
                                       Handler<AsyncResult<Boolean>> resultHandler)

      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
        `resultHandler` - the result handler

    - #### replaceIfPresent

          public void 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

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

    - #### clear

          public void clear(Handler<AsyncResult<Void>> resultHandler)

      Clear all entries in the map
      Parameters:
        `resultHandler` - called on completion

    - #### clear

          public void clear()

      Clear all entries in the map

    - #### rxClear

          public Single<Void> rxClear()

      Clear all entries in the map
      Returns:

    - #### size

          public void size(Handler<AsyncResult<Integer>> resultHandler)

      Provide the number of entries in the map
      Parameters:
        `resultHandler` - handler which will receive the number of entries

    - #### size

          public void size()

      Provide the number of entries in the map

    - #### rxSize

          public Single<Integer> rxSize()

      Provide the number of entries in the map
      Returns:

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

Copyright © 2022 Eclipse. All rights reserved.