Class LocalMap<K,​V>


  • public class LocalMap<K,​V>
    extends Object
    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.

    • Constructor Detail

      • LocalMap

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

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

      • getDelegate

        public io.vertx.core.shareddata.LocalMap getDelegate()
      • 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)