org.redisson.core

Interface RMapAsync<K,V>

Type Parameters:

K - key

V - value

All Superinterfaces:

RExpirableAsync, RObjectAsync

All Known Subinterfaces:

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

All Known Implementing Classes:

RedissonMap, RedissonMapCache

public interface RMapAsync<K,V>
extends RExpirableAsync

Async map functions

Author:

Nikita Koksharov

Method Summary

Methods

Modifier and Type	Method and Description
io.netty.util.concurrent.Future<V>	addAndGetAsync(K key, Number value)
io.netty.util.concurrent.Future<Boolean>	containsKeyAsync(Object key)
io.netty.util.concurrent.Future<Boolean>	containsValueAsync(Object value)
io.netty.util.concurrent.Future<Boolean>	fastPutAsync(K key, V value) Associates the specified value with the specified key in async manner.
io.netty.util.concurrent.Future<Long>	fastRemoveAsync(K... keys) Removes keys from map by one operation in async manner Works faster than RMap.removeAsync but not returning the value associated with key
io.netty.util.concurrent.Future<Map<K,V>>	getAllAsync(Set<K> keys)
io.netty.util.concurrent.Future<V>	getAsync(K key)
io.netty.util.concurrent.Future<Void>	putAllAsync(Map<? extends K,? extends V> map)
io.netty.util.concurrent.Future<V>	putAsync(K key, V value)
io.netty.util.concurrent.Future<V>	putIfAbsentAsync(K key, V value)
io.netty.util.concurrent.Future<V>	removeAsync(K key)
io.netty.util.concurrent.Future<Long>	removeAsync(Object key, Object value)
io.netty.util.concurrent.Future<V>	replaceAsync(K key, V value)
io.netty.util.concurrent.Future<Boolean>	replaceAsync(K key, V oldValue, V newValue)
io.netty.util.concurrent.Future<Integer>	sizeAsync()

Methods inherited from interface org.redisson.core.RExpirableAsync

clearExpireAsync, expireAsync, expireAtAsync, expireAtAsync, remainTimeToLiveAsync

Methods inherited from interface org.redisson.core.RObjectAsync

deleteAsync, isExistsAsync, migrateAsync, moveAsync, renameAsync, renamenxAsync

Method Detail

getAllAsync

io.netty.util.concurrent.Future<Map<K,V>> getAllAsync(Set<K> keys)

putAllAsync

io.netty.util.concurrent.Future<Void> putAllAsync(Map<? extends K,? extends V> map)

addAndGetAsync

io.netty.util.concurrent.Future<V> addAndGetAsync(K key,
                                                Number value)

containsValueAsync

io.netty.util.concurrent.Future<Boolean> containsValueAsync(Object value)

containsKeyAsync

io.netty.util.concurrent.Future<Boolean> containsKeyAsync(Object key)

sizeAsync

io.netty.util.concurrent.Future<Integer> sizeAsync()

fastRemoveAsync

io.netty.util.concurrent.Future<Long> fastRemoveAsync(K... keys)

Removes keys from map by one operation in async manner Works faster than RMap.removeAsync but not returning the value associated with key

Parameters:

keys -

Returns:

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

fastPutAsync

io.netty.util.concurrent.Future<Boolean> fastPutAsync(K key,
                                                    V value)

Associates the specified value with the specified key in async manner. Works faster than RMap.putAsync but not returning the previous value associated with key

Parameters:

key -

value -

Returns:

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

getAsync

io.netty.util.concurrent.Future<V> getAsync(K key)

putAsync

io.netty.util.concurrent.Future<V> putAsync(K key,
                                          V value)

removeAsync

io.netty.util.concurrent.Future<V> removeAsync(K key)

replaceAsync

io.netty.util.concurrent.Future<V> replaceAsync(K key,
                                              V value)

replaceAsync

io.netty.util.concurrent.Future<Boolean> replaceAsync(K key,
                                                    V oldValue,
                                                    V newValue)

removeAsync

io.netty.util.concurrent.Future<Long> removeAsync(Object key,
                                                Object value)

putIfAbsentAsync

io.netty.util.concurrent.Future<V> putIfAbsentAsync(K key,
                                                  V value)