Package io.vertx.rxjava3.core.shareddata

Class AsyncMap<K,V>

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

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

  • Constructor Summary

    Constructors
    Constructor
    Description
    AsyncMap(AsyncMap delegate)
     
    AsyncMap(Object delegate, TypeArg<K> typeArg_0, TypeArg<V> typeArg_1)
     

  • Method Summary

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

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

    • get

      public io.reactivex.rxjava3.core.Maybe<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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Completable 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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Completable 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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Maybe<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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Maybe<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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Maybe<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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Single<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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Maybe<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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Maybe<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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Single<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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Single<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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Completable clear()
      Clear all entries in the map
      Returns:
      a future notified some time later with the async result.

    • rxClear

      public io.reactivex.rxjava3.core.Completable rxClear()
      Clear all entries in the map
      Returns:
      a future notified some time later with the async result.

    • size

      public io.reactivex.rxjava3.core.Single<Integer> size()
      Provide the number of entries in the map
      Returns:
      a future notified some time later with the async result.

    • rxSize

      public io.reactivex.rxjava3.core.Single<Integer> rxSize()
      Provide the number of entries in the map
      Returns:
      a future notified some time later with the async result.

    • keys

      public io.reactivex.rxjava3.core.Single<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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Single<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 io.reactivex.rxjava3.core.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, TypeArg<K> __typeArg_K, TypeArg<V> __typeArg_V)