Package org.redisson.transaction

Class BaseTransactionalMap<K,V>

java.lang.Object

org.redisson.transaction.BaseTransactionalObject

org.redisson.transaction.BaseTransactionalMap<K,V>

Type Parameters:

K - key type

V - value type

Direct Known Subclasses:

BaseTransactionalMapCache

public class BaseTransactionalMap<K,V>
extends BaseTransactionalObject

Author:

Nikita Koksharov

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	BaseTransactionalMap.MapEntry

Constructor Summary

Constructors

Constructor	Description
BaseTransactionalMap(CommandAsyncExecutor commandExecutor, long timeout, List<TransactionalOperation> operations, RMap<K,V> map, String transactionId)

Method Summary

Modifier and Type	Method	Description
protected RFuture<V>	addAndGetOperationAsync(K key, Number value)
RFuture<Boolean>	containsKeyAsync(Object key)
RFuture<Boolean>	containsValueAsync(Object value)
RFuture<Boolean>	deleteAsync(CommandAsyncExecutor commandExecutor)
protected RFuture<Boolean>	deleteAsync(CommandAsyncExecutor commandExecutor, TransactionalOperation operation)
protected <R> RFuture<R>	executeLocked(K key, Supplier<CompletionStage<R>> runnable)
protected RFuture<Boolean>	fastPutIfAbsentOperationAsync(K key, V value)
protected RFuture<Boolean>	fastPutIfAbsentOperationAsync(K key, V value, MapOperation mapOperation)
protected RFuture<Boolean>	fastPutIfExistsOperationAsync(K key, V value)
protected RFuture<Boolean>	fastPutIfExistsOperationAsync(K key, V value, MapOperation mapOperation)
protected RFuture<Boolean>	fastPutOperationAsync(K key, V value)
protected RFuture<Boolean>	fastPutOperationAsync(K key, V value, MapOperation operation)
protected RFuture<Long>	fastRemoveOperationAsync(K... keys)
protected RFuture<Map<K,V>>	getAllOperationAsync(Set<K> keys)
protected RLock	getLock(K key)
protected RFuture<V>	getOperationAsync(K key)
RFuture<Boolean>	isExistsAsync()
protected RFuture<Void>	putAllOperationAsync(Map<? extends K,? extends V> entries)
protected RFuture<V>	putIfAbsentOperationAsync(K key, V value)
protected RFuture<V>	putIfAbsentOperationAsync(K key, V value, MapOperation mapOperation)
protected RFuture<V>	putIfExistsOperationAsync(K key, V value)
protected RFuture<V>	putIfExistsOperationAsync(K key, V value, MapOperation mapOperation)
protected RFuture<V>	putOperationAsync(K key, V value)
protected RFuture<V>	putOperationAsync(K key, V value, MapOperation operation)
RFuture<Set<Map.Entry<K,V>>>	readAllEntrySetAsync()
RFuture<Set<K>>	readAllKeySetAsync()
RFuture<Map<K,V>>	readAllMapAsync()
RFuture<Collection<V>>	readAllValuesAsync()
protected RFuture<Boolean>	removeOperationAsync(Object key, Object value)
protected RFuture<V>	removeOperationAsync(K key)
protected RFuture<V>	replaceOperationAsync(K key, V value)
protected RFuture<Boolean>	replaceOperationAsync(K key, V oldValue, V newValue)
protected ScanResult<Map.Entry<Object,Object>>	scanIterator(String name, RedisClient client, long startPos, String pattern, int count)
RFuture<Boolean>	touchAsync(CommandAsyncExecutor commandExecutor)
RFuture<Boolean>	unlinkAsync(CommandAsyncExecutor commandExecutor)
RFuture<Integer>	valueSizeAsync(K key)

Methods inherited from class org.redisson.transaction.BaseTransactionalObject

clearExpireAsync, executeLocked, executeLocked, expireAsync, expireAtAsync, expireAtAsync, expireAtAsync, migrateAsync, moveAsync

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BaseTransactionalMap

public BaseTransactionalMap(CommandAsyncExecutor commandExecutor,
                            long timeout,
                            List<TransactionalOperation> operations,
                            RMap<K,V> map,
                            String transactionId)

Method Detail

isExistsAsync

public RFuture<Boolean> isExistsAsync()

unlinkAsync

public RFuture<Boolean> unlinkAsync(CommandAsyncExecutor commandExecutor)

touchAsync

public RFuture<Boolean> touchAsync(CommandAsyncExecutor commandExecutor)

deleteAsync

public RFuture<Boolean> deleteAsync(CommandAsyncExecutor commandExecutor)

deleteAsync

protected RFuture<Boolean> deleteAsync(CommandAsyncExecutor commandExecutor,
                                       TransactionalOperation operation)

scanIterator

protected ScanResult<Map.Entry<Object,Object>> scanIterator(String name,
                                                                  RedisClient client,
                                                                  long startPos,
                                                                  String pattern,
                                                                  int count)

containsKeyAsync

public RFuture<Boolean> containsKeyAsync(Object key)

containsValueAsync

public RFuture<Boolean> containsValueAsync(Object value)

addAndGetOperationAsync

protected RFuture<V> addAndGetOperationAsync(K key,
                                             Number value)

putIfExistsOperationAsync

protected RFuture<V> putIfExistsOperationAsync(K key,
                                               V value)

putIfExistsOperationAsync

protected RFuture<V> putIfExistsOperationAsync(K key,
                                               V value,
                                               MapOperation mapOperation)

putIfAbsentOperationAsync

protected RFuture<V> putIfAbsentOperationAsync(K key,
                                               V value)

putIfAbsentOperationAsync

protected RFuture<V> putIfAbsentOperationAsync(K key,
                                               V value,
                                               MapOperation mapOperation)

putOperationAsync

protected final RFuture<V> putOperationAsync(K key,
                                             V value)

putOperationAsync

protected RFuture<V> putOperationAsync(K key,
                                       V value,
                                       MapOperation operation)

fastPutIfExistsOperationAsync

protected RFuture<Boolean> fastPutIfExistsOperationAsync(K key,
                                                         V value)

fastPutIfExistsOperationAsync

protected RFuture<Boolean> fastPutIfExistsOperationAsync(K key,
                                                         V value,
                                                         MapOperation mapOperation)

fastPutIfAbsentOperationAsync

protected RFuture<Boolean> fastPutIfAbsentOperationAsync(K key,
                                                         V value)

fastPutIfAbsentOperationAsync

protected RFuture<Boolean> fastPutIfAbsentOperationAsync(K key,
                                                         V value,
                                                         MapOperation mapOperation)

fastPutOperationAsync

protected RFuture<Boolean> fastPutOperationAsync(K key,
                                                 V value)

fastPutOperationAsync

protected RFuture<Boolean> fastPutOperationAsync(K key,
                                                 V value,
                                                 MapOperation operation)

fastRemoveOperationAsync

protected RFuture<Long> fastRemoveOperationAsync(K... keys)

valueSizeAsync

public RFuture<Integer> valueSizeAsync(K key)

getOperationAsync

protected RFuture<V> getOperationAsync(K key)

readAllKeySetAsync

public RFuture<Set<K>> readAllKeySetAsync()

readAllEntrySetAsync

public RFuture<Set<Map.Entry<K,V>>> readAllEntrySetAsync()

readAllValuesAsync

public RFuture<Collection<V>> readAllValuesAsync()

readAllMapAsync

public RFuture<Map<K,V>> readAllMapAsync()

getAllOperationAsync

protected RFuture<Map<K,V>> getAllOperationAsync(Set<K> keys)

removeOperationAsync

protected RFuture<V> removeOperationAsync(K key)

removeOperationAsync

protected RFuture<Boolean> removeOperationAsync(Object key,
                                                Object value)

putAllOperationAsync

protected RFuture<Void> putAllOperationAsync(Map<? extends K,? extends V> entries)

replaceOperationAsync

protected RFuture<Boolean> replaceOperationAsync(K key,
                                                 V oldValue,
                                                 V newValue)

replaceOperationAsync

protected RFuture<V> replaceOperationAsync(K key,
                                           V value)

executeLocked

protected <R> RFuture<R> executeLocked(K key,
                                       Supplier<CompletionStage<R>> runnable)

getLock

protected RLock getLock(K key)