LocalMap (Vert.x Stack - Docs 4.3.8 API)

java.lang.Object
- io.vertx.rxjava.core.shareddata.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 RX-ified interface using Vert.x codegen.

Field Summary

Fields
Modifier and Type Field and 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

Fields
Modifier and Type	Field and 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 and 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 and 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()
```
  - 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:
    
    @{code true} if this map maps one or more keys to the specified value
  - 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)
```

Class LocalMap<K,V>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

__typeArg_0

__typeArg_1

Constructor Detail

LocalMap

LocalMap

Method Detail

toString

equals

hashCode

getDelegate

get

put

remove

clear

size

isEmpty

putIfAbsent

removeIfPresent

replaceIfPresent

replace

close

containsKey

containsValue

getOrDefault

newInstance

newInstance