Package io.vertx.mutiny.core.shareddata

Class LocalMap<K,V>

java.lang.Object

io.vertx.mutiny.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 Mutiny-ified interface using Vert.x codegen.

Field Summary

Fields

Modifier and Type	Field	Description
static TypeArg<LocalMap>	__TYPE_ARG
TypeArg<K>	__typeArg_0
TypeArg<V>	__typeArg_1

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method	Description
void	clear()
void	close()
boolean	containsKey(Object key)
boolean	containsValue(Object value)
boolean	equals(Object o)
V	get(Object key)
io.vertx.core.shareddata.LocalMap	getDelegate()
V	getOrDefault(Object key, V defaultValue)
int	hashCode()
boolean	isEmpty()
static <K,V> LocalMap<K,V>	newInstance(io.vertx.core.shareddata.LocalMap arg)
static <K,V> LocalMap<K,V>	newInstance(io.vertx.core.shareddata.LocalMap arg, TypeArg<K> __typeArg_K, TypeArg<V> __typeArg_V)
V	put(K key, V value)
V	putIfAbsent(K key, V value)
V	remove(Object key)
boolean	removeIfPresent(K key, V value)
V	replace(K key, V value)
boolean	replaceIfPresent(K key, V oldValue, V newValue)
int	size()
String	toString()

Methods inherited from class java.lang.Object

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

Field Detail

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

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 Detail

getDelegate

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

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)