RMapAsync (Redisson 3.13.0 API)

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
```
Async interface for Redis based implementation of ConcurrentMap and Map
This map uses serialized state of key instead of hashCode or equals methods. This map doesn't allow to store null as key or value.

Author:

Nikita Koksharov

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`RFuture<V>`	`addAndGetAsync(K key, Number delta)` Adds the given `delta` to the current value by mapped `key`.
`RFuture<Boolean>`	`containsKeyAsync(Object key)` Returns `true` if this map contains map entry mapped by specified `key`, otherwise `false`
`RFuture<Boolean>`	`containsValueAsync(Object value)` Returns `true` if this map contains any map entry with specified `value`, otherwise `false`
`RFuture<Boolean>`	`fastPutAsync(K key, V value)` Stores the specified `value` mapped by specified `key`.
`RFuture<Boolean>`	`fastPutIfAbsentAsync(K key, V value)` Stores the specified `value` mapped by specified `key` only if there is no value with specified`key` stored before.
`RFuture<Long>`	`fastRemoveAsync(K... keys)` Removes map entries mapped by specified `keys`.
`RFuture<Boolean>`	`fastReplaceAsync(K key, V value)` Replaces previous value with a new `value` mapped by specified `key`.
`RFuture<Map<K,V>>`	`getAllAsync(Set<K> keys)` Returns map slice contained the mappings with defined `keys`.
`RFuture<V>`	`getAsync(K key)` Returns the value mapped by defined `key` or `null` if value is absent.
`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)` Stores map entries specified in `map` object in batch mode.
`RFuture<Void>`	`putAllAsync(Map<? extends K,? extends V> map, int batchSize)` Stores map entries specified in `map` object in batch mode.
`RFuture<V>`	`putAsync(K key, V value)` Stores the specified `value` mapped by specified `key`.
`RFuture<V>`	`putIfAbsentAsync(K key, V value)` Stores the specified `value` mapped by specified `key` only if there is no value with specified`key` stored before.
`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<V>`	`removeAsync(K key)` Removes map entry by specified `key` and returns value.
`RFuture<Boolean>`	`removeAsync(Object key, Object value)` Removes map entry only if it exists with specified `key` and `value`.
`RFuture<V>`	`replaceAsync(K key, V value)` Replaces previous value with a new `value` mapped by specified `key`.
`RFuture<Boolean>`	`replaceAsync(K key, V oldValue, V newValue)` Replaces previous `oldValue` with a `newValue` mapped by specified `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
addListenerAsync, copyAsync, deleteAsync, dumpAsync, isExistsAsync, migrateAsync, moveAsync, removeListenerAsync, renameAsync, renamenxAsync, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, sizeInMemoryAsync, 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)
```
    Returns map slice contained the mappings with defined keys.
    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)
```
    Stores map entries specified in map object in batch mode.
    If MapWriter is defined then map entries will be stored in write-through mode.
    
    Parameters:
    
    map - mappings to be stored in this map
    
    Returns:
    
    void
  - putAllAsync
```
RFuture<Void> putAllAsync(Map<? extends K,? extends V> map,
                          int batchSize)
```
    Stores map entries specified in map object in batch mode. Batch inserted by chunks limited by batchSize value to avoid OOM and/or Redis response timeout error for map with big size.
    If MapWriter is defined then map entries are stored in write-through mode.
    
    Parameters:
    
    map - mappings to be stored in this map
    
    batchSize - - size of map entries batch
    
    Returns:
    
    void
  - addAndGetAsync
```
RFuture<V> addAndGetAsync(K key,
                          Number delta)
```
    Adds the given delta to the current value by mapped key. Works only for numeric values!
    
    Parameters:
    
    key - - map key
    
    delta - the value to add
    
    Returns:
    
    the updated value
  - containsValueAsync
```
RFuture<Boolean> containsValueAsync(Object value)
```
    Returns true if this map contains any map entry with specified value, otherwise false
    
    Parameters:
    
    value - - map value
    
    Returns:
    
    true if this map contains any map entry with specified value, otherwise false
  - containsKeyAsync
```
RFuture<Boolean> containsKeyAsync(Object key)
```
    Returns true if this map contains map entry mapped by specified key, otherwise false
    
    Parameters:
    
    key - - map key
    
    Returns:
    
    true if this map contains map entry mapped by specified key, otherwise false
  - sizeAsync
```
RFuture<Integer> sizeAsync()
```
    Returns size of this map
    
    Returns:
    
    size
  - fastRemoveAsync
```
RFuture<Long> fastRemoveAsync(K... keys)
```
    Removes map entries mapped by specified keys.
    Works faster than removeAsync(Object) but not returning the value.
    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)
```
    Stores the specified value mapped by specified key.
    Works faster than putAsync(Object, Object) but not returning previous value.
    Returns true if key is a new key in the hash and value was set or false if key already exists in the hash and the value was updated.
    If MapWriter is defined then map entry is stored in write-through mode.
    
    Parameters:
    
    key - - map key
    
    value - - map 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.
  - fastReplaceAsync
```
RFuture<Boolean> fastReplaceAsync(K key,
                                  V value)
```
    Replaces previous value with a new value mapped by specified key.
    Works faster than replaceAsync(Object, Object) but not returning the previous value.
    Returns true if key exists and value was updated or false if key doesn't exists and value wasn't updated.
    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)
```
    Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.
    Returns true if key is a new one in the hash and value was set or false if key already exists in the hash and change hasn't been made.
    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 mapped by defined key or null if value is absent.
    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
    
    Returns:
    
    the value mapped by defined key or null if value is absent
  - putAsync
```
RFuture<V> putAsync(K key,
                    V value)
```
    Stores the specified value mapped by specified key. Returns previous value if map entry with specified key already existed.
    If MapWriter is defined then 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 map entry by specified key and returns value.
    If MapWriter is defined then keyis deleted in write-through mode.
    
    Parameters:
    
    key - - map key
    
    Returns:
    
    deleted value, null if map entry doesn't exist
  - replaceAsync
```
RFuture<V> replaceAsync(K key,
                        V value)
```
    Replaces previous value with a new value mapped by specified key. Returns null if there is no map entry stored before and doesn't store new map entry.
    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 is no map entry stored before and doesn't store new map entry
  - replaceAsync
```
RFuture<Boolean> replaceAsync(K key,
                              V oldValue,
                              V newValue)
```
    Replaces previous oldValue with a newValue mapped by specified key. Returns false if previous value doesn't exist or equal to oldValue.
    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 map entry only if it exists with specified key and 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 removed otherwise false.
  - putIfAbsentAsync
```
RFuture<V> putIfAbsentAsync(K key,
                            V value)
```
    Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.
    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.

Interface RMapAsync<K,V>

Method Summary

Methods inherited from interface org.redisson.api.RExpirableAsync

Methods inherited from interface org.redisson.api.RObjectAsync

Method Detail

loadAllAsync

loadAllAsync

valueSizeAsync

getAllAsync

putAllAsync

putAllAsync

addAndGetAsync

containsValueAsync

containsKeyAsync

sizeAsync

fastRemoveAsync

fastPutAsync

fastReplaceAsync

fastPutIfAbsentAsync

readAllKeySetAsync

readAllValuesAsync

readAllEntrySetAsync

readAllMapAsync

getAsync

putAsync

removeAsync

replaceAsync

replaceAsync

removeAsync

putIfAbsentAsync