Package io.vertx.reactivex.core.shareddata

## Class LocalMap<K,​V>

- java.lang.Object
- - io.vertx.reactivex.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 io.vertx.lang.rx.TypeArg<LocalMap>` | `__TYPE_ARG` |
    `io.vertx.lang.rx.TypeArg<K>` | `__typeArg_0` |
    `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

    All Methods Static Methods Instance Methods Concrete Methods
    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 java.lang.Object

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

- - ### 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

    - #### 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(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)