RMapAsync (Redisson 3.6.5 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
```
public interface RMapAsync<K,V>
extends RExpirableAsync
```
Async map functions

Author:

Nikita Koksharov

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`RFuture<V>`	`addAndGetAsync(K key, Number value)`
`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 specified`key`.
`RFuture<Long>`	`fastRemoveAsync(K... keys)` Removes `keys` from map by one operation in async manner.
`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 specified`key`.
`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 `key` from map and returns associated value in async manner.
`RFuture<Boolean>`	`removeAsync(Object key, Object value)` Removes `key` from map only if it associated with `value`.
`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()`
`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, isExistsAsync, migrateAsync, moveAsync, renameAsync, renamenxAsync, 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)
```
  - containsValueAsync
```
RFuture<Boolean> containsValueAsync(Object value)
```
  - containsKeyAsync
```
RFuture<Boolean> containsKeyAsync(Object key)
```
  - sizeAsync
```
RFuture<Integer> sizeAsync()
```
  - 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.
  - 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.

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

addAndGetAsync

containsValueAsync

containsKeyAsync

sizeAsync

fastRemoveAsync

fastPutAsync

fastPutIfAbsentAsync

readAllKeySetAsync

readAllValuesAsync

readAllEntrySetAsync

readAllMapAsync

getAsync

putAsync

removeAsync

replaceAsync

replaceAsync

removeAsync

putIfAbsentAsync