Package io.vertx.reactivex.core.shareddata

Class LocalMap<K,V>

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

    • __TYPE_ARG

      public static final TypeArg<LocalMap> __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 LocalMap getDelegate()
      Specified by:
      getDelegate in interface 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(java.lang.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:

    • 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, TypeArg<K> __typeArg_K, TypeArg<V> __typeArg_V)