Package org.redisson.transaction

Class BaseTransactionalMap<K,V>

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

Type Parameters:

K - key type

V - value type

Direct Known Subclasses:

BaseTransactionalMapCache

public class BaseTransactionalMap<K,V>
extends 

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, <TransactionalOperation> operations, RMap<K,V> map, transactionId)

Method Summary

Modifier and Type	Method	Description
protected RFuture<V>	addAndGetOperationAsync(K key, value)
>	key)
>	value)
>	deleteAsync(CommandAsyncExecutor commandExecutor)
protected >	deleteAsync(CommandAsyncExecutor commandExecutor, TransactionalOperation operation)
protected <R> void	executeLocked(RPromise<R> promise, runnable, <K> keys)
protected <R> void	executeLocked(RPromise<R> promise, runnable, RLock lock)
protected <R> void	executeLocked(RPromise<R> promise, K key, runnable)
protected >	fastPutIfAbsentOperationAsync(K key, V value)
protected >	fastPutIfAbsentOperationAsync(K key, V value, MapOperation mapOperation)
protected >	fastPutIfExistsOperationAsync(K key, V value)
protected >	fastPutIfExistsOperationAsync(K key, V value, MapOperation mapOperation)
protected >	fastPutOperationAsync(K key, V value)
protected >	fastPutOperationAsync(K key, V value, MapOperation operation)
protected >	fastRemoveOperationAsync(K... keys)
protected <K,V>>	<K> keys)
protected RLock	getLock(K key)
protected RFuture<V>	getOperationAsync(K key)
>	isExistsAsync()
protected >	<? 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)
<<K,V>>>	readAllEntrySetAsync()
<K>>	readAllKeySetAsync()
<K,V>>	readAllMapAsync()
<V>>	readAllValuesAsync()
protected >	key, value)
protected RFuture<V>	removeOperationAsync(K key)
protected RFuture<V>	replaceOperationAsync(K key, V value)
protected >	replaceOperationAsync(K key, V oldValue, V newValue)
protected <,>>	name, RedisClient client, long startPos, pattern, int count)
>	touchAsync(CommandAsyncExecutor commandExecutor)
>	unlinkAsync(CommandAsyncExecutor commandExecutor)
>	valueSizeAsync(K key)

Methods inherited from class java.lang.

, , , , , , , , , ,

Constructor Detail

BaseTransactionalMap

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

Method Detail

isExistsAsync

public > isExistsAsync()

unlinkAsync

public > unlinkAsync(CommandAsyncExecutor commandExecutor)

touchAsync

public > touchAsync(CommandAsyncExecutor commandExecutor)

deleteAsync

public > deleteAsync(CommandAsyncExecutor commandExecutor)

deleteAsync

protected > deleteAsync(CommandAsyncExecutor commandExecutor,
                                       TransactionalOperation operation)

scanIterator

protected <,>> scanIterator( name,
                                                                  RedisClient client,
                                                                  long startPos,
                                                                   pattern,
                                                                  int count)

containsKeyAsync

public > containsKeyAsync( key)

containsValueAsync

public > containsValueAsync( value)

addAndGetOperationAsync

protected RFuture<V> addAndGetOperationAsync(K key,
                                              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 > fastPutIfExistsOperationAsync(K key,
                                                         V value)

fastPutIfExistsOperationAsync

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

fastPutIfAbsentOperationAsync

protected > fastPutIfAbsentOperationAsync(K key,
                                                         V value)

fastPutIfAbsentOperationAsync

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

fastPutOperationAsync

protected > fastPutOperationAsync(K key,
                                                 V value)

fastPutOperationAsync

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

fastRemoveOperationAsync

protected > fastRemoveOperationAsync(K... keys)

valueSizeAsync

public > valueSizeAsync(K key)

getOperationAsync

protected RFuture<V> getOperationAsync(K key)

readAllKeySetAsync

public <K>> readAllKeySetAsync()

readAllEntrySetAsync

public <<K,V>>> readAllEntrySetAsync()

readAllValuesAsync

public <V>> readAllValuesAsync()

readAllMapAsync

public <K,V>> readAllMapAsync()

getAllOperationAsync

protected <<K> keys)

removeOperationAsync

protected RFuture<V> removeOperationAsync(K key)

removeOperationAsync

protected > removeOperationAsync( key,
                                                 value)

putAllOperationAsync

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

replaceOperationAsync

protected > replaceOperationAsync(K key,
                                                 V oldValue,
                                                 V newValue)

replaceOperationAsync

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

executeLocked

protected <R> void executeLocked(RPromise<R> promise,
                                 K key,
                                  runnable)

getLock

protected RLock getLock(K key)

executeLocked

protected <R> void executeLocked(RPromise<R> promise,
                                  runnable,
                                 RLock lock)

executeLocked

protected <R> void executeLocked(RPromise<R> promise,
                                  runnable,
                                 <K> keys)