io.vertx.core.shareddata

Interface AsyncMap<K,V>

public interface AsyncMap<K,V>

An asynchronous map.

AsyncMap does not allow null to be used as a key or value.

Author:

Tim Fox

Method Summary

Modifier and Type	Method and Description
Future<Void>	clear() Same as clear(Handler) but returns a Future of the asynchronous result
default void	clear(Handler<AsyncResult<Void>> resultHandler) Clear all entries in the map
Future<Map<K,V>>	entries() Same as entries(Handler) but returns a Future of the asynchronous result
default void	entries(Handler<AsyncResult<Map<K,V>>> resultHandler) Get the entries of the map, asynchronously.
Future<V>	get(K k) Same as #get(K, Handler) but returns a Future of the asynchronous result
default void	get(K k, Handler<AsyncResult<V>> resultHandler) Get a value from the map, asynchronously.
Future<Set<K>>	keys() Same as keys(Handler) but returns a Future of the asynchronous result
default void	keys(Handler<AsyncResult<Set<K>>> resultHandler) Get the keys of the map, asynchronously.
Future<Void>	put(K k, V v) Same as #put(K, V, Handler) but returns a Future of the asynchronous result
default void	put(K k, V v, Handler<AsyncResult<Void>> completionHandler) Put a value in the map, asynchronously.
Future<Void>	put(K k, V v, long ttl) Same as #put(K, V, long, Handler) but returns a Future of the asynchronous result
default void	put(K k, V v, long ttl, Handler<AsyncResult<Void>> completionHandler) Like put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but specifying a time to live for the entry.
Future<V>	putIfAbsent(K k, V v) Same as #putIfAbsent(K, V, Handler) but returns a Future of the asynchronous result
default void	putIfAbsent(K k, V v, Handler<AsyncResult<V>> completionHandler) Put the entry only if there is no entry with the key already present.
Future<V>	putIfAbsent(K k, V v, long ttl) Same as #putIfAbsent(K, V, long, Handler) but returns a Future of the asynchronous result
default void	putIfAbsent(K k, V v, long ttl, Handler<AsyncResult<V>> completionHandler) Link putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>) but specifying a time to live for the entry.
Future<V>	remove(K k) Same as #remove(K, Handler) but returns a Future of the asynchronous result
default void	remove(K k, Handler<AsyncResult<V>> resultHandler) Remove a value from the map, asynchronously.
Future<Boolean>	removeIfPresent(K k, V v) Same as #removeIfPresent(K, V, Handler) but returns a Future of the asynchronous result
default void	removeIfPresent(K k, V v, Handler<AsyncResult<Boolean>> resultHandler) Remove a value from the map, only if entry already exists with same value.
Future<V>	replace(K k, V v) Same as #replace(K, V, Handler) but returns a Future of the asynchronous result
default void	replace(K k, V v, Handler<AsyncResult<V>> resultHandler) Replace the entry only if it is currently mapped to some value
default Future<V>	replace(K k, V v, long ttl) Same as #replace(K, V, long, Handler) but returns a Future of the asynchronous result returns UnsupportedOperationException if the implementation does not support it
default void	replace(K k, V v, long ttl, Handler<AsyncResult<V>> resultHandler) Replace the entry only if it is currently mapped to some value
Future<Boolean>	replaceIfPresent(K k, V oldValue, V newValue) Same as #replaceIfPresent(K, V, V, Handler) but returns a Future of the asynchronous result
default void	replaceIfPresent(K k, V oldValue, V newValue, Handler<AsyncResult<Boolean>> resultHandler) Replace the entry only if it is currently mapped to a specific value
default Future<Boolean>	replaceIfPresent(K k, V oldValue, V newValue, long ttl) Same as #replaceIfPresent(K, V, V, long, Handler) but returns a Future of the asynchronous result returns UnsupportedOperationException if the implementation does not support it
default void	replaceIfPresent(K k, V oldValue, V newValue, long ttl, Handler<AsyncResult<Boolean>> resultHandler) Replace the entry only if it is currently mapped to a specific value
Future<Integer>	size() Same as size(Handler) but returns a Future of the asynchronous result
default void	size(Handler<AsyncResult<Integer>> resultHandler) Provide the number of entries in the map
Future<List<V>>	values() Same as values(Handler) but returns a Future of the asynchronous result
default void	values(Handler<AsyncResult<List<V>>> resultHandler) Get the values of the map, asynchronously.

Method Detail

get

default void get(K k,
                 Handler<AsyncResult<V>> resultHandler)

Get a value from the map, asynchronously.

Parameters:

k - the key

resultHandler - - this will be called some time later with the async result.

get

Future<V> get(K k)

Same as #get(K, Handler) but returns a Future of the asynchronous result

put

default void put(K k,
                 V v,
                 Handler<AsyncResult<Void>> completionHandler)

Put a value in the map, asynchronously.

Parameters:

k - the key

v - the value

completionHandler - - this will be called some time later to signify the value has been put

put

Future<Void> put(K k,
                 V v)

Same as #put(K, V, Handler) but returns a Future of the asynchronous result

put

default void put(K k,
                 V v,
                 long ttl,
                 Handler<AsyncResult<Void>> completionHandler)

Like put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but specifying a time to live for the entry. Entry will expire and get evicted after the ttl.

Parameters:

k - the key

v - the value

ttl - The time to live (in ms) for the entry

completionHandler - the handler

put

Future<Void> put(K k,
                 V v,
                 long ttl)

Same as #put(K, V, long, Handler) but returns a Future of the asynchronous result

putIfAbsent

default void putIfAbsent(K k,
                         V v,
                         Handler<AsyncResult<V>> completionHandler)

Put the entry only if there is no entry with the key already present. If key already present then the existing value will be returned to the handler, otherwise null.

Parameters:

k - the key

v - the value

completionHandler - the handler

putIfAbsent

Future<V> putIfAbsent(K k,
                      V v)

Same as #putIfAbsent(K, V, Handler) but returns a Future of the asynchronous result

putIfAbsent

default void putIfAbsent(K k,
                         V v,
                         long ttl,
                         Handler<AsyncResult<V>> completionHandler)

Link putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>) but specifying a time to live for the entry. Entry will expire and get evicted after the ttl.

Parameters:

k - the key

v - the value

ttl - The time to live (in ms) for the entry

completionHandler - the handler

putIfAbsent

Future<V> putIfAbsent(K k,
                      V v,
                      long ttl)

Same as #putIfAbsent(K, V, long, Handler) but returns a Future of the asynchronous result

remove

default void remove(K k,
                    Handler<AsyncResult<V>> resultHandler)

Remove a value from the map, asynchronously.

Parameters:

k - the key

resultHandler - - this will be called some time later to signify the value has been removed

remove

Future<V> remove(K k)

Same as #remove(K, Handler) but returns a Future of the asynchronous result

removeIfPresent

default void removeIfPresent(K k,
                             V v,
                             Handler<AsyncResult<Boolean>> resultHandler)

Remove a value from the map, only if entry already exists with same value.

Parameters:

k - the key

v - the value

resultHandler - - this will be called some time later to signify the value has been removed

removeIfPresent

Future<Boolean> removeIfPresent(K k,
                                V v)

Same as #removeIfPresent(K, V, Handler) but returns a Future of the asynchronous result

replace

default void replace(K k,
                     V v,
                     Handler<AsyncResult<V>> resultHandler)

Replace the entry only if it is currently mapped to some value

Parameters:

k - the key

v - the new value

resultHandler - the result handler will be passed the previous value

replace

Future<V> replace(K k,
                  V v)

Same as #replace(K, V, Handler) but returns a Future of the asynchronous result

replace

default void replace(K k,
                     V v,
                     long ttl,
                     Handler<AsyncResult<V>> resultHandler)

Replace the entry only if it is currently mapped to some value

Parameters:

k - the key

v - the new value

ttl - The time to live (in ms) for the entry

resultHandler - the result handler will be passed the previous value

replace

default Future<V> replace(K k,
                          V v,
                          long ttl)

Same as #replace(K, V, long, Handler) but returns a Future of the asynchronous result returns UnsupportedOperationException if the implementation does not support it

replaceIfPresent

default void replaceIfPresent(K k,
                              V oldValue,
                              V newValue,
                              Handler<AsyncResult<Boolean>> resultHandler)

Replace the entry only if it is currently mapped to a specific value

Parameters:

k - the key

oldValue - the existing value

newValue - the new value

resultHandler - the result handler

replaceIfPresent

Future<Boolean> replaceIfPresent(K k,
                                 V oldValue,
                                 V newValue)

Same as #replaceIfPresent(K, V, V, Handler) but returns a Future of the asynchronous result

replaceIfPresent

default void replaceIfPresent(K k,
                              V oldValue,
                              V newValue,
                              long ttl,
                              Handler<AsyncResult<Boolean>> resultHandler)

Replace the entry only if it is currently mapped to a specific value

Parameters:

k - the key

oldValue - the existing value

newValue - the new value

ttl - The time to live (in ms) for the entry

resultHandler - the result handler

replaceIfPresent

default Future<Boolean> replaceIfPresent(K k,
                                         V oldValue,
                                         V newValue,
                                         long ttl)

Same as #replaceIfPresent(K, V, V, long, Handler) but returns a Future of the asynchronous result returns UnsupportedOperationException if the implementation does not support it

clear

default void clear(Handler<AsyncResult<Void>> resultHandler)

Clear all entries in the map

Parameters:

resultHandler - called on completion

clear

Future<Void> clear()

Same as clear(Handler) but returns a Future of the asynchronous result

size

default void size(Handler<AsyncResult<Integer>> resultHandler)

Provide the number of entries in the map

Parameters:

resultHandler - handler which will receive the number of entries

size

Future<Integer> size()

Same as size(Handler) but returns a Future of the asynchronous result

keys

default void keys(Handler<AsyncResult<Set<K>>> resultHandler)

Get the keys of the map, asynchronously.

Use this method with care as the map may contain a large number of keys, which may not fit entirely in memory of a single node. In this case, the invocation will result in an OutOfMemoryError.

Parameters:

resultHandler - invoked when the operation completes

keys

Future<Set<K>> keys()

Same as keys(Handler) but returns a Future of the asynchronous result

values

default void values(Handler<AsyncResult<List<V>>> resultHandler)

Get the values of the map, asynchronously.

Use this method with care as the map may contain a large number of values, which may not fit entirely in memory of a single node. In this case, the invocation will result in an OutOfMemoryError.

Parameters:

resultHandler - invoked when the operation completes

values

Future<List<V>> values()

Same as values(Handler) but returns a Future of the asynchronous result

entries

default void entries(Handler<AsyncResult<Map<K,V>>> resultHandler)

Get the entries of the map, asynchronously.

Use this method with care as the map may contain a large number of entries, which may not fit entirely in memory of a single node. In this case, the invocation will result in an OutOfMemoryError.

Parameters:

resultHandler - invoked when the operation completes

entries

Future<Map<K,V>> entries()

Same as entries(Handler) but returns a Future of the asynchronous result