org.redisson.core

Interface RMultimapAsync<K,V>

Type Parameters:

K - key

V - value

All Superinterfaces:

RExpirableAsync, RObjectAsync

All Known Subinterfaces:

RListMultimap<K,V>, RListMultimapCache<K,V>, RMultimap<K,V>, RMultimapCache<K,V>, RMultimapCacheAsync<K,V>, RSetMultimap<K,V>, RSetMultimapCache<K,V>

All Known Implementing Classes:

RedissonListMultimap, RedissonListMultimapCache, RedissonMultimap, RedissonSetMultimap, RedissonSetMultimapCache

public interface RMultimapAsync<K,V>
extends RExpirableAsync

Base asynchronous MultiMap interface. A collection that maps multiple values per one key.

Author:

Nikita Koksharov

Method Summary

Methods

Modifier and Type	Method and Description
io.netty.util.concurrent.Future<Boolean>	containsEntryAsync(Object key, Object value) Returns true if this multimap contains at least one key-value pair with the key key and the value value.
io.netty.util.concurrent.Future<Boolean>	containsKeyAsync(Object key) Returns true if this multimap contains at least one key-value pair with the key key.
io.netty.util.concurrent.Future<Boolean>	containsValueAsync(Object value) Returns true if this multimap contains at least one key-value pair with the value value.
io.netty.util.concurrent.Future<Long>	fastRemoveAsync(K... keys) Removes keys from map by one operation Works faster than removeAll but not returning the value associated with key
io.netty.util.concurrent.Future<Collection<V>>	getAllAsync(K key)
io.netty.util.concurrent.Future<Integer>	keySizeAsync() Returns the number of key-value pairs in this multimap.
io.netty.util.concurrent.Future<Boolean>	putAllAsync(K key, Iterable<? extends V> values) Stores a key-value pair in this multimap for each of values, all using the same key, key.
io.netty.util.concurrent.Future<Boolean>	putAsync(K key, V value) Stores a key-value pair in this multimap.
io.netty.util.concurrent.Future<Collection<V>>	removeAllAsync(Object key) Removes all values associated with the key key.
io.netty.util.concurrent.Future<Boolean>	removeAsync(Object key, Object value) Removes a single key-value pair with the key key and the value value from this multimap, if such exists.
io.netty.util.concurrent.Future<Collection<V>>	replaceValuesAsync(K key, Iterable<? extends V> values) Stores a collection of values with the same key, replacing any existing values for that key.
io.netty.util.concurrent.Future<Integer>	sizeAsync() Returns the number of key-value pairs in this multimap.

Methods inherited from interface org.redisson.core.RExpirableAsync

clearExpireAsync, expireAsync, expireAtAsync, expireAtAsync, remainTimeToLiveAsync

Methods inherited from interface org.redisson.core.RObjectAsync

deleteAsync, isExistsAsync, migrateAsync, moveAsync, renameAsync, renamenxAsync

Method Detail

sizeAsync

io.netty.util.concurrent.Future<Integer> sizeAsync()

Returns the number of key-value pairs in this multimap.

Returns:

containsKeyAsync

io.netty.util.concurrent.Future<Boolean> containsKeyAsync(Object key)

Returns true if this multimap contains at least one key-value pair with the key key.

containsValueAsync

io.netty.util.concurrent.Future<Boolean> containsValueAsync(Object value)

Returns true if this multimap contains at least one key-value pair with the value value.

containsEntryAsync

io.netty.util.concurrent.Future<Boolean> containsEntryAsync(Object key,
                                                          Object value)

Returns true if this multimap contains at least one key-value pair with the key key and the value value.

putAsync

io.netty.util.concurrent.Future<Boolean> putAsync(K key,
                                                V value)

Stores a key-value pair in this multimap.

Some multimap implementations allow duplicate key-value pairs, in which case put always adds a new key-value pair and increases the multimap size by 1. Other implementations prohibit duplicates, and storing a key-value pair that's already in the multimap has no effect.

Returns:

true if the method increased the size of the multimap, or false if the multimap already contained the key-value pair and doesn't allow duplicates

removeAsync

io.netty.util.concurrent.Future<Boolean> removeAsync(Object key,
                                                   Object value)

Removes a single key-value pair with the key key and the value value from this multimap, if such exists. If multiple key-value pairs in the multimap fit this description, which one is removed is unspecified.

Returns:

true if the multimap changed

putAllAsync

io.netty.util.concurrent.Future<Boolean> putAllAsync(K key,
                                                   Iterable<? extends V> values)

Stores a key-value pair in this multimap for each of values, all using the same key, key. Equivalent to (but expected to be more efficient than):

   for (V value : values) {
     put(key, value);
   }

In particular, this is a no-op if values is empty.

Returns:

true if the multimap changed

replaceValuesAsync

io.netty.util.concurrent.Future<Collection<V>> replaceValuesAsync(K key,
                                                                Iterable<? extends V> values)

Stores a collection of values with the same key, replacing any existing values for that key.

If values is empty, this is equivalent to removeAll(key).

Returns:

the collection of replaced values, or an empty collection if no values were previously associated with the key. The collection may be modifiable, but updating it will have no effect on the multimap.

removeAllAsync

io.netty.util.concurrent.Future<Collection<V>> removeAllAsync(Object key)

Removes all values associated with the key key.

Once this method returns, key will not be mapped to any values, so it will not appear in #keySet(), #asMap(), or any other views.

Returns:

the values that were removed (possibly empty). The returned collection may be modifiable, but updating it will have no effect on the multimap.

getAllAsync

io.netty.util.concurrent.Future<Collection<V>> getAllAsync(K key)

keySizeAsync

io.netty.util.concurrent.Future<Integer> keySizeAsync()

Returns the number of key-value pairs in this multimap.

Returns:

fastRemoveAsync

io.netty.util.concurrent.Future<Long> fastRemoveAsync(K... keys)

Removes keys from map by one operation Works faster than removeAll but not returning the value associated with key

Parameters:

keys -

Returns:

the number of keys that were removed from the hash, not including specified but non existing keys