org.redisson.api

Interface RMapReactive<K,V>

Type Parameters:

K - key

V - value

All Superinterfaces:

RExpirableReactive, RObjectReactive

All Known Subinterfaces:

RMapCacheReactive<K,V>

public interface RMapReactive<K,V>
extends RExpirableReactive

map functions

Author:

Nikita Koksharov

Method Summary

Modifier and Type	Method and Description
reactor.core.publisher.Mono<V>	addAndGet(K key, Number value)
reactor.core.publisher.Mono<Boolean>	containsKey(Object key)
reactor.core.publisher.Mono<Boolean>	containsValue(Object value)
reactor.core.publisher.Flux<Map.Entry<K,V>>	entryIterator() Returns iterator over map entries collection.
reactor.core.publisher.Flux<Map.Entry<K,V>>	entryIterator(int count) Returns iterator over map entries collection.
reactor.core.publisher.Flux<Map.Entry<K,V>>	entryIterator(String pattern) Returns iterator over map entries collection.
reactor.core.publisher.Flux<Map.Entry<K,V>>	entryIterator(String pattern, int count) Returns iterator over map entries collection.
reactor.core.publisher.Mono<Boolean>	fastPut(K key, V value) Associates the specified value with the specified key in async manner.
reactor.core.publisher.Mono<Boolean>	fastPutIfAbsent(K key, V value) Associates the specified value with the specified key only if there is no any association with specifiedkey.
reactor.core.publisher.Mono<Long>	fastRemove(K... keys) Removes keys from map by one operation in async manner.
reactor.core.publisher.Mono<V>	get(K key) Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
reactor.core.publisher.Mono<Map<K,V>>	getAll(Set<K> keys) Gets a map slice contained the mappings with defined keys by one operation.
RLockReactive	getFairLock(K key) Returns RLock instance associated with key
RLockReactive	getLock(K key) Returns RLock instance associated with key
RPermitExpirableSemaphoreReactive	getPermitExpirableSemaphore(K key) Returns RPermitExpirableSemaphore instance associated with key
RReadWriteLockReactive	getReadWriteLock(K key) Returns RReadWriteLock instance associated with key
RSemaphoreReactive	getSemaphore(K key) Returns RSemaphore instance associated with key
reactor.core.publisher.Flux<K>	keyIterator() Returns iterator over key set of this map.
reactor.core.publisher.Flux<K>	keyIterator(int count) Returns iterator over key set of this map.
reactor.core.publisher.Flux<K>	keyIterator(String pattern) Returns iterator over key set of this map.
reactor.core.publisher.Flux<K>	keyIterator(String pattern, int count) Returns iterator over key set of this map.
reactor.core.publisher.Mono<Void>	loadAll(boolean replaceExistingValues, int parallelism) Loads all map entries to this Redis map using MapLoader.
reactor.core.publisher.Mono<Void>	loadAll(Set<? extends K> keys, boolean replaceExistingValues, int parallelism) Loads map entries using MapLoader whose keys are listed in defined keys parameter.
reactor.core.publisher.Mono<V>	put(K key, V value) Associates the specified value with the specified key in async manner.
reactor.core.publisher.Mono<Void>	putAll(Map<? extends K,? extends V> map) Associates the specified value with the specified key in batch.
reactor.core.publisher.Mono<V>	putIfAbsent(K key, V value) Associates the specified value with the specified key only if there is no any association with specifiedkey.
reactor.core.publisher.Mono<Set<Map.Entry<K,V>>>	readAllEntrySet() Read all map entries at once
reactor.core.publisher.Mono<Set<K>>	readAllKeySet() Read all keys at once
reactor.core.publisher.Mono<Map<K,V>>	readAllMap() Read all map as local instance at once
reactor.core.publisher.Mono<Collection<V>>	readAllValues() Read all values at once
reactor.core.publisher.Mono<V>	remove(K key) Removes key from map and returns associated value in async manner.
reactor.core.publisher.Mono<Boolean>	remove(Object key, Object value) Removes key from map only if it associated with value.
reactor.core.publisher.Mono<V>	replace(K key, V value) Replaces previous value with a new value associated with the key.
reactor.core.publisher.Mono<Boolean>	replace(K key, V oldValue, V newValue) Replaces previous oldValue with a newValue associated with the key.
reactor.core.publisher.Mono<Integer>	size()
reactor.core.publisher.Flux<V>	valueIterator() Returns iterator over values collection of this map.
reactor.core.publisher.Flux<V>	valueIterator(int count) Returns iterator over values collection of this map.
reactor.core.publisher.Flux<V>	valueIterator(String pattern) Returns iterator over values collection of this map.
reactor.core.publisher.Flux<V>	valueIterator(String pattern, int count) Returns iterator over values collection of this map.
reactor.core.publisher.Mono<Integer>	valueSize(K key) Returns size of value mapped by key in bytes

Methods inherited from interface org.redisson.api.RExpirableReactive

clearExpire, expire, expireAt, expireAt, remainTimeToLive

Methods inherited from interface org.redisson.api.RObjectReactive

copy, delete, dump, getCodec, getName, isExists, migrate, move, rename, renamenx, restore, restore, restoreAndReplace, restoreAndReplace, touch, unlink

Method Detail

loadAll

reactor.core.publisher.Mono<Void> loadAll(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

loadAll

reactor.core.publisher.Mono<Void> loadAll(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

valueSize

reactor.core.publisher.Mono<Integer> valueSize(K key)

Returns size of value mapped by key in bytes

Parameters:

key - - map key

Returns:

size of value

getAll

reactor.core.publisher.Mono<Map<K,V>> getAll(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

putAll

reactor.core.publisher.Mono<Void> putAll(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

addAndGet

reactor.core.publisher.Mono<V> addAndGet(K key,
                                         Number value)

containsValue

reactor.core.publisher.Mono<Boolean> containsValue(Object value)

containsKey

reactor.core.publisher.Mono<Boolean> containsKey(Object key)

size

reactor.core.publisher.Mono<Integer> size()

fastRemove

reactor.core.publisher.Mono<Long> fastRemove(K... keys)

Removes keys from map by one operation in async manner.

Works faster than remove(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

fastPut

reactor.core.publisher.Mono<Boolean> fastPut(K key,
                                             V value)

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

Works faster than put(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.

fastPutIfAbsent

reactor.core.publisher.Mono<Boolean> fastPutIfAbsent(K key,
                                                     V value)

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

Works faster than putIfAbsent(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.

readAllKeySet

reactor.core.publisher.Mono<Set<K>> readAllKeySet()

Read all keys at once

Returns:

keys

readAllValues

reactor.core.publisher.Mono<Collection<V>> readAllValues()

Read all values at once

Returns:

values

readAllEntrySet

reactor.core.publisher.Mono<Set<Map.Entry<K,V>>> readAllEntrySet()

Read all map entries at once

Returns:

entries

readAllMap

reactor.core.publisher.Mono<Map<K,V>> readAllMap()

Read all map as local instance at once

Returns:

map

get

reactor.core.publisher.Mono<V> get(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

put

reactor.core.publisher.Mono<V> put(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

remove

reactor.core.publisher.Mono<V> remove(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

replace

reactor.core.publisher.Mono<V> replace(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

replace

reactor.core.publisher.Mono<Boolean> replace(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.

remove

reactor.core.publisher.Mono<Boolean> remove(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.

putIfAbsent

reactor.core.publisher.Mono<V> putIfAbsent(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.

entryIterator

reactor.core.publisher.Flux<Map.Entry<K,V>> entryIterator()

Returns iterator over map entries collection. Map entries are loaded in batch. Batch size is 10.

Returns:

iterator

See Also:

readAllEntrySet()

entryIterator

reactor.core.publisher.Flux<Map.Entry<K,V>> entryIterator(int count)

Returns iterator over map entries collection. Map entries are loaded in batch. Batch size is defined by count param.

Parameters:

count - - size of entries batch

Returns:

iterator

See Also:

readAllEntrySet()

entryIterator

reactor.core.publisher.Flux<Map.Entry<K,V>> entryIterator(String pattern)

Returns iterator over map entries collection. Map entries are loaded in batch. Batch size is 10. If keyPattern is not null then only entries mapped by matched keys of this pattern are loaded. Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Parameters:

pattern - - key pattern

Returns:

iterator

See Also:

readAllEntrySet()

entryIterator

reactor.core.publisher.Flux<Map.Entry<K,V>> entryIterator(String pattern,
                                                          int count)

Returns iterator over map entries collection. Map entries are loaded in batch. Batch size is defined by count param. If keyPattern is not null then only entries mapped by matched keys of this pattern are loaded. Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Parameters:

pattern - - key pattern

count - - size of entries batch

Returns:

iterator

See Also:

readAllEntrySet()

valueIterator

reactor.core.publisher.Flux<V> valueIterator()

Returns iterator over values collection of this map. Values are loaded in batch. Batch size is 10.

Returns:

iterator

See Also:

readAllValues()

valueIterator

reactor.core.publisher.Flux<V> valueIterator(int count)

Returns iterator over values collection of this map. Values are loaded in batch. Batch size is defined by count param.

Parameters:

count - - size of values batch

Returns:

iterator

See Also:

readAllValues()

valueIterator

reactor.core.publisher.Flux<V> valueIterator(String pattern)

Returns iterator over values collection of this map. Values are loaded in batch. Batch size is 10. If keyPattern is not null then only values mapped by matched keys of this pattern are loaded. Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Parameters:

pattern - - key pattern

Returns:

iterator

See Also:

readAllValues()

valueIterator

reactor.core.publisher.Flux<V> valueIterator(String pattern,
                                             int count)

Returns iterator over values collection of this map. Values are loaded in batch. Batch size is defined by count param. If keyPattern is not null then only values mapped by matched keys of this pattern are loaded. Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Parameters:

pattern - - key pattern

count - - size of values batch

Returns:

iterator

See Also:

readAllValues()

keyIterator

reactor.core.publisher.Flux<K> keyIterator()

Returns iterator over key set of this map. Keys are loaded in batch. Batch size is 10.

Returns:

iterator

See Also:

readAllKeySet()

keyIterator

reactor.core.publisher.Flux<K> keyIterator(int count)

Returns iterator over key set of this map. Keys are loaded in batch. Batch size is defined by count param.

Parameters:

count - - size of keys batch

Returns:

iterator

See Also:

readAllKeySet()

keyIterator

reactor.core.publisher.Flux<K> keyIterator(String pattern)

Returns iterator over key set of this map. If pattern is not null then only keys match this pattern are loaded. Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Parameters:

pattern - - key pattern

Returns:

iterator

See Also:

readAllKeySet()

keyIterator

reactor.core.publisher.Flux<K> keyIterator(String pattern,
                                           int count)

Returns iterator over key set of this map. If pattern is not null then only keys match this pattern are loaded. Keys are loaded in batch. Batch size is defined by count param. Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Parameters:

pattern - - key pattern

count - - size of keys batch

Returns:

iterator

See Also:

readAllKeySet()

getPermitExpirableSemaphore

RPermitExpirableSemaphoreReactive getPermitExpirableSemaphore(K key)

Returns RPermitExpirableSemaphore instance associated with key

Parameters:

key - - map key

Returns:

permitExpirableSemaphore

getSemaphore

RSemaphoreReactive getSemaphore(K key)

Returns RSemaphore instance associated with key

Parameters:

key - - map key

Returns:

semaphore

getFairLock

RLockReactive getFairLock(K key)

Returns RLock instance associated with key

Parameters:

key - - map key

Returns:

fairLock

getReadWriteLock

RReadWriteLockReactive getReadWriteLock(K key)

Returns RReadWriteLock instance associated with key

Parameters:

key - - map key

Returns:

readWriteLock

getLock

RLockReactive getLock(K key)

Returns RLock instance associated with key

Parameters:

key - - map key

Returns:

lock