K
- the type of the Map entry keysV
- the type of the Map entry valuespublic interface InvocableMap<K,V> extends Map<K,V>
Note: When using the Coherence Enterprise Edition or Grid Edition, the Partitioned Cache implements the InvocableMap interface by partitioning and localizing the invocations, resulting in extremely high throughput and low latency. When using Coherence Standard Edition, the InvocableMap processes the invocations on the originating node, typically resulting in higher network, memory and CPU utilization, which translates to lower performance, and particularly when processing large data sets.
Modifier and Type | Interface and Description |
---|---|
static interface |
InvocableMap.Entry<K,V>
An InvocableMap.Entry contains additional information and exposes additional operations that the basic Map.Entry does not.
|
static interface |
InvocableMap.EntryAggregator<K,V,R>
An EntryAggregator represents processing that can be directed to occur against some subset of the entries in an InvocableMap, resulting in a aggregated result.
|
static interface |
InvocableMap.EntryProcessor<K,V,R>
An invocable agent that operates against the Entry objects within a Map.
|
static interface |
InvocableMap.ParallelAwareAggregator<K,V,P,R>
Deprecated.
This interface was deprecated in Coherence 12.2.1 and might be removed in a future release. Use
InvocableMap.StreamingAggregator instead. |
static interface |
InvocableMap.StreamingAggregator<K,V,P,R>
A StreamingAggregator is an extension of
InvocableMap.EntryAggregator that processes entries in a streaming fashion and provides better control over execution characteristics . |
Modifier and Type | Method and Description |
---|---|
<R> R |
aggregate(Collection<? extends K> collKeys, InvocableMap.EntryAggregator<? super K,? super V,R> aggregator)
Perform an aggregating operation against the entries specified by the passed keys.
|
<R> R |
aggregate(Filter filter, InvocableMap.EntryAggregator<? super K,? super V,R> aggregator)
Perform an aggregating operation against the set of entries that are selected by the given Filter.
|
default <R> R |
aggregate(InvocableMap.EntryAggregator<? super K,? super V,R> aggregator)
Perform an aggregating operation against all the entries.
|
default V |
compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) |
default V |
compute(K key, Remote.BiFunction<? super K,? super V,? extends V> remappingFunction)
Compute a new mapping for the specified key and its current value.
|
default V |
computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
Note that the previous example will not work as expected if this method is called on a distributed map, as the <c>add</c> method will be called on a client-side copy of the collection stored on the server.
|
default V |
computeIfAbsent(K key, Remote.Function<? super K,? extends V> mappingFunction)
Compute the value using the given mapping function and enter it into this map (unless
null ), if the specified key is not already associated with a value (or is mapped to null ). |
default V |
computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) |
default V |
computeIfPresent(K key, Remote.BiFunction<? super K,? super V,? extends V> remappingFunction)
Compute a new mapping given the key and its current mapped value, if the value for the specified key is present and non-null.
|
default V |
getOrDefault(Object key, V defaultValue) |
<R> R |
invoke(K key, InvocableMap.EntryProcessor<K,V,R> processor)
Invoke the passed EntryProcessor against the Entry specified by the passed key, returning the result of the invocation.
|
<R> Map<K,R> |
invokeAll(Collection<? extends K> collKeys, InvocableMap.EntryProcessor<K,V,R> processor)
Invoke the passed EntryProcessor against the entries specified by the passed keys, returning the result of the invocation for each.
|
<R> Map<K,R> |
invokeAll(Filter filter, InvocableMap.EntryProcessor<K,V,R> processor)
Invoke the passed EntryProcessor against the set of entries that are selected by the given Filter, returning the result of the invocation for each.
|
default <R> Map<K,R> |
invokeAll(InvocableMap.EntryProcessor<K,V,R> processor)
Invoke the passed EntryProcessor against all the entries, returning the result of the invocation for each.
|
default V |
merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) |
default V |
merge(K key, V value, Remote.BiFunction<? super V,? super V,? extends V> remappingFunction)
If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value.
|
default V |
putIfAbsent(K key, V value) |
default boolean |
remove(Object key, Object value) |
default V |
replace(K key, V value) |
default boolean |
replace(K key, V oldValue, V newValue) |
default void |
replaceAll(BiFunction<? super K,? super V,? extends V> function) |
default void |
replaceAll(Collection<? extends K> collKeys, Remote.BiFunction<? super K,? super V,? extends V> function)
Replace each entry's value with the result of invoking the given function on that entry until all entries for the specified key set have been processed or the function throws an exception.
|
default void |
replaceAll(Filter filter, Remote.BiFunction<? super K,? super V,? extends V> function)
Replace each entry's value with the result of invoking the given function on that entry until all entries selected by the specified filter have been processed or the function throws an exception.
|
default void |
replaceAll(Remote.BiFunction<? super K,? super V,? extends V> function)
Replace each entry's value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception.
|
default RemoteStream<InvocableMap.Entry<K,V>> |
stream()
Return a stream of all entries in this map.
|
default RemoteStream<InvocableMap.Entry<K,V>> |
stream(Collection<? extends K> collKeys)
Return a stream of entries with the specified keys.
|
default <T,E> RemoteStream<E> |
stream(Collection<? extends K> collKeys, ValueExtractor<T,? extends E> extractor)
Return a stream of values extracted from the entries with the specified keys.
|
default RemoteStream<InvocableMap.Entry<K,V>> |
stream(Filter filter)
Return a filtered stream of entries in this map.
|
default <T,E> RemoteStream<E> |
stream(Filter filter, ValueExtractor<T,? extends E> extractor)
Return a stream of values extracted from all the entries that satisfy the specified filter.
|
default <T,E> RemoteStream<E> |
stream(ValueExtractor<T,? extends E> extractor)
Return a stream of values extracted from the entries of this map.
|
<R> R invoke(K key, InvocableMap.EntryProcessor<K,V,R> processor)
R
- the type of value returned by the EntryProcessorkey
- the key to process; it is not required to exist within the Mapprocessor
- the EntryProcessor to use to process the specified keydefault <R> Map<K,R> invokeAll(InvocableMap.EntryProcessor<K,V,R> processor)
R
- the type of value returned by the EntryProcessorprocessor
- the EntryProcessor to use to process the specified keys<R> Map<K,R> invokeAll(Collection<? extends K> collKeys, InvocableMap.EntryProcessor<K,V,R> processor)
R
- the type of value returned by the EntryProcessorcollKeys
- the keys to process; these keys are not required to exist within the Mapprocessor
- the EntryProcessor to use to process the specified keys<R> Map<K,R> invokeAll(Filter filter, InvocableMap.EntryProcessor<K,V,R> processor)
Unless specified otherwise, InvocableMap implementations will perform this operation in two steps: (1) use the filter to retrieve a matching entry set; (2) apply the agent to every filtered entry. This algorithm assumes that the agent's processing does not affect the result of the specified filter evaluation, since the filtering and processing could be performed in parallel on different threads. If this assumption does not hold, the processor logic has to be idempotent, or at least re-evaluate the filter. This could be easily accomplished by wrapping the processor with the ConditionalProcessor
.
R
- the type of value returned by the EntryProcessorfilter
- a Filter that results in the set of keys to be processedprocessor
- the EntryProcessor to use to process the specified keysdefault <R> R aggregate(InvocableMap.EntryAggregator<? super K,? super V,R> aggregator)
R
- the type of value returned by the EntryAggregatoraggregator
- the EntryAggregator that is used to aggregate across the specified entries of this Map<R> R aggregate(Collection<? extends K> collKeys, InvocableMap.EntryAggregator<? super K,? super V,R> aggregator)
R
- the type of value returned by the EntryAggregatorcollKeys
- the Collection of keys that specify the entries within this Map to aggregate acrossaggregator
- the EntryAggregator that is used to aggregate across the specified entries of this Map<R> R aggregate(Filter filter, InvocableMap.EntryAggregator<? super K,? super V,R> aggregator)
R
- the type of value returned by the EntryAggregatorfilter
- the Filter that is used to select entries within this Map to aggregate acrossaggregator
- the EntryAggregator that is used to aggregate across the selected entries of this Mapdefault V getOrDefault(Object key, V defaultValue)
getOrDefault
in interface Map<K,V>
default V computeIfAbsent(K key, Remote.Function<? super K,? extends V> mappingFunction)
null
), if the specified key is not already associated with a value (or is mapped to null
).
If the mapping function returns null
no mapping is recorded. If the function itself throws an (unchecked) exception, the exception is rethrown, and no mapping is recorded.
The most common usage is to construct a new object serving as an initial mapped value or memoized result, as in:
map.computeIfAbsent(key, k -> new Value(f(k)));
Or to implement a multi-value map, Map<K, Collection<V>>
, supporting multiple values per key:
map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
Note that the previous example will not work as expected if this method is called on a distributed map, as the <c>add</c> method will be called on the client-side copy of the collection stored on the server.key
- key with which the specified value is to be associatedmappingFunction
- the function to compute a valuedefault V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
computeIfAbsent
in interface Map<K,V>
default V computeIfPresent(K key, Remote.BiFunction<? super K,? super V,? extends V> remappingFunction)
If the function returns null
, the mapping is removed. If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.
key
- the key with which the specified value is to be associatedremappingFunction
- the function to compute a valuedefault V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
computeIfPresent
in interface Map<K,V>
default V compute(K key, Remote.BiFunction<? super K,? super V,? extends V> remappingFunction)
If the function returns null
, the mapping is removed (or remains absent if initially absent). If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.
key
- the key with which the computed value is to be associatedremappingFunction
- the function to compute a valuedefault V merge(K key, V value, Remote.BiFunction<? super V,? super V,? extends V> remappingFunction)
null
.
This method may be of use when combining multiple mapped values for a key. For example, to either create or append a String msg
to a value mapping:
map.merge(key, msg, String::concat)
If the function returns null
the mapping is removed. If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.key
- key with which the resulting value is to be associatedvalue
- the non-null value to be merged with the existing value associated with the key or, if no existing value or a null value is associated with the key, to be associated with the keyremappingFunction
- the function to recompute a value if presentdefault V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
default void replaceAll(Remote.BiFunction<? super K,? super V,? extends V> function)
Exceptions thrown by the function are relayed to the caller.
function
- the function to apply to each entrydefault void replaceAll(BiFunction<? super K,? super V,? extends V> function)
replaceAll
in interface Map<K,V>
default void replaceAll(Collection<? extends K> collKeys, Remote.BiFunction<? super K,? super V,? extends V> function)
Exceptions thrown by the function are relayed to the caller.
collKeys
- the keys to process; these keys are not required to exist within the Mapfunction
- the function to apply to each entrydefault void replaceAll(Filter filter, Remote.BiFunction<? super K,? super V,? extends V> function)
Exceptions thrown by the function are relayed to the caller.
filter
- the filter that should be used to select entriesfunction
- the function to apply to each entrydefault RemoteStream<InvocableMap.Entry<K,V>> stream()
default RemoteStream<InvocableMap.Entry<K,V>> stream(Collection<? extends K> collKeys)
collKeys
- the keys to process; these keys are not required to exist within the Mapdefault RemoteStream<InvocableMap.Entry<K,V>> stream(Filter filter)
filter
- filter to apply to this map's entries before creating the streamdefault <T,E> RemoteStream<E> stream(ValueExtractor<T,? extends E> extractor)
This method is highly recommended when the intention is to work against a stream of InvocableMap.Entry
attributes, and is functionally equivalent to:
cache.stream().map(entry -> entry.extract(extractor))The use of this method over the
stream()
method, allows relevant indices to be used avoiding potential deserialization and significantly improving performance of value extraction.
The same goal can be achieved by simply using multiple RemoteStream.map(ValueExtractor)
calls against the entry stream, such as:
cache.stream() .map(Map.Entry::getValue) .map(MyValue::getAttribute)However, this will only be efficient if you have a
DeserializationAccelerator
configured for the cache. Otherwise, it will result in deserialization of all cache entries, which is likely to have significant negative impact on performance.extractor
- the extractor to usedefault <T,E> RemoteStream<E> stream(Collection<? extends K> collKeys, ValueExtractor<T,? extends E> extractor)
This method is highly recommended when the intention is to work against a stream of InvocableMap.Entry
attributes, and is functionally equivalent to:
cache.stream(collKeys).map(entry -> entry.extract(extractor))The use of this method over the
stream(Collection)
method, allows relevant indices to be used avoiding potential deserialization and significantly improving performance of value extraction.
The same goal can be achieved by simply using multiple RemoteStream.map(ValueExtractor)
calls against the entry stream, such as:
cache.stream(collKeys) .map(Map.Entry::getValue) .map(MyValue::getAttribute)However, this will only be efficient if you have a
DeserializationAccelerator
configured for the cache. Otherwise, it will result in deserialization of all selected entries, which is likely to have significant negative impact on performance.collKeys
- the keys to process; these keys are not required to exist within the Mapextractor
- the extractor to usedefault <T,E> RemoteStream<E> stream(Filter filter, ValueExtractor<T,? extends E> extractor)
This method is highly recommended when the intention is to work against a stream of InvocableMap.Entry
attributes, and is functionally equivalent to:
cache.stream(filter).map(entry -> entry.extract(extractor))The use of this method over the
stream(Filter)
method, allows relevant indices to be used avoiding potential deserialization and significantly improving performance of value extraction.
The same goal can be achieved by simply using multiple RemoteStream.map(ValueExtractor)
calls against the entry stream, such as:
cache.stream(filter) .map(Map.Entry::getValue) .map(MyValue::getAttribute)However, this will only be efficient if you have a
DeserializationAccelerator
configured for the cache. Otherwise, it will result in deserialization of all selected entries, which is likely to have significant negative impact on performance.filter
- filter to apply to this map's entries before creating the streamextractor
- the extractor to use