Class AsyncMap<K,V>

java.lang.Object
io.vertx.reactivex.core.shareddata.AsyncMap<K,V>
All Implemented Interfaces:
io.vertx.lang.rx.RxDelegate
public class AsyncMap<K,V> extends Object implements io.vertx.lang.rx.RxDelegate
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 Details

    • __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 Details

    • 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 Details

    • 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()
      Specified by:
      getDelegate in interface io.vertx.lang.rx.RxDelegate

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