Class LocalMap<K,V>

java.lang.Object
io.vertx.rxjava3.core.shareddata.LocalMap<K,V>
All Implemented Interfaces:
io.vertx.lang.rx.RxDelegate
public class LocalMap<K,V> extends Object implements io.vertx.lang.rx.RxDelegate
Local maps can be used to share data safely in a single Vert.x instance.

By default the map allows immutable keys and values. Custom keys and values should implement Shareable interface. The map returns their copies.

This ensures there is no shared access to mutable state from different threads (e.g. different event loops) in the Vert.x instance, and means you don't have to protect access to that state using synchronization or locks.

Since the version 3.4, this class extends the interface. However some methods are only accessible in Java.

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 io.vertx.lang.rx.TypeArg<LocalMap>
    __TYPE_ARG
     
    final io.vertx.lang.rx.TypeArg<K>
    __typeArg_0
     
    final io.vertx.lang.rx.TypeArg<V>
    __typeArg_1
     

  • Constructor Summary

    Constructors
    Constructor
    Description
    LocalMap(LocalMap delegate)
     
    LocalMap(Object delegate, io.vertx.lang.rx.TypeArg<K> typeArg_0, io.vertx.lang.rx.TypeArg<V> typeArg_1)
     

  • Method Summary

    Modifier and Type
    Method
    Description
    void
    clear()
    Clear all entries in the map
    void
    close()
    Close and release the map
    boolean
    containsKey(Object key)
    Returns true if this map contains a mapping for the specified key.
    boolean
    containsValue(Object value)
    Returns @{code true} if this map maps one or more keys to the specified value.
    boolean
    equals(Object o)
     
    V
    get(Object key)
    Get a value from the map
    LocalMap
    getDelegate()
     
    V
    getOrDefault(Object key, V defaultValue)
    Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.
    int
    hashCode()
     
    boolean
    isEmpty()
     
    static <K,V> LocalMap<K,V>
    newInstance(LocalMap arg)
     
    static <K,V> LocalMap<K,V>
    newInstance(LocalMap arg, io.vertx.lang.rx.TypeArg<K> __typeArg_K, io.vertx.lang.rx.TypeArg<V> __typeArg_V)
     
    V
    put(K key, V value)
    Put an entry in the map
    V
    putIfAbsent(K key, V value)
    Put the entry only if there is no existing entry for that key
    V
    remove(Object key)
    Remove an entry from the map
    boolean
    removeIfPresent(K key, V value)
    Remove the entry only if there is an entry with the specified key and value.
    V
    replace(K key, V value)
    Replace the entry only if there is an existing entry with the key
    boolean
    replaceIfPresent(K key, V oldValue, V newValue)
    Replace the entry only if there is an existing entry with the specified key and value.
    int
    size()
    Get the size of the map
    String
    toString()
     

    Methods inherited from class Object

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

  • Field Details

    • __TYPE_ARG

      public static final io.vertx.lang.rx.TypeArg<LocalMap> __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

    • LocalMap

      public LocalMap(LocalMap delegate)

    • LocalMap

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

    • get

      public V get(Object key)
      Get a value from the map
      Parameters:
      key - the key
      Returns:
      the value, or null if none

    • put

      public V put(K key, V value)
      Put an entry in the map
      Parameters:
      key - the key
      value - the value
      Returns:
      return the old value, or null if none

    • remove

      public V remove(Object key)
      Remove an entry from the map
      Parameters:
      key - the key
      Returns:
      the old value

    • clear

      public void clear()
      Clear all entries in the map

    • size

      public int size()
      Get the size of the map
      Returns:
      the number of entries in the map

    • isEmpty

      public boolean isEmpty()
      Returns:
      true if there are zero entries in the map

    • putIfAbsent

      public V putIfAbsent(K key, V value)
      Put the entry only if there is no existing entry for that key
      Parameters:
      key - the key
      value - the value
      Returns:
      the old value or null, if none

    • removeIfPresent

      public boolean removeIfPresent(K key, V value)
      Remove the entry only if there is an entry with the specified key and value.

      This method is the poyglot version of remove(Object).

      Parameters:
      key - the key
      value - the value
      Returns:
      true if removed

    • replaceIfPresent

      public boolean replaceIfPresent(K key, V oldValue, V newValue)
      Replace the entry only if there is an existing entry with the specified key and value.

      This method is the polyglot version of replace(K, V).

      Parameters:
      key - the key
      oldValue - the old value
      newValue - the new value
      Returns:
      true if removed

    • replace

      public V replace(K key, V value)
      Replace the entry only if there is an existing entry with the key
      Parameters:
      key - the key
      value - the new value
      Returns:
      the old value

    • close

      public void close()
      Close and release the map

    • containsKey

      public boolean containsKey(Object key)
      Returns true if this map contains a mapping for the specified key.
      Parameters:
      key - key whose presence in this map is to be tested
      Returns:
      true if this map contains a mapping for the specified key

    • containsValue

      public boolean containsValue(Object value)
      Returns @{code true} if this map maps one or more keys to the specified value.
      Parameters:
      value - value whose presence in this map is to be tested
      Returns:
      @{code true} if this map maps one or more keys to the specified value

    • getOrDefault

      public V getOrDefault(Object key, V defaultValue)
      Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.
      Parameters:
      key - the key whose associated value is to be returned
      defaultValue - the default mapping of the key
      Returns:
      the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key

    • newInstance

      public static <K,V> LocalMap<K,V> newInstance(LocalMap arg)

    • newInstance

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