Package io.vertx.reactivex.core.shareddata

Class 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 Detail

      • __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 Detail

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

      • 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(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,
                                                          io.vertx.lang.rx.TypeArg<K> __typeArg_K,
                                                          io.vertx.lang.rx.TypeArg<V> __typeArg_V)