Package io.vertx.mutiny.core.shareddata

Class LocalMap<K,V>

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

    • LocalMap

      public LocalMap(io.vertx.core.shareddata.LocalMap delegate)

    • LocalMap

      public LocalMap(Object delegate, TypeArg<K> typeArg_0, TypeArg<V> typeArg_1)

    • LocalMap

      public LocalMap(io.vertx.core.shareddata.LocalMap delegate, TypeArg<K> typeArg_0, TypeArg<V> typeArg_1)

  • Method Details

    • getDelegate

      public io.vertx.core.shareddata.LocalMap getDelegate()
      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate used by this Mutiny object of generated type

    • 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

    • get

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

    • put

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

    • remove

      public V remove(Object key)
      Parameters:
      key - the key
      Returns:
      the old value

    • clear

      public void clear()

    • size

      public int size()
      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)
      Parameters:
      key - the key
      value - the value
      Returns:
      the old value or null, if none

    • removeIfPresent

      public boolean removeIfPresent(K key, V value)
      Parameters:
      key - the key
      value - the value
      Returns:
      true if removed

    • replaceIfPresent

      public boolean replaceIfPresent(K key, V oldValue, V newValue)
      Parameters:
      key - the key
      oldValue - the old value
      newValue - the new value
      Returns:
      true if removed

    • replace

      public V replace(K key, V value)
      Parameters:
      key - the key
      value - the new value
      Returns:
      the old value

    • close

      public void close()

    • containsKey

      public boolean containsKey(Object 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)
      Parameters:
      value - value whose presence in this map is to be tested
      Returns:

    • getOrDefault

      public V getOrDefault(Object key, V defaultValue)
      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(io.vertx.core.shareddata.LocalMap arg)

    • newInstance

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