org.redisson.api

Interface RMapRx<K,V>

Type Parameters:

K - key

V - value

All Superinterfaces:

RExpirableRx, RObjectRx

All Known Subinterfaces:

RMapCacheRx<K,V>

public interface RMapRx<K,V>
extends RExpirableRx

RxJava2 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

Modifier and Type	Method and Description
io.reactivex.Single<V>	addAndGet(K key, Number delta) Adds the given delta to the current value by mapped key.
io.reactivex.Single<Boolean>	containsKey(Object key) Returns true if this map contains map entry mapped by specified key, otherwise false
io.reactivex.Single<Boolean>	containsValue(Object value) Returns true if this map contains any map entry with specified value, otherwise false
io.reactivex.Flowable<Map.Entry<K,V>>	entryIterator() Returns iterator over map entries collection.
io.reactivex.Flowable<Map.Entry<K,V>>	entryIterator(int count) Returns iterator over map entries collection.
io.reactivex.Flowable<Map.Entry<K,V>>	entryIterator(String pattern) Returns iterator over map entries collection.
io.reactivex.Flowable<Map.Entry<K,V>>	entryIterator(String pattern, int count) Returns iterator over map entries collection.
io.reactivex.Single<Boolean>	fastPut(K key, V value) Stores the specified value mapped by specified key.
io.reactivex.Single<Boolean>	fastPutIfAbsent(K key, V value) Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.
io.reactivex.Single<Long>	fastRemove(K... keys) Removes map entries mapped by specified keys.
io.reactivex.Maybe<V>	get(K key) Returns the value mapped by defined key or null if value is absent.
io.reactivex.Single<Map<K,V>>	getAll(Set<K> keys) Returns map slice contained the mappings with defined keys.
RLockRx	getFairLock(K key) Returns RLock instance associated with key
RLockRx	getLock(K key) Returns RLock instance associated with key
RPermitExpirableSemaphoreRx	getPermitExpirableSemaphore(K key) Returns RPermitExpirableSemaphore instance associated with key
RReadWriteLockRx	getReadWriteLock(K key) Returns RReadWriteLock instance associated with key
RSemaphoreRx	getSemaphore(K key) Returns RSemaphore instance associated with key
io.reactivex.Flowable<K>	keyIterator() Returns iterator over key set of this map.
io.reactivex.Flowable<K>	keyIterator(int count) Returns iterator over key set of this map.
io.reactivex.Flowable<K>	keyIterator(String pattern) Returns iterator over key set of this map.
io.reactivex.Flowable<K>	keyIterator(String pattern, int count) Returns iterator over key set of this map.
io.reactivex.Completable	loadAll(boolean replaceExistingValues, int parallelism) Loads all map entries to this Redis map using MapLoader.
io.reactivex.Completable	loadAll(Set<? extends K> keys, boolean replaceExistingValues, int parallelism) Loads map entries using MapLoader whose keys are listed in defined keys parameter.
io.reactivex.Maybe<V>	put(K key, V value) Stores the specified value mapped by specified key.
io.reactivex.Completable	putAll(Map<? extends K,? extends V> map) Stores map entries specified in map object in batch mode.
io.reactivex.Maybe<V>	putIfAbsent(K key, V value) Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.
io.reactivex.Single<Set<Map.Entry<K,V>>>	readAllEntrySet() Read all map entries at once
io.reactivex.Single<Set<K>>	readAllKeySet() Read all keys at once
io.reactivex.Single<Map<K,V>>	readAllMap() Read all map as local instance at once
io.reactivex.Single<Collection<V>>	readAllValues() Read all values at once
io.reactivex.Maybe<V>	remove(K key) Removes map entry by specified key and returns value.
io.reactivex.Single<Boolean>	remove(Object key, Object value) Removes map entry only if it exists with specified key and value.
io.reactivex.Maybe<V>	replace(K key, V value) Replaces previous value with a new value mapped by specified key.
io.reactivex.Single<Boolean>	replace(K key, V oldValue, V newValue) Replaces previous oldValue with a newValue mapped by specified key.
io.reactivex.Single<Integer>	size() Returns size of this map
io.reactivex.Flowable<V>	valueIterator() Returns iterator over values collection of this map.
io.reactivex.Flowable<V>	valueIterator(int count) Returns iterator over values collection of this map.
io.reactivex.Flowable<V>	valueIterator(String pattern) Returns iterator over values collection of this map.
io.reactivex.Flowable<V>	valueIterator(String pattern, int count) Returns iterator over values collection of this map.
io.reactivex.Single<Integer>	valueSize(K key) Returns size of value mapped by key in bytes

Methods inherited from interface org.redisson.api.RExpirableRx

clearExpire, expire, expireAt, expireAt, remainTimeToLive

Methods inherited from interface org.redisson.api.RObjectRx

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

Method Detail

loadAll

io.reactivex.Completable 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

io.reactivex.Completable 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

io.reactivex.Single<Integer> valueSize(K key)

Returns size of value mapped by key in bytes

Parameters:

key - - map key

Returns:

size of value

getAll

io.reactivex.Single<Map<K,V>> getAll(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

putAll

io.reactivex.Completable putAll(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

addAndGet

io.reactivex.Single<V> addAndGet(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

containsValue

io.reactivex.Single<Boolean> containsValue(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

containsKey

io.reactivex.Single<Boolean> containsKey(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

size

io.reactivex.Single<Integer> size()

Returns size of this map

Returns:

size

fastRemove

io.reactivex.Single<Long> fastRemove(K... keys)

Removes map entries mapped by specified keys.

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

fastPut

io.reactivex.Single<Boolean> fastPut(K key,
                                     V value)

Stores the specified value mapped by specified key.

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

fastPutIfAbsent

io.reactivex.Single<Boolean> fastPutIfAbsent(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 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

io.reactivex.Single<Set<K>> readAllKeySet()

Read all keys at once

Returns:

keys

readAllValues

io.reactivex.Single<Collection<V>> readAllValues()

Read all values at once

Returns:

values

readAllEntrySet

io.reactivex.Single<Set<Map.Entry<K,V>>> readAllEntrySet()

Read all map entries at once

Returns:

entries

readAllMap

io.reactivex.Single<Map<K,V>> readAllMap()

Read all map as local instance at once

Returns:

map

get

io.reactivex.Maybe<V> get(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

put

io.reactivex.Maybe<V> put(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

remove

io.reactivex.Maybe<V> remove(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

replace

io.reactivex.Maybe<V> replace(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

replace

io.reactivex.Single<Boolean> replace(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.

remove

io.reactivex.Single<Boolean> remove(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.

putIfAbsent

io.reactivex.Maybe<V> putIfAbsent(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.

entryIterator

io.reactivex.Flowable<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

io.reactivex.Flowable<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

io.reactivex.Flowable<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

io.reactivex.Flowable<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

io.reactivex.Flowable<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

io.reactivex.Flowable<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

io.reactivex.Flowable<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

io.reactivex.Flowable<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

io.reactivex.Flowable<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

io.reactivex.Flowable<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

io.reactivex.Flowable<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

io.reactivex.Flowable<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

RPermitExpirableSemaphoreRx getPermitExpirableSemaphore(K key)

Returns RPermitExpirableSemaphore instance associated with key

Parameters:

key - - map key

Returns:

permitExpirableSemaphore

getSemaphore

RSemaphoreRx getSemaphore(K key)

Returns RSemaphore instance associated with key

Parameters:

key - - map key

Returns:

semaphore

getFairLock

RLockRx getFairLock(K key)

Returns RLock instance associated with key

Parameters:

key - - map key

Returns:

fairLock

getReadWriteLock

RReadWriteLockRx getReadWriteLock(K key)

Returns RReadWriteLock instance associated with key

Parameters:

key - - map key

Returns:

readWriteLock

getLock

RLockRx getLock(K key)

Returns RLock instance associated with key

Parameters:

key - - map key

Returns:

lock