Package org.redisson.api

Interface RMapAsync<K,V>

Type Parameters:

K - key

V - value

All Superinterfaces:

RExpirableAsync, RObjectAsync

All Known Subinterfaces:

RLocalCachedMap<K,V>, RMap<K,V>, RMapCache<K,V>, RMapCacheAsync<K,V>

All Known Implementing Classes:

RedissonLocalCachedMap, RedissonMap, RedissonMapCache, RedissonTransactionalLocalCachedMap, RedissonTransactionalMap, RedissonTransactionalMapCache

public interface RMapAsync<K,V>
extends RExpirableAsync

Distributed async implementation of Map. This map doesn't allow to store null as key or value.

Author:

Nikita Koksharov

Method Summary

Modifier and Type	Method	Description
RFuture<V>	addAndGetAsync(K key, Number value)	Atomically adds the given delta to the current value by mapped key.
RFuture<Boolean>	containsKeyAsync(Object key)
RFuture<Boolean>	containsValueAsync(Object value)
RFuture<Boolean>	fastPutAsync(K key, V value)	Associates the specified value with the specified key in async manner.
RFuture<Boolean>	fastPutIfAbsentAsync(K key, V value)	Associates the specified value with the specified key only if there is no any association with specifiedkey.
RFuture<Long>	fastRemoveAsync(K... keys)	Removes keys from map by one operation in async manner.
RFuture<Boolean>	fastReplaceAsync(K key, V value)	Replaces previous value with a new value associated with the key.
RFuture<Map<K,V>>	getAllAsync(Set<K> keys)	Gets a map slice contained the mappings with defined keys by one operation.
RFuture<V>	getAsync(K key)	Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
RFuture<Void>	loadAllAsync(boolean replaceExistingValues, int parallelism)	Loads all map entries to this Redis map using MapLoader.
RFuture<Void>	loadAllAsync(Set<? extends K> keys, boolean replaceExistingValues, int parallelism)	Loads map entries using MapLoader whose keys are listed in defined keys parameter.
RFuture<Void>	putAllAsync(Map<? extends K,? extends V> map)	Associates the specified value with the specified key in batch.
RFuture<V>	putAsync(K key, V value)	Associates the specified value with the specified key in async manner.
RFuture<V>	putIfAbsentAsync(K key, V value)	Associates the specified value with the specified key only if there is no any association with specifiedkey.
RFuture<Set<Map.Entry<K,V>>>	readAllEntrySetAsync()	Read all map entries at once
RFuture<Set<K>>	readAllKeySetAsync()	Read all keys at once
RFuture<Map<K,V>>	readAllMapAsync()	Read all map as local instance at once
RFuture<Collection<V>>	readAllValuesAsync()	Read all values at once
RFuture<Boolean>	removeAsync(Object key, Object value)	Removes key from map only if it associated with value.
RFuture<V>	removeAsync(K key)	Removes key from map and returns associated value in async manner.
RFuture<V>	replaceAsync(K key, V value)	Replaces previous value with a new value associated with the key.
RFuture<Boolean>	replaceAsync(K key, V oldValue, V newValue)	Replaces previous oldValue with a newValue associated with the key.
RFuture<Integer>	sizeAsync()	Returns size of this map
RFuture<Integer>	valueSizeAsync(K key)	Returns size of value mapped by key in bytes

Methods inherited from interface org.redisson.api.RExpirableAsync

clearExpireAsync, expireAsync, expireAtAsync, expireAtAsync, remainTimeToLiveAsync

Methods inherited from interface org.redisson.api.RObjectAsync

copyAsync, deleteAsync, dumpAsync, isExistsAsync, migrateAsync, moveAsync, renameAsync, renamenxAsync, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, touchAsync, unlinkAsync

Method Detail

loadAllAsync

RFuture<Void> loadAllAsync(boolean replaceExistingValues,
                           int parallelism)

Loads all map entries to this Redis map using MapLoader.

Parameters:

replaceExistingValues - - true if existed values should be replaced, false otherwise.

parallelism - - parallelism level, used to increase speed of process execution

Returns:

void

loadAllAsync

RFuture<Void> loadAllAsync(Set<? extends K> keys,
                           boolean replaceExistingValues,
                           int parallelism)

Loads map entries using MapLoader whose keys are listed in defined keys parameter.

Parameters:

keys - - map keys

replaceExistingValues - - true if existed values should be replaced, false otherwise.

parallelism - - parallelism level, used to increase speed of process execution

Returns:

void

valueSizeAsync

RFuture<Integer> valueSizeAsync(K key)

Returns size of value mapped by key in bytes

Parameters:

key - - map key

Returns:

size of value

getAllAsync

RFuture<Map<K,V>> getAllAsync(Set<K> keys)

Gets a map slice contained the mappings with defined keys by one operation.

If map doesn't contain value/values for specified key/keys and MapLoader is defined then value/values will be loaded in read-through mode.

The returned map is NOT backed by the original map.

Parameters:

keys - - map keys

Returns:

Map slice

putAllAsync

RFuture<Void> putAllAsync(Map<? extends K,? extends V> map)

Associates the specified value with the specified key in batch.

If MapWriter is defined then new map entries are stored in write-through mode.

Parameters:

map - mappings to be stored in this map

Returns:

void

addAndGetAsync

RFuture<V> addAndGetAsync(K key,
                          Number value)

Atomically adds the given delta to the current value by mapped key. Works only for numeric values!

Parameters:

key - - map key

value - - delta the value to add

Returns:

the updated value

containsValueAsync

RFuture<Boolean> containsValueAsync(Object value)

containsKeyAsync

RFuture<Boolean> containsKeyAsync(Object key)

sizeAsync

RFuture<Integer> sizeAsync()

Returns size of this map

Returns:

size

fastRemoveAsync

RFuture<Long> fastRemoveAsync(K... keys)

Removes keys from map by one operation in async manner.

Works faster than removeAsync(Object, Object) but doesn't return the value associated with key.

If MapWriter is defined then keysare deleted in write-through mode.

Parameters:

keys - - map keys

Returns:

the number of keys that were removed from the hash, not including specified but non existing keys

fastPutAsync

RFuture<Boolean> fastPutAsync(K key,
                              V value)

Associates the specified value with the specified key in async manner.

Works faster than putAsync(Object, Object) but not returning the previous value associated with key

If MapWriter is defined then new map entry is stored in write-through mode.

Parameters:

key - - map key

value - - map value

Returns:

true if key is a new one in the hash and value was set. false if key already exists in the hash and the value was updated.

fastReplaceAsync

RFuture<Boolean> fastReplaceAsync(K key,
                                  V value)

Replaces previous value with a new value associated with the key.

Works faster than replaceAsync(Object, Object) but not returning the previous value associated with key

If MapWriter is defined then new map entry is stored in write-through mode.

Parameters:

key - - map key

value - - map value

Returns:

true if key exists and value was updated. false if key doesn't exists and value wasn't updated.

fastPutIfAbsentAsync

RFuture<Boolean> fastPutIfAbsentAsync(K key,
                                      V value)

Associates the specified value with the specified key only if there is no any association with specifiedkey.

Works faster than putIfAbsentAsync(Object, Object) but not returning the previous value associated with key

If MapWriter is defined then new map entry is stored in write-through mode.

Parameters:

key - - map key

value - - map value

Returns:

true if key is a new one in the hash and value was set. false if key already exists in the hash and change hasn't been made.

readAllKeySetAsync

RFuture<Set<K>> readAllKeySetAsync()

Read all keys at once

Returns:

keys

readAllValuesAsync

RFuture<Collection<V>> readAllValuesAsync()

Read all values at once

Returns:

values

readAllEntrySetAsync

RFuture<Set<Map.Entry<K,V>>> readAllEntrySetAsync()

Read all map entries at once

Returns:

entries

readAllMapAsync

RFuture<Map<K,V>> readAllMapAsync()

Read all map as local instance at once

Returns:

map

getAsync

RFuture<V> getAsync(K key)

Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.

If map doesn't contain value for specified key and MapLoader is defined then value will be loaded in read-through mode.

Parameters:

key - the key whose associated value is to be returned

Returns:

the value to which the specified key is mapped, or null if this map contains no mapping for the key

putAsync

RFuture<V> putAsync(K key,
                    V value)

Associates the specified value with the specified key in async manner.

If MapWriter is defined then new map entry is stored in write-through mode.

Parameters:

key - - map key

value - - map value

Returns:

previous associated value

removeAsync

RFuture<V> removeAsync(K key)

Removes key from map and returns associated value in async manner.

If MapWriter is defined then keyis deleted in write-through mode.

Parameters:

key - - map key

Returns:

deleted value or null if there wasn't any association

replaceAsync

RFuture<V> replaceAsync(K key,
                        V value)

Replaces previous value with a new value associated with the key. If there wasn't any association before then method returns null.

If MapWriter is defined then new valueis written in write-through mode.

Parameters:

key - - map key

value - - map value

Returns:

previous associated value or null if there wasn't any association and change hasn't been made

replaceAsync

RFuture<Boolean> replaceAsync(K key,
                              V oldValue,
                              V newValue)

Replaces previous oldValue with a newValue associated with the key. If previous value doesn't exist or equal to oldValue then method returns false.

If MapWriter is defined then newValueis written in write-through mode.

Parameters:

key - - map key

oldValue - - map old value

newValue - - map new value

Returns:

true if value has been replaced otherwise false.

removeAsync

RFuture<Boolean> removeAsync(Object key,
                             Object value)

Removes key from map only if it associated with value.

If MapWriter is defined then keyis deleted in write-through mode.

Parameters:

key - - map key

value - - map value

Returns:

true if map entry has been replaced otherwise false.

putIfAbsentAsync

RFuture<V> putIfAbsentAsync(K key,
                            V value)

Associates the specified value with the specified key only if there is no any association with specifiedkey.

If MapWriter is defined then new map entry is stored in write-through mode.

Parameters:

key - - map key

value - - map value

Returns:

null if key is a new one in the hash and value was set. Previous value if key already exists in the hash and change hasn't been made.