ClientMapProxy (Hazelcast Root 3.11 API)

java.lang.Object
- com.hazelcast.client.spi.ClientProxy
- - com.hazelcast.client.proxy.ClientMapProxy<K,V>

Type Parameters:

K - key

V - value

All Implemented Interfaces:

BaseMap<K,V>, DistributedObject, IMap<K,V>, EventJournalReader<EventJournalMapEvent<K,V>>, LegacyAsyncMap<K,V>, ConcurrentMap<K,V>, Map<K,V>

Direct Known Subclasses:

NearCachedClientMapProxy
```
public class ClientMapProxy<K,V>
extends ClientProxy
implements IMap<K,V>, EventJournalReader<EventJournalMapEvent<K,V>>
```
Proxy implementation of IMap.

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Field Summary

Fields
Modifier and Type	Field and Description
`protected static String`	`NULL_AGGREGATOR_IS_NOT_ALLOWED`
`protected static String`	`NULL_KEY_IS_NOT_ALLOWED`
`protected static String`	`NULL_LISTENER_IS_NOT_ALLOWED`
`protected static String`	`NULL_PREDICATE_IS_NOT_ALLOWED`
`protected static String`	`NULL_PROJECTION_IS_NOT_ALLOWED`
`protected static String`	`NULL_VALUE_IS_NOT_ALLOWED`

Fields inherited from class com.hazelcast.client.spi.ClientProxy
name

Constructor Summary

Constructors
Constructor and Description

ClientMapProxy(String serviceName, String name, ClientContext context)

Constructors
Constructor and Description
`ClientMapProxy(String serviceName, String name, ClientContext context)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`String`	`addEntryListener(EntryListener listener, boolean includeValue)` Adds an entry listener for this map.
`String`	`addEntryListener(EntryListener listener, K key, boolean includeValue)` Adds the specified entry listener for the specified key.
`String`	`addEntryListener(EntryListener listener, Predicate<K,V> predicate, boolean includeValue)` Adds an continuous entry listener for this map.
`String`	`addEntryListener(EntryListener listener, Predicate<K,V> predicate, K key, boolean includeValue)` Adds an continuous entry listener for this map.
`String`	`addEntryListener(MapListener listener, boolean includeValue)` Adds a `MapListener` for this map.
`String`	`addEntryListener(MapListener listener, K key, boolean includeValue)` Adds a `MapListener` for this map.
`String`	`addEntryListener(MapListener listener, Predicate<K,V> predicate, boolean includeValue)` Adds a `MapListener` for this map.
`String`	`addEntryListener(MapListener listener, Predicate<K,V> predicate, K key, boolean includeValue)` Adds a `MapListener` for this map.
`void`	`addIndex(String attribute, boolean ordered)` Adds an index to this map for the specified entries so that queries can run faster.
`String`	`addInterceptor(MapInterceptor interceptor)` Adds an interceptor for this map.
`String`	`addLocalEntryListener(EntryListener listener)` Adds a local entry listener for this map.
`String`	`addLocalEntryListener(EntryListener listener, Predicate<K,V> predicate, boolean includeValue)` Adds a local entry listener for this map.
`String`	`addLocalEntryListener(EntryListener listener, Predicate<K,V> predicate, K key, boolean includeValue)` Adds a local entry listener for this map.
`String`	`addLocalEntryListener(MapListener listener)` Adds a `MapListener` for this map.
`String`	`addLocalEntryListener(MapListener listener, Predicate<K,V> predicate, boolean includeValue)` Adds a `MapListener` for this map.
`String`	`addLocalEntryListener(MapListener listener, Predicate<K,V> predicate, K key, boolean includeValue)` Adds a local entry listener for this map.
`String`	`addPartitionLostListener(MapPartitionLostListener listener)` Adds a MapPartitionLostListener.
`<R> R`	`aggregate(Aggregator<Map.Entry<K,V>,R> aggregator)` Applies the aggregation logic on all map entries and returns the result
`<R> R`	`aggregate(Aggregator<Map.Entry<K,V>,R> aggregator, Predicate<K,V> predicate)` Applies the aggregation logic on map entries filtered with the Predicated and returns the result
`<SuppliedValue,Result> Result`	`aggregate(Supplier<K,V,SuppliedValue> supplier, Aggregation<K,SuppliedValue,Result> aggregation)` Executes a predefined aggregation on the maps data set.
`<SuppliedValue,Result> Result`	`aggregate(Supplier<K,V,SuppliedValue> supplier, Aggregation<K,SuppliedValue,Result> aggregation, JobTracker jobTracker)` Executes a predefined aggregation on the maps data set.
`void`	`clear()` Clears the map and deletes the items from the backing map store.
`boolean`	`containsKey(Object key)` Returns `true` if this map contains an entry for the specified key.
`protected boolean`	`containsKeyInternal(Object key)`
`boolean`	`containsValue(Object value)`
`void`	`delete(Object key)` Removes the mapping for the key from this map if it is present.
`protected void`	`deleteInternal(Object key)`
`Set<Map.Entry<K,V>>`	`entrySet()` Returns a `Set` clone of the mappings contained in this map.
`Set<Map.Entry<K,V>>`	`entrySet(Predicate predicate)` Queries the map based on the specified predicate and returns the matching entries.
`boolean`	`evict(K key)` Evicts the specified key from this map.
`void`	`evictAll()` Evicts all keys from this map except the locked ones.
`protected boolean`	`evictInternal(Object key)`
`Map<K,Object>`	`executeOnEntries(EntryProcessor entryProcessor)` Applies the user defined `EntryProcessor` to the all entries in the map.
`Map<K,Object>`	`executeOnEntries(EntryProcessor entryProcessor, Predicate predicate)` Applies the user defined `EntryProcessor` to the entries in the map which satisfy provided predicate.
`Object`	`executeOnKey(K key, EntryProcessor entryProcessor)` Applies the user defined `EntryProcessor` to the entry mapped by the `key`.
`Object`	`executeOnKeyInternal(Object key, EntryProcessor entryProcessor)`
`Map<K,Object>`	`executeOnKeys(Set<K> keys, EntryProcessor entryProcessor)` Applies the user defined `EntryProcessor` to the entries mapped by the collection of keys.
`protected void`	`fillPartitionToKeyData(Set<K> keys, Map<Integer,List<Data>> partitionToKeyData, Map<Object,Data> keyMap, Map<Data,Object> reverseKeyMap)`
`void`	`flush()` If this map has a MapStore, this method flushes all the local dirty entries.
`void`	`forceUnlock(K key)` Releases the lock for the specified key regardless of the lock owner.
`V`	`get(Object key)` Returns the value for the specified key, or `null` if this map does not contain this key.
`Map<K,V>`	`getAll(Set<K> keys)` Returns the entries for the given keys.
`protected void`	`getAllInternal(Set<K> keys, Map<Integer,List<Data>> partitionToKeyData, List<Object> resultingKeyValuePairs)`
`ICompletableFuture<V>`	`getAsync(K key)` Asynchronously gets the given key.
`protected ICompletableFuture<V>`	`getAsyncInternal(Object key)`
`EntryView<K,V>`	`getEntryView(K key)` Returns the `EntryView` for the specified key.
`protected Object`	`getInternal(Object key)`
`LocalMapStats`	`getLocalMapStats()` Returns LocalMapStats for this map.
`QueryCache<K,V>`	`getQueryCache(String name)` Returns corresponding `QueryCache` instance for the supplied `name` or null.
`QueryCache<K,V>`	`getQueryCache(String name, MapListener listener, Predicate<K,V> predicate, boolean includeValue)` Creates an always up to date snapshot of this `IMap` according to the supplied parameters.
`QueryCache<K,V>`	`getQueryCache(String name, Predicate<K,V> predicate, boolean includeValue)` Creates an always up to date snapshot of this `IMap` according to the supplied parameters.
`ClientQueryCacheContext`	`getQueryCacheContext()`
`boolean`	`isEmpty()` Returns `true` if this map contains no entries.
`boolean`	`isLocked(K key)` Checks the lock for the specified key.
`Iterator<Map.Entry<K,V>>`	`iterator(int fetchSize, int partitionId, boolean prefetchValues)` Returns an iterator for iterating entries in the `partitionId`.
`<R> Iterator<R>`	`iterator(int fetchSize, int partitionId, Projection<Map.Entry<K,V>,R> projection, Predicate<K,V> predicate)` Returns an iterator for iterating the result of the projection on entries in the `partitionId` which satisfy the `predicate`.
`Set<K>`	`keySet()` Returns a set clone of the keys contained in this map.
`Set<K>`	`keySet(Predicate predicate)` Queries the map based on the specified predicate and returns the keys of matching entries.
`void`	`loadAll(boolean replaceExistingValues)` Loads all keys into the store.
`void`	`loadAll(Set<K> keys, boolean replaceExistingValues)` Loads the given keys.
`protected void`	`loadAllInternal(boolean replaceExistingValues, Collection<?> keys)`
`Set<K>`	`localKeySet()` Returns the locally owned set of keys.
`Set<K>`	`localKeySet(Predicate predicate)` Returns the keys of matching locally owned entries.
`void`	`lock(K key)` Acquires the lock for the specified key.
`void`	`lock(K key, long leaseTime, TimeUnit timeUnit)` Acquires the lock for the specified key for the specified lease time.
`protected void`	`onDestroy()` Called before proxy is destroyed.
`protected void`	`onInitialize()` Called when proxy is created.
`protected Map<K,Object>`	`prepareResult(Collection<Map.Entry<Data,Data>> entries)`
`<R> Collection<R>`	`project(Projection<Map.Entry<K,V>,R> projection)` Applies the projection logic on all map entries and returns the result
`<R> Collection<R>`	`project(Projection<Map.Entry<K,V>,R> projection, Predicate<K,V> predicate)` Applies the projection logic on map entries filtered with the Predicated and returns the result
`V`	`put(K key, V value)` Associates the specified value with the specified key in this map.
`V`	`put(K key, V value, long ttl, TimeUnit timeunit)` Puts an entry into this map with a given TTL (time to live) value.
`V`	`put(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)` Puts an entry into this map with a given TTL (time to live) value and max idle time value.
`void`	`putAll(Map<? extends K,? extends V> map)`
`protected void`	`putAllInternal(Map<? extends K,? extends V> map, Map<Integer,List<Map.Entry<Data,Data>>> entryMap)`
`ICompletableFuture<V>`	`putAsync(K key, V value)` Asynchronously puts the given key and value.
`ICompletableFuture<V>`	`putAsync(K key, V value, long ttl, TimeUnit timeunit)` Asynchronously puts the given key and value into this map with a given TTL (time to live) value.
`ICompletableFuture<V>`	`putAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)` Asynchronously puts the given key and value into this map with a given TTL (time to live) value and max idle time value.
`protected ICompletableFuture<V>`	`putAsyncInternal(long ttl, TimeUnit timeunit, Long maxIdle, TimeUnit maxIdleUnit, Object key, Object value)`
`V`	`putIfAbsent(K key, V value)` If the specified key is not already associated with a value, associate it with the given value.
`V`	`putIfAbsent(K key, V value, long ttl, TimeUnit timeunit)` Puts an entry into this map with a given TTL (time to live) value, if the specified key is not already associated with a value.
`V`	`putIfAbsent(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)` Puts an entry into this map with a given TTL (time to live) value and max idle time value.
`protected V`	`putIfAbsentInternal(long ttl, TimeUnit timeunit, Long maxIdle, TimeUnit maxIdleUnit, Object key, Object value)`
`protected V`	`putInternal(long ttl, TimeUnit ttlUnit, Long maxIdle, TimeUnit maxIdleUnit, Object key, Object value)`
`void`	`putTransient(K key, V value, long ttl, TimeUnit timeunit)` Same as `#put(K, V, long, java.util.concurrent.TimeUnit)` except that the map store, if defined, will not be called to load/store/persist the entry.
`void`	`putTransient(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)` Same as `#put(K, V, long, java.util.concurrent.TimeUnit)` except that the map store, if defined, will not be called to load/store/persist the entry.
`protected void`	`putTransientInternal(long ttl, TimeUnit timeunit, Long maxIdle, TimeUnit maxIdleUnit, Object key, Object value)`
`<T> ICompletableFuture<ReadResultSet<T>>`	`readFromEventJournal(long startSequence, int minSize, int maxSize, int partitionId, Predicate<? super EventJournalMapEvent<K,V>> predicate, Projection<? super EventJournalMapEvent<K,V>,? extends T> projection)` Reads from the event journal.
`V`	`remove(Object key)` Removes the mapping for a key from this map if it is present.
`boolean`	`remove(Object key, Object value)` Removes the entry for a key only if currently mapped to a given value.
`void`	`removeAll(Predicate<K,V> predicate)` Removes all entries which match with the supplied predicate.
`protected void`	`removeAllInternal(Predicate predicate)`
`ICompletableFuture<V>`	`removeAsync(K key)` Asynchronously removes the given key, returning an `ICompletableFuture` on which the caller can provide an `ExecutionCallback` to be invoked upon remove operation completion or block waiting for the operation to complete with `Future.get()`.
`protected ICompletableFuture<V>`	`removeAsyncInternal(Object key)`
`boolean`	`removeEntryListener(String registrationId)` Removes the specified entry listener.
`void`	`removeInterceptor(String id)` Removes the given interceptor for this map, so it will not intercept operations anymore.
`protected com.hazelcast.client.impl.protocol.codec.MapRemoveCodec.ResponseParameters`	`removeInternal(Object key)`
`protected boolean`	`removeInternal(Object key, Object value)`
`boolean`	`removePartitionLostListener(String registrationId)` Removes the specified map partition lost listener.
`V`	`replace(K key, V value)` Replaces the entry for a key only if it is currently mapped to some value.
`boolean`	`replace(K key, V oldValue, V newValue)` Replaces the entry for a key only if currently mapped to a given value.
`protected boolean`	`replaceIfSameInternal(Object key, Object oldValue, Object newValue)`
`protected V`	`replaceInternal(Object key, Object value)`
`void`	`set(K key, V value)` Puts an entry into this map without returning the old value (which is more efficient than `put()`).
`void`	`set(K key, V value, long ttl, TimeUnit timeunit)` Puts an entry into this map with a given TTL (time to live) value, without returning the old value (which is more efficient than `put()`).
`void`	`set(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)` Puts an entry into this map with a given TTL (time to live) value and max idle time value.
`ICompletableFuture<Void>`	`setAsync(K key, V value)` Asynchronously puts the given key and value.
`ICompletableFuture<Void>`	`setAsync(K key, V value, long ttl, TimeUnit timeunit)` Asynchronously puts an entry into this map with a given TTL (time to live) value, without returning the old value (which is more efficient than `put()`).
`ICompletableFuture<Void>`	`setAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdle, TimeUnit maxIdleUnit)` Asynchronously puts an entry into this map with a given TTL (time to live) value and max idle time value.
`protected ICompletableFuture<Void>`	`setAsyncInternal(long ttl, TimeUnit timeunit, Long maxIdle, TimeUnit maxIdleUnit, Object key, Object value)`
`protected void`	`setInternal(long ttl, TimeUnit timeunit, Long maxIdle, TimeUnit maxIdleUnit, Object key, Object value)`
`boolean`	`setTtl(K key, long ttl, TimeUnit timeunit)` Updates TTL (time to live) value of the entry specified by `key` with a new TTL value.
`protected boolean`	`setTtlInternal(Object key, long ttl, TimeUnit timeUnit)`
`int`	`size()` Returns the number of entries in this map.
`ICompletableFuture`	`submitToKey(K key, EntryProcessor entryProcessor)` Applies the user defined `EntryProcessor` to the entry mapped by the `key`.
`void`	`submitToKey(K key, EntryProcessor entryProcessor, ExecutionCallback callback)` Applies the user defined `EntryProcessor` to the entry mapped by the `key` with specified `ExecutionCallback` to listen event status and returns immediately.
`ICompletableFuture`	`submitToKeyInternal(Object key, EntryProcessor entryProcessor)`
`void`	`submitToKeyInternal(Object key, EntryProcessor entryProcessor, ExecutionCallback callback)`
`ICompletableFuture<Map<K,Object>>`	`submitToKeys(Set<K> keys, EntryProcessor entryProcessor)` Async version of `executeOnKeys(java.util.Set<K>, com.hazelcast.map.EntryProcessor)`.
`ICompletableFuture<EventJournalInitialSubscriberState>`	`subscribeToEventJournal(int partitionId)` Subscribe to the event journal for this reader and a specific partition ID.
`String`	`toString()`
`boolean`	`tryLock(K key)` Tries to acquire the lock for the specified key.
`boolean`	`tryLock(K key, long time, TimeUnit timeunit)` Tries to acquire the lock for the specified key.
`boolean`	`tryLock(K key, long time, TimeUnit timeunit, long leaseTime, TimeUnit leaseUnit)` Tries to acquire the lock for the specified key for the specified lease time.
`boolean`	`tryPut(K key, V value, long timeout, TimeUnit timeunit)` Tries to put the given key and value into this map within a specified timeout value.
`protected boolean`	`tryPutInternal(long timeout, TimeUnit timeunit, Object key, Object value)`
`boolean`	`tryRemove(K key, long timeout, TimeUnit timeunit)` Tries to remove the entry with the given key from this map within the specified timeout value.
`protected boolean`	`tryRemoveInternal(long timeout, TimeUnit timeunit, Object key)`
`void`	`unlock(K key)` Releases the lock for the specified key.
`Collection<V>`	`values()` Returns a collection clone of the values contained in this map.
`Collection<V>`	`values(Predicate predicate)` Queries the map based on the specified predicate and returns the values of matching entries.

Methods inherited from class com.hazelcast.client.spi.ClientProxy
deregisterListener, destroy, destroyLocally, destroyRemotely, equals, getClient, getConnectedServerVersion, getContext, getDistributedObjectName, getId, getName, getPartitionKey, getSerializationService, getServiceName, hashCode, invoke, invoke, invokeOnAddress, invokeOnPartition, invokeOnPartitionInterruptibly, onShutdown, postDestroy, preDestroy, registerListener, setContext, toData, toObject

Methods inherited from class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.concurrent.ConcurrentMap
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll

Methods inherited from interface java.util.Map
equals, hashCode

Methods inherited from interface com.hazelcast.core.DistributedObject
destroy, getName, getPartitionKey, getServiceName

- Field Detail
  - NULL_LISTENER_IS_NOT_ALLOWED
```
protected static final String NULL_LISTENER_IS_NOT_ALLOWED
```
    See Also:
    
    Constant Field Values
  - NULL_KEY_IS_NOT_ALLOWED
```
protected static final String NULL_KEY_IS_NOT_ALLOWED
```
    See Also:
    
    Constant Field Values
  - NULL_VALUE_IS_NOT_ALLOWED
```
protected static final String NULL_VALUE_IS_NOT_ALLOWED
```
    See Also:
    
    Constant Field Values
  - NULL_PREDICATE_IS_NOT_ALLOWED
```
protected static final String NULL_PREDICATE_IS_NOT_ALLOWED
```
    See Also:
    
    Constant Field Values
  - NULL_AGGREGATOR_IS_NOT_ALLOWED
```
protected static final String NULL_AGGREGATOR_IS_NOT_ALLOWED
```
    See Also:
    
    Constant Field Values
  - NULL_PROJECTION_IS_NOT_ALLOWED
```
protected static final String NULL_PROJECTION_IS_NOT_ALLOWED
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - ClientMapProxy
```
public ClientMapProxy(String serviceName,
                      String name,
                      ClientContext context)
```
- Method Detail
  - onInitialize
```
protected void onInitialize()
```
    Description copied from class: ClientProxy
    
    Called when proxy is created. Overriding implementations can add initialization specific logic into this method like registering a listener, creating a cleanup task etc.
    
    Overrides:
    
    onInitialize in class ClientProxy
  - containsKey
```
public boolean containsKey(Object key)
```
    Description copied from interface: IMap
    
    Returns true if this map contains an entry for the specified key.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Interactions with the map store
    If key is not found in memory MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    
    Specified by:
    
    containsKey in interface BaseMap<K,V>
    
    Specified by:
    
    containsKey in interface IMap<K,V>
    
    Specified by:
    
    containsKey in interface Map<K,V>
    
    Parameters:
    
    key - The specified key.
    
    Returns:
    
    true if this map contains an entry for the specified key.
  - containsKeyInternal
```
protected boolean containsKeyInternal(Object key)
```
  - containsValue
```
public boolean containsValue(Object value)
```
    Description copied from interface: IMap
    
    Specified by:
    
    containsValue in interface IMap<K,V>
    
    Specified by:
    
    containsValue in interface Map<K,V>
  - get
```
public V get(Object key)
```
    Description copied from interface: IMap
    Returns the value for the specified key, or null if this map does not contain this key.
    Warning 1:
    This method returns a clone of the original value, so modifying the returned value does not change the actual value in the map. You should put the modified value back to make changes visible to all nodes.
```
      V value = map.get(key);
      value.updateSomeProperty();
      map.put(key, value);
 
```
    Warning 2:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Interactions with the map store
    If value with key is not found in memory MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    Specified by:
    
    get in interface BaseMap<K,V>
    
    Specified by:
    
    get in interface IMap<K,V>
    
    Specified by:
    
    get in interface Map<K,V>
    
    Parameters:
    
    key - The specified key.
    
    Returns:
    
    The value for the specified key.
  - getInternal
```
protected Object getInternal(Object key)
```
  - put
```
public V put(K key,
             V value)
```
    Description copied from interface: IMap
    
    Associates the specified value with the specified key in this map. If the map previously contained a mapping for the key, the old value is replaced by the specified value.
    Warning 1:
    This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
    Warning 2:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Note: Use IMap.set(Object, Object) if you don't need the return value, it's slightly more efficient.
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    put in interface BaseMap<K,V>
    
    Specified by:
    
    put in interface IMap<K,V>
    
    Specified by:
    
    put in interface Map<K,V>
    
    Parameters:
    
    key - The specified key.
    
    value - The value to associate with the key.
    
    Returns:
    
    Previous value associated with key or null if there was no mapping for key.
  - put
```
public V put(K key,
             V value,
             long ttl,
             TimeUnit ttlUnit,
             long maxIdle,
             TimeUnit maxIdleUnit)
```
    Description copied from interface: IMap
    
    Puts an entry into this map with a given TTL (time to live) value and max idle time value.
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
    The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
    Warning 3:
    Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
    
    Note: Use IMap.set(Object, Object, long, TimeUnit) if you don't need the return value, it's slightly more efficient.
    
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    put in interface IMap<K,V>
    
    Parameters:
    
    key - key of the entry
    
    value - value of the entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    ttlUnit - time unit for the TTL
    
    maxIdle - maximum time for this entry to stay idle in the map. (0 means infinite, negative means map config default)
    
    maxIdleUnit - time unit for the Max-Idle
    
    Returns:
    
    old value of the entry
  - remove
```
public V remove(Object key)
```
    Description copied from interface: IMap
    
    Removes the mapping for a key from this map if it is present.
    If you don't need the previously mapped value for the removed key, prefer to use IMap.delete(java.lang.Object) and avoid the cost of serialization and network transfer.
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is removed from the memory, MapStore.delete(Object) is called to remove the value from the map store. Exceptions thrown by delete fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    remove in interface BaseMap<K,V>
    
    Specified by:
    
    remove in interface IMap<K,V>
    
    Specified by:
    
    remove in interface Map<K,V>
    
    Parameters:
    
    key - Remove the mapping for this key.
    
    Returns:
    
    The previous value associated with key, or null if there was no mapping for key.
    
    See Also:
    
    IMap.delete(Object)
  - removeInternal
```
protected com.hazelcast.client.impl.protocol.codec.MapRemoveCodec.ResponseParameters removeInternal(Object key)
```
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Description copied from interface: IMap
    Removes the entry for a key only if currently mapped to a given value. This is equivalent to
```
   if (map.containsKey(key) && map.get(key).equals(value)) {
       map.remove(key);
       return true;
   } else return false;
```
    except that the action is performed atomically.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is removed from the memory, MapStore.delete(Object) is called to remove the value from the map store. Exceptions thrown by delete fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    remove in interface BaseMap<K,V>
    
    Specified by:
    
    remove in interface IMap<K,V>
    
    Specified by:
    
    remove in interface ConcurrentMap<K,V>
    
    Specified by:
    
    remove in interface Map<K,V>
    
    Parameters:
    
    key - The specified key.
    
    value - Remove the key if it has this value.
    
    Returns:
    
    true if the value was removed.
  - removeInternal
```
protected boolean removeInternal(Object key,
                                 Object value)
```
  - removeAll
```
public void removeAll(Predicate<K,V> predicate)
```
    Description copied from interface: IMap
    
    Removes all entries which match with the supplied predicate.
    If this map has index, matching entries will be found via index search, otherwise they will be found by full-scan.
    Note that calling this method also removes all entries from callers Near Cache.
    Interactions with the map store
    If write-through persistence mode is configured, before a value is removed from the memory, MapStore.delete(Object) is called to remove the value from the map store. Exceptions thrown by delete fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    removeAll in interface IMap<K,V>
    
    Parameters:
    
    predicate - matching entries with this predicate will be removed from this map
  - removeAllInternal
```
protected void removeAllInternal(Predicate predicate)
```
  - delete
```
public void delete(Object key)
```
    Description copied from interface: IMap
    
    Removes the mapping for the key from this map if it is present.
    Unlike IMap.remove(Object), this operation does not return the removed value, which avoids the serialization and network transfer cost of the returned value. If the removed value will not be used, this operation is preferred over the remove operation for better performance.
    The map will not contain a mapping for the specified key once the call returns.
    Warning:
    This method breaks the contract of EntryListener. When an entry is removed by delete(), it fires an EntryEvent with a null oldValue.
    Also, a listener with predicates will have null values, so only keys can be queried via predicates.
    Interactions with the map store
    If write-through persistence mode is configured, before the value is removed from the the memory, MapStore.delete(Object) is called to remove the value from the map store. Exceptions thrown by delete fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    delete in interface BaseMap<K,V>
    
    Specified by:
    
    delete in interface IMap<K,V>
    
    Parameters:
    
    key - key whose mapping is to be removed from the map
    
    See Also:
    
    IMap.remove(Object)
  - deleteInternal
```
protected void deleteInternal(Object key)
```
  - flush
```
public void flush()
```
    Description copied from interface: IMap
    
    If this map has a MapStore, this method flushes all the local dirty entries.
    Interactions with the map store
    Calls MapStore.storeAll(Map) and/or MapStore.deleteAll(Collection) with elements marked dirty. Please note that this method has effect only if write-behind persistence mode is configured. If the persistence mode is write-through calling this method has no practical effect, but an operation is executed on all partitions wasting resources.
    
    Specified by:
    
    flush in interface IMap<K,V>
  - getAsync
```
public ICompletableFuture<V> getAsync(K key)
```
    Description copied from interface: IMap
    Asynchronously gets the given key.
```
   ICompletableFuture future = map.getAsync(key);
   // do some other stuff, when ready get the result.
   Object value = future.get();
 
```
    Future.get() will block until the actual map.get() completes. If the application requires timely response, then Future.get(long, TimeUnit) can be used.
```
   try {
     ICompletableFuture future = map.getAsync(key);
     Object value = future.get(40, TimeUnit.MILLISECOND);
   } catch (TimeoutException t) {
     // time wasn't enough
   }
 
```
    Additionally, the client can schedule an ExecutionCallback to be invoked upon completion of the ICompletableFuture via ICompletableFuture.andThen(ExecutionCallback) or ICompletableFuture.andThen(ExecutionCallback, Executor):
```
   // assuming an IMap<String, String>
   ICompletableFuture<String> future = map.getAsync("a");
   future.andThen(new ExecutionCallback<String>() {
     public void onResponse(String response) {
       // do something with value in response
     }

     public void onFailure(Throwable t) {
       // handle failure
     }
   });
 
```
    ExecutionException is never thrown.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Interactions with the map store
    If value with key is not found in memory MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    Specified by:
    
    getAsync in interface IMap<K,V>
    
    Specified by:
    
    getAsync in interface LegacyAsyncMap<K,V>
    
    Parameters:
    
    key - the key of the map entry
    
    Returns:
    
    ICompletableFuture from which the value of the key can be retrieved
    
    See Also:
    
    ICompletableFuture
  - getAsyncInternal
```
protected ICompletableFuture<V> getAsyncInternal(Object key)
```
  - putAsync
```
public ICompletableFuture<V> putAsync(K key,
                                      V value)
```
    Description copied from interface: IMap
    Asynchronously puts the given key and value.
```
   ICompletableFuture future = map.putAsync(key, value);
   // do some other stuff, when ready get the result.
   Object oldValue = future.get();
 
```
    ICompletableFuture.get() will block until the actual map.put() completes. If the application requires a timely response, then you can use Future.get(timeout, timeunit).
```
   try {
     ICompletableFuture future = map.putAsync(key, newValue);
     Object oldValue = future.get(40, TimeUnit.MILLISECOND);
   } catch (TimeoutException t) {
     // time wasn't enough
   }
 
```
    Additionally, the client can schedule an ExecutionCallback to be invoked upon completion of the ICompletableFuture via ICompletableFuture.andThen(ExecutionCallback) or ICompletableFuture.andThen(ExecutionCallback, Executor):
```
   // assuming an IMap<String, String>
   ICompletableFuture<String> future = map.putAsync("a", "b");
   future.andThen(new ExecutionCallback<String>() {
     public void onResponse(String response) {
       // do something with the old value returned by put operation
     }

     public void onFailure(Throwable t) {
       // handle failure
     }
   });
 
```
    ExecutionException is never thrown.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Note: Use IMap.setAsync(Object, Object) if you don't need the return value, it's slightly more efficient.
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    putAsync in interface IMap<K,V>
    
    Specified by:
    
    putAsync in interface LegacyAsyncMap<K,V>
    
    Parameters:
    
    key - the key of the map entry
    
    value - the new value of the map entry
    
    Returns:
    
    ICompletableFuture from which the old value of the key can be retrieved
    
    See Also:
    
    ICompletableFuture, IMap.setAsync(Object, Object)
  - putAsync
```
public ICompletableFuture<V> putAsync(K key,
                                      V value,
                                      long ttl,
                                      TimeUnit timeunit)
```
    Description copied from interface: IMap
    Asynchronously puts the given key and value into this map with a given TTL (time to live) value.
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
```
   ICompletableFuture future = map.putAsync(key, value, ttl, timeunit);
   // do some other stuff, when ready get the result
   Object oldValue = future.get();
 
```
    ICompletableFuture.get() will block until the actual map.put() completes. If your application requires a timely response, then you can use Future.get(timeout, timeunit).
```
   try {
     ICompletableFuture future = map.putAsync(key, newValue, ttl, timeunit);
     Object oldValue = future.get(40, TimeUnit.MILLISECOND);
   } catch (TimeoutException t) {
     // time wasn't enough
   }
 
```
    The client can schedule an ExecutionCallback to be invoked upon completion of the ICompletableFuture via ICompletableFuture.andThen(ExecutionCallback) or ICompletableFuture.andThen(ExecutionCallback, Executor):
```
   // assuming an IMap<String, String>
   ICompletableFuture<String> future = map.putAsync("a", "b", 5, TimeUnit.MINUTES);
   future.andThen(new ExecutionCallback<String>() {
     public void onResponse(String response) {
       // do something with old value returned by put operation
     }

     public void onFailure(Throwable t) {
       // handle failure
     }
   });
 
```
    ExecutionException is never thrown.
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
    
    Note: Use IMap.setAsync(Object, Object, long, TimeUnit) if you don't need the return value, it's slightly more efficient.
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    putAsync in interface IMap<K,V>
    
    Specified by:
    
    putAsync in interface LegacyAsyncMap<K,V>
    
    Parameters:
    
    key - the key of the map entry
    
    value - the new value of the map entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    timeunit - time unit for the TTL
    
    Returns:
    
    ICompletableFuture from which the old value of the key can be retrieved
    
    See Also:
    
    ICompletableFuture, IMap.setAsync(Object, Object, long, TimeUnit)
  - putAsync
```
public ICompletableFuture<V> putAsync(K key,
                                      V value,
                                      long ttl,
                                      TimeUnit ttlUnit,
                                      long maxIdle,
                                      TimeUnit maxIdleUnit)
```
    Description copied from interface: IMap
    Asynchronously puts the given key and value into this map with a given TTL (time to live) value and max idle time value.
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
    The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
```
   ICompletableFuture future = map.putAsync(key, value, ttl, timeunit);
   // do some other stuff, when ready get the result
   Object oldValue = future.get();
 
```
    ICompletableFuture.get() will block until the actual map.put() completes. If your application requires a timely response, then you can use Future.get(timeout, timeunit).
```
   try {
     ICompletableFuture future = map.putAsync(key, newValue, ttl, timeunit);
     Object oldValue = future.get(40, TimeUnit.MILLISECOND);
   } catch (TimeoutException t) {
     // time wasn't enough
   }
 
```
    The client can schedule an ExecutionCallback to be invoked upon completion of the ICompletableFuture via ICompletableFuture.andThen(ExecutionCallback) or ICompletableFuture.andThen(ExecutionCallback, Executor):
```
   // assuming an IMap<String, String>
   ICompletableFuture<String> future = map.putAsync("a", "b", 5, TimeUnit.MINUTES);
   future.andThen(new ExecutionCallback<String>() {
     public void onResponse(String response) {
       // do something with old value returned by put operation
     }

     public void onFailure(Throwable t) {
       // handle failure
     }
   });
 
```
    ExecutionException is never thrown.
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
    
    Note: Use IMap.setAsync(Object, Object, long, TimeUnit) if you don't need the return value, it's slightly more efficient.
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    putAsync in interface IMap<K,V>
    
    Parameters:
    
    key - the key of the map entry
    
    value - the new value of the map entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    ttlUnit - time unit for the TTL
    
    maxIdle - maximum time for this entry to stay idle in the map. (0 means infinite, negative means map config default)
    
    maxIdleUnit - time unit for the Max-Idle
    
    Returns:
    
    ICompletableFuture from which the old value of the key can be retrieved
    
    See Also:
    
    ICompletableFuture, IMap.setAsync(Object, Object, long, TimeUnit)
  - putAsyncInternal
```
protected ICompletableFuture<V> putAsyncInternal(long ttl,
                                                 TimeUnit timeunit,
                                                 Long maxIdle,
                                                 TimeUnit maxIdleUnit,
                                                 Object key,
                                                 Object value)
```
  - setAsync
```
public ICompletableFuture<Void> setAsync(K key,
                                         V value)
```
    Description copied from interface: IMap
    Asynchronously puts the given key and value. The entry lives forever. Similar to the put operation except that set doesn't return the old value, which is more efficient.
```
   ICompletableFuture<Void> future = map.setAsync(key, value);
   // do some other stuff, when ready wait for completion
   future.get();
 
```
    ICompletableFuture.get() will block until the actual map.set() operation completes. If your application requires a timely response, then you can use ICompletableFuture.get(timeout, timeunit).
```
   try {
     ICompletableFuture<Void> future = map.setAsync(key, newValue);
     future.get(40, TimeUnit.MILLISECOND);
   } catch (TimeoutException t) {
     // time wasn't enough
   }
 
```
    You can also schedule an ExecutionCallback to be invoked upon completion of the ICompletableFuture via ICompletableFuture.andThen(ExecutionCallback) or ICompletableFuture.andThen(ExecutionCallback, Executor):
```
   ICompletableFuture<Void> future = map.setAsync("a", "b");
   future.andThen(new ExecutionCallback<String>() {
     public void onResponse(Void response) {
       // Set operation was completed
     }

     public void onFailure(Throwable t) {
       // handle failure
     }
   });
 
```
    ExecutionException is never thrown.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Interactions with the map store
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    setAsync in interface IMap<K,V>
    
    Specified by:
    
    setAsync in interface LegacyAsyncMap<K,V>
    
    Parameters:
    
    key - the key of the map entry
    
    value - the new value of the map entry
    
    Returns:
    
    ICompletableFuture on which to block waiting for the operation to complete or register an ExecutionCallback to be invoked upon completion
    
    See Also:
    
    ICompletableFuture
  - setAsync
```
public ICompletableFuture<Void> setAsync(K key,
                                         V value,
                                         long ttl,
                                         TimeUnit timeunit)
```
    Description copied from interface: IMap
    Asynchronously puts an entry into this map with a given TTL (time to live) value, without returning the old value (which is more efficient than put()).
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
    The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
```
   ICompletableFuture<Void> future = map.setAsync(key, value, ttl, timeunit);
   // do some other stuff, when you want to make sure set operation is complete:
   future.get();
 
```
    ICompletableFuture.get() will block until the actual map set operation completes. If your application requires a timely response, then you can use Future.get(long, TimeUnit).
```
   try {
     ICompletableFuture future = map.setAsync(key, newValue, ttl, timeunit);
     future.get(40, TimeUnit.MILLISECOND);
   } catch (TimeoutException t) {
     // time wasn't enough
   }
 
```
    You can also schedule an ExecutionCallback to be invoked upon completion of the ICompletableFuture via ICompletableFuture.andThen(ExecutionCallback) or ICompletableFuture.andThen(ExecutionCallback, Executor):
```
   ICompletableFuture<Void> future = map.setAsync("a", "b", 5, TimeUnit.MINUTES);
   future.andThen(new ExecutionCallback<String>() {
     public void onResponse(Void response) {
       // Set operation was completed
     }

     public void onFailure(Throwable t) {
       // handle failure
     }
   });
 
```
    ExecutionException is never thrown.
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
    Interactions with the map store
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller..
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    setAsync in interface IMap<K,V>
    
    Specified by:
    
    setAsync in interface LegacyAsyncMap<K,V>
    
    Parameters:
    
    key - the key of the map entry
    
    value - the new value of the map entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    timeunit - time unit for the TTL
    
    Returns:
    
    ICompletableFuture on which client code can block waiting for the operation to complete or provide an ExecutionCallback to be invoked upon set operation completion
    
    See Also:
    
    ICompletableFuture
  - setAsync
```
public ICompletableFuture<Void> setAsync(K key,
                                         V value,
                                         long ttl,
                                         TimeUnit ttlUnit,
                                         long maxIdle,
                                         TimeUnit maxIdleUnit)
```
    Description copied from interface: IMap
    Asynchronously puts an entry into this map with a given TTL (time to live) value and max idle time value. without returning the old value (which is more efficient than put()).
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
    The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
```
   ICompletableFuture<Void> future = map.setAsync(key, value, ttl, timeunit);
   // do some other stuff, when you want to make sure set operation is complete:
   future.get();
 
```
    ICompletableFuture.get() will block until the actual map set operation completes. If your application requires a timely response, then you can use Future.get(long, TimeUnit).
```
   try {
     ICompletableFuture future = map.setAsync(key, newValue, ttl, timeunit);
     future.get(40, TimeUnit.MILLISECOND);
   } catch (TimeoutException t) {
     // time wasn't enough
   }
 
```
    You can also schedule an ExecutionCallback to be invoked upon completion of the ICompletableFuture via ICompletableFuture.andThen(ExecutionCallback) or ICompletableFuture.andThen(ExecutionCallback, Executor):
```
   ICompletableFuture<Void> future = map.setAsync("a", "b", 5, TimeUnit.MINUTES);
   future.andThen(new ExecutionCallback<String>() {
     public void onResponse(Void response) {
       // Set operation was completed
     }

     public void onFailure(Throwable t) {
       // handle failure
     }
   });
 
```
    ExecutionException is never thrown.
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
    Interactions with the map store
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller..
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    setAsync in interface IMap<K,V>
    
    Parameters:
    
    key - the key of the map entry
    
    value - the new value of the map entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    ttlUnit - time unit for the TTL
    
    maxIdle - maximum time for this entry to stay idle in the map. (0 means infinite, negative means map config default)
    
    maxIdleUnit - time unit for the Max-Idle
    
    Returns:
    
    ICompletableFuture on which client code can block waiting for the operation to complete or provide an ExecutionCallback to be invoked upon set operation completion
    
    See Also:
    
    ICompletableFuture
  - setAsyncInternal
```
protected ICompletableFuture<Void> setAsyncInternal(long ttl,
                                                    TimeUnit timeunit,
                                                    Long maxIdle,
                                                    TimeUnit maxIdleUnit,
                                                    Object key,
                                                    Object value)
```
  - removeAsync
```
public ICompletableFuture<V> removeAsync(K key)
```
    Description copied from interface: IMap
    
    Asynchronously removes the given key, returning an ICompletableFuture on which the caller can provide an ExecutionCallback to be invoked upon remove operation completion or block waiting for the operation to complete with Future.get().
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Interactions with the map store
    If write-through persistence mode is configured, before the value is removed from the the memory, MapStore.delete(Object) is called to remove the value from the map store. Exceptions thrown by delete fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    removeAsync in interface IMap<K,V>
    
    Specified by:
    
    removeAsync in interface LegacyAsyncMap<K,V>
    
    Parameters:
    
    key - The key of the map entry to remove
    
    Returns:
    
    ICompletableFuture from which the value removed from the map can be retrieved
    
    See Also:
    
    ICompletableFuture
  - removeAsyncInternal
```
protected ICompletableFuture<V> removeAsyncInternal(Object key)
```
  - tryRemove
```
public boolean tryRemove(K key,
                         long timeout,
                         TimeUnit timeunit)
```
    Description copied from interface: IMap
    
    Tries to remove the entry with the given key from this map within the specified timeout value. If the key is already locked by another thread and/or member, then this operation will wait the timeout amount for acquiring the lock.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Interactions with the map store
    If write-through persistence mode is configured, before the value is removed from the the memory, MapStore.delete(Object) is called to remove the value from the map store. Exceptions thrown by delete fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    tryRemove in interface IMap<K,V>
    
    Parameters:
    
    key - key of the entry
    
    timeout - maximum time to wait for acquiring the lock for the key
    
    timeunit - time unit for the timeout
    
    Returns:
    
    true if the remove is successful, false otherwise
  - tryRemoveInternal
```
protected boolean tryRemoveInternal(long timeout,
                                    TimeUnit timeunit,
                                    Object key)
```
  - tryPut
```
public boolean tryPut(K key,
                      V value,
                      long timeout,
                      TimeUnit timeunit)
```
    Description copied from interface: IMap
    
    Tries to put the given key and value into this map within a specified timeout value. If this method returns false, it means that the caller thread could not acquire the lock for the key within the timeout duration, thus the put operation is not successful.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    tryPut in interface IMap<K,V>
    
    Parameters:
    
    key - key of the entry
    
    value - value of the entry
    
    timeout - maximum time to wait
    
    timeunit - time unit for the timeout
    
    Returns:
    
    true if the put is successful, false otherwise
  - tryPutInternal
```
protected boolean tryPutInternal(long timeout,
                                 TimeUnit timeunit,
                                 Object key,
                                 Object value)
```
  - put
```
public V put(K key,
             V value,
             long ttl,
             TimeUnit timeunit)
```
    Description copied from interface: IMap
    
    Puts an entry into this map with a given TTL (time to live) value.
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
    Warning 3:
    Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
    
    Note: Use IMap.set(Object, Object, long, TimeUnit) if you don't need the return value, it's slightly more efficient.
    
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    put in interface BaseMap<K,V>
    
    Specified by:
    
    put in interface IMap<K,V>
    
    Parameters:
    
    key - key of the entry
    
    value - value of the entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    timeunit - time unit for the TTL
    
    Returns:
    
    old value of the entry
  - putInternal
```
protected V putInternal(long ttl,
                        TimeUnit ttlUnit,
                        Long maxIdle,
                        TimeUnit maxIdleUnit,
                        Object key,
                        Object value)
```
  - putTransient
```
public void putTransient(K key,
                         V value,
                         long ttl,
                         TimeUnit timeunit)
```
    Description copied from interface: IMap
    
    Same as #put(K, V, long, java.util.concurrent.TimeUnit) except that the map store, if defined, will not be called to load/store/persist the entry.
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    Time resolution for TTL is seconds. The given TTL value is rounded to next closest second value.
    
    Specified by:
    
    putTransient in interface IMap<K,V>
    
    Parameters:
    
    key - key of the entry
    
    value - value of the entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    timeunit - time unit for the TTL
  - putTransient
```
public void putTransient(K key,
                         V value,
                         long ttl,
                         TimeUnit ttlUnit,
                         long maxIdle,
                         TimeUnit maxIdleUnit)
```
    Description copied from interface: IMap
    
    Same as #put(K, V, long, java.util.concurrent.TimeUnit) except that the map store, if defined, will not be called to load/store/persist the entry.
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
    The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    Time resolution for TTL is seconds. The given TTL value is rounded to next closest second value.
    
    Specified by:
    
    putTransient in interface IMap<K,V>
    
    Parameters:
    
    key - key of the entry
    
    value - value of the entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    ttlUnit - time unit for the TTL
    
    maxIdle - maximum time for this entry to stay idle in the map. (0 means infinite, negative means map config default)
    
    maxIdleUnit - time unit for the Max-Idle
  - putTransientInternal
```
protected void putTransientInternal(long ttl,
                                    TimeUnit timeunit,
                                    Long maxIdle,
                                    TimeUnit maxIdleUnit,
                                    Object key,
                                    Object value)
```
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value)
```
    Description copied from interface: IMap
    If the specified key is not already associated with a value, associate it with the given value. This is equivalent to
```
   if (!map.containsKey(key))
       return map.put(key, value);
   else
       return map.get(key);
```
    except that the action is performed atomically.
    Note:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Also, this method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    putIfAbsent in interface BaseMap<K,V>
    
    Specified by:
    
    putIfAbsent in interface IMap<K,V>
    
    Specified by:
    
    putIfAbsent in interface ConcurrentMap<K,V>
    
    Specified by:
    
    putIfAbsent in interface Map<K,V>
    
    Parameters:
    
    key - The specified key.
    
    value - The value to associate with the key when there is no previous value.
    
    Returns:
    
    a clone of the previous value
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value,
                     long ttl,
                     TimeUnit timeunit)
```
    Description copied from interface: IMap
    
    Puts an entry into this map with a given TTL (time to live) value, if the specified key is not already associated with a value.
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
    Warning 3:
    Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    putIfAbsent in interface IMap<K,V>
    
    Parameters:
    
    key - key of the entry
    
    value - value of the entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    timeunit - time unit for the TTL
    
    Returns:
    
    old value of the entry
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value,
                     long ttl,
                     TimeUnit ttlUnit,
                     long maxIdle,
                     TimeUnit maxIdleUnit)
```
    Description copied from interface: IMap
    
    Puts an entry into this map with a given TTL (time to live) value and max idle time value. if the specified key is not already associated with a value.
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
    The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
    Warning 3:
    Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
    Interactions with the map store
    If no value is found with key in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map. Exceptions thrown by load fail the operation and are propagated to the caller.
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    putIfAbsent in interface IMap<K,V>
    
    Parameters:
    
    key - key of the entry
    
    value - value of the entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    ttlUnit - time unit for the TTL
    
    maxIdle - maximum time for this entry to stay idle in the map. (0 means infinite, negative means map config default)
    
    maxIdleUnit - time unit for the Max-Idle
    
    Returns:
    
    old value of the entry
  - putIfAbsentInternal
```
protected V putIfAbsentInternal(long ttl,
                                TimeUnit timeunit,
                                Long maxIdle,
                                TimeUnit maxIdleUnit,
                                Object key,
                                Object value)
```
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
    Description copied from interface: IMap
    Replaces the entry for a key only if currently mapped to a given value. This is equivalent to
```
   if (map.containsKey(key) && map.get(key).equals(oldValue)) {
       map.put(key, newValue);
       return true;
   } else return false;
```
    except that the action is performed atomically.
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    This method may return false even if the operation succeeds.
    Background: If the partition owner for given key goes down after successful value replace, but before the executing node retrieved the invocation result response, then the operation is retried. The invocation retry fails because the value is already updated and the result of such replace call returns false. Hazelcast doesn't guarantee exactly once invocation.
    
    Interactions with the map store
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    replace in interface BaseMap<K,V>
    
    Specified by:
    
    replace in interface IMap<K,V>
    
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
    
    Parameters:
    
    key - The specified key.
    
    oldValue - Replace the key value if it is the old value.
    
    newValue - The new value to replace the old value.
    
    Returns:
    
    true if the value was replaced.
  - replaceIfSameInternal
```
protected boolean replaceIfSameInternal(Object key,
                                        Object oldValue,
                                        Object newValue)
```
  - replace
```
public V replace(K key,
                 V value)
```
    Description copied from interface: IMap
    Replaces the entry for a key only if it is currently mapped to some value. This is equivalent to
```
   if (map.containsKey(key)) {
       return map.put(key, value);
   } else return null;
```
    except that the action is performed atomically.
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.
    Interactions with the map store
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    replace in interface BaseMap<K,V>
    
    Specified by:
    
    replace in interface IMap<K,V>
    
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
    
    Parameters:
    
    key - The specified key.
    
    value - The value to replace the previous value.
    
    Returns:
    
    The previous value associated with key, or null if there was no mapping for key.
  - replaceInternal
```
protected V replaceInternal(Object key,
                            Object value)
```
  - set
```
public void set(K key,
                V value,
                long ttl,
                TimeUnit timeunit)
```
    Description copied from interface: IMap
    
    Puts an entry into this map with a given TTL (time to live) value, without returning the old value (which is more efficient than put()).
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
    Interactions with the map store
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    set in interface IMap<K,V>
    
    Parameters:
    
    key - key of the entry
    
    value - value of the entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    timeunit - time unit for the TTL
  - set
```
public void set(K key,
                V value,
                long ttl,
                TimeUnit ttlUnit,
                long maxIdle,
                TimeUnit maxIdleUnit)
```
    Description copied from interface: IMap
    
    Puts an entry into this map with a given TTL (time to live) value and max idle time value. without returning the old value (which is more efficient than put()).
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever).
    The entry will expire and get evicted after the Max Idle time. If the MaxIdle is 0, then the entry lives forever. If the MaxIdle is negative, then the MaxIdle from the map configuration will be used (default: forever).
    Warning 1:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Warning 2:
    Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
    Interactions with the map store
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    set in interface IMap<K,V>
    
    Parameters:
    
    key - key of the entry
    
    value - value of the entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    ttlUnit - time unit for the TTL
    
    maxIdle - maximum time for this entry to stay idle in the map. (0 means infinite, negative means map config default)
    
    maxIdleUnit - time unit for the Max-Idle
  - setInternal
```
protected void setInternal(long ttl,
                           TimeUnit timeunit,
                           Long maxIdle,
                           TimeUnit maxIdleUnit,
                           Object key,
                           Object value)
```
  - lock
```
public void lock(K key)
```
    Description copied from interface: IMap
    
    Acquires the lock for the specified key.
    If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired.
    You get a lock whether the value is present in the map or not. Other threads (possibly on other systems) would block on their invoke of lock() until the non-existent key is unlocked. If the lock holder introduces the key to the map, the put() operation is not blocked. If a thread not holding a lock on the non-existent key tries to introduce the key while a lock exists on the non-existent key, the put() operation blocks until it is unlocked.
    Scope of the lock is this map only. Acquired lock is only for the key in this map.
    Locks are re-entrant so if the key is locked N times then it should be unlocked N times before another thread can acquire it.
    There is no lock timeout on this method. Locks will be held infinitely.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Specified by:
    
    lock in interface IMap<K,V>
    
    Parameters:
    
    key - key to lock
  - lock
```
public void lock(K key,
                 long leaseTime,
                 TimeUnit timeUnit)
```
    Description copied from interface: IMap
    
    Acquires the lock for the specified key for the specified lease time.
    After lease time, the lock will be released.
    If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired.
    Scope of the lock is this map only. Acquired lock is only for the key in this map.
    Locks are re-entrant, so if the key is locked N times then it should be unlocked N times before another thread can acquire it.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Specified by:
    
    lock in interface IMap<K,V>
    
    Parameters:
    
    key - the key to lock
    
    leaseTime - time to wait before releasing the lock
    
    timeUnit - unit of time to specify lease time
  - isLocked
```
public boolean isLocked(K key)
```
    Description copied from interface: IMap
    
    Checks the lock for the specified key.
    If the lock is acquired then returns true, else returns false.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Specified by:
    
    isLocked in interface IMap<K,V>
    
    Parameters:
    
    key - the key that is checked for lock
    
    Returns:
    
    true if lock is acquired, false otherwise
  - tryLock
```
public boolean tryLock(K key)
```
    Description copied from interface: IMap
    
    Tries to acquire the lock for the specified key.
    If the lock is not available then the current thread doesn't wait and returns false immediately.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Specified by:
    
    tryLock in interface IMap<K,V>
    
    Parameters:
    
    key - the key to lock
    
    Returns:
    
    true if lock is acquired, false otherwise
  - tryLock
```
public boolean tryLock(K key,
                       long time,
                       TimeUnit timeunit)
                throws InterruptedException
```
    Description copied from interface: IMap
    Tries to acquire the lock for the specified key.
    If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of two things happens:
    - the lock is acquired by the current thread, or
    - the specified waiting time elapses.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Specified by:
    
    tryLock in interface IMap<K,V>
    
    Parameters:
    
    key - key to lock in this map
    
    time - maximum time to wait for the lock
    
    timeunit - time unit of the time argument
    
    Returns:
    
    true if the lock was acquired, false if the waiting time elapsed before the lock was acquired
    
    Throws:
    
    InterruptedException
  - tryLock
```
public boolean tryLock(K key,
                       long time,
                       TimeUnit timeunit,
                       long leaseTime,
                       TimeUnit leaseUnit)
                throws InterruptedException
```
    Description copied from interface: IMap
    Tries to acquire the lock for the specified key for the specified lease time.
    After lease time, the lock will be released.
    If the lock is not available, then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of two things happens:
    - the lock is acquired by the current thread, or
    - the specified waiting time elapses.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Specified by:
    
    tryLock in interface IMap<K,V>
    
    Parameters:
    
    key - key to lock in this map
    
    time - maximum time to wait for the lock
    
    timeunit - time unit of the time argument
    
    leaseTime - time to wait before releasing the lock
    
    leaseUnit - unit of time to specify lease time
    
    Returns:
    
    true if the lock was acquired, false if the waiting time elapsed before the lock was acquired
    
    Throws:
    
    InterruptedException
  - unlock
```
public void unlock(K key)
```
    Description copied from interface: IMap
    
    Releases the lock for the specified key. It never blocks and returns immediately.
    If the current thread is the holder of this lock, then the hold count is decremented. If the hold count is zero, then the lock is released. If the current thread is not the holder of this lock, then IllegalMonitorStateException is thrown.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Specified by:
    
    unlock in interface IMap<K,V>
    
    Parameters:
    
    key - the key to lock
  - forceUnlock
```
public void forceUnlock(K key)
```
    Description copied from interface: IMap
    
    Releases the lock for the specified key regardless of the lock owner. It always successfully unlocks the key, never blocks, and returns immediately.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Specified by:
    
    forceUnlock in interface IMap<K,V>
    
    Parameters:
    
    key - the key to lock
  - addLocalEntryListener
```
public String addLocalEntryListener(MapListener listener)
```
    Description copied from interface: IMap
    
    Adds a MapListener for this map. To receive an event, you should implement a corresponding MapListener sub-interface for that event.
    Note that entries in distributed map are partitioned across the cluster members; each member owns and manages the some portion of the entries. Owned entries are called local entries. This listener will be listening for the events of local entries. Let's say your cluster has member1 and member2. On member2 you added a local listener and from member1, you call map.put(key2, value2). If the key2 is owned by member2 then the local listener will be notified for the add/update event. Also note that entries can migrate to other nodes for load balancing and/or membership change.
    
    Specified by:
    
    addLocalEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - MapListener for this map
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
    
    See Also:
    
    IMap.localKeySet(), MapListener
  - addLocalEntryListener
```
public String addLocalEntryListener(EntryListener listener)
```
    Description copied from interface: IMap
    
    Adds a local entry listener for this map. The added listener will only be listening for the events (add/remove/update/evict) of the locally owned entries.
    Note that entries in distributed map are partitioned across the cluster members; each member owns and manages the some portion of the entries. Owned entries are called local entries. This listener will be listening for the events of local entries. Let's say your cluster has member1 and member2. On member2 you added a local listener and from member1, you call map.put(key2, value2). If the key2 is owned by member2 then the local listener will be notified for the add/update event. Also note that entries can migrate to other nodes for load balancing and/or membership change.
    
    Specified by:
    
    addLocalEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - entry listener
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
    
    See Also:
    
    IMap.localKeySet()
  - addLocalEntryListener
```
public String addLocalEntryListener(MapListener listener,
                                    Predicate<K,V> predicate,
                                    boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds a MapListener for this map.
    To receive an event, you should implement a corresponding MapListener sub-interface for that event. The listener will get notified for map events filtered by the given predicate.
    
    Specified by:
    
    addLocalEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - MapListener for this map
    
    predicate - predicate for filtering entries
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
    
    See Also:
    
    MapListener
  - addLocalEntryListener
```
public String addLocalEntryListener(EntryListener listener,
                                    Predicate<K,V> predicate,
                                    boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds a local entry listener for this map.
    The added listener will only be listening for the events (add/remove/update/evict) of the locally owned entries. The listener will get notified for map add/remove/update/evict events filtered by the given predicate.
    
    Specified by:
    
    addLocalEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - entry listener
    
    predicate - predicate for filtering entries
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
  - addLocalEntryListener
```
public String addLocalEntryListener(MapListener listener,
                                    Predicate<K,V> predicate,
                                    K key,
                                    boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds a local entry listener for this map.
    The added listener will only be listening for the events (add/remove/update/evict) of the locally owned entries. The listener will get notified for map add/remove/update/evict events filtered by the given predicate.
    
    Specified by:
    
    addLocalEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - MapListener for this map
    
    predicate - predicate for filtering entries
    
    key - key to listen for
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
    
    See Also:
    
    MapListener
  - addLocalEntryListener
```
public String addLocalEntryListener(EntryListener listener,
                                    Predicate<K,V> predicate,
                                    K key,
                                    boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds a local entry listener for this map.
    The added listener will only be listening for the events (add/remove/update/evict) of the locally owned entries. The listener will get notified for map add/remove/update/evict events filtered by the given predicate.
    
    Specified by:
    
    addLocalEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - entry listener
    
    predicate - predicate for filtering entries
    
    key - key to listen fo
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
  - addInterceptor
```
public String addInterceptor(MapInterceptor interceptor)
```
    Description copied from interface: IMap
    
    Adds an interceptor for this map.
    Added interceptor will intercept operations and execute user defined methods. They will cancel operations if the user defined method throws an exception.
    
    Specified by:
    
    addInterceptor in interface IMap<K,V>
    
    Parameters:
    
    interceptor - map interceptor
    
    Returns:
    
    ID of registered interceptor
  - removeInterceptor
```
public void removeInterceptor(String id)
```
    Description copied from interface: IMap
    
    Removes the given interceptor for this map, so it will not intercept operations anymore.
    
    Specified by:
    
    removeInterceptor in interface IMap<K,V>
    
    Parameters:
    
    id - registration ID of the map interceptor
  - addEntryListener
```
public String addEntryListener(MapListener listener,
                               boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds a MapListener for this map.
    To receive an event, you should implement a corresponding MapListener sub-interface for that event.
    
    Specified by:
    
    addEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - MapListener for this map
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
    
    See Also:
    
    MapListener
  - addEntryListener
```
public String addEntryListener(EntryListener listener,
                               boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds an entry listener for this map.
    The listener will get notified for all map add/remove/update/evict events.
    
    Specified by:
    
    addEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - the added entry listener for this map
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
  - removeEntryListener
```
public boolean removeEntryListener(String registrationId)
```
    Description copied from interface: IMap
    
    Removes the specified entry listener.
    Returns silently if there is no such listener added before.
    
    Specified by:
    
    removeEntryListener in interface IMap<K,V>
    
    Parameters:
    
    registrationId - ID of registered listener
    
    Returns:
    
    true if registration is removed, false otherwise
  - addPartitionLostListener
```
public String addPartitionLostListener(MapPartitionLostListener listener)
```
    Description copied from interface: IMap
    
    Adds a MapPartitionLostListener.
    The addPartitionLostListener returns a register ID. This ID is needed to remove the MapPartitionLostListener using the IMap.removePartitionLostListener(String) method.
    There is no check for duplicate registrations, so if you register the listener twice, it will get events twice.
    Warning 1:
    Please see PartitionLostListener for weaknesses.
    Warning 2:
    Listeners registered from HazelcastClient may miss some of the map partition lost events due to design limitations.
    
    Specified by:
    
    addPartitionLostListener in interface IMap<K,V>
    
    Parameters:
    
    listener - the added MapPartitionLostListener
    
    Returns:
    
    returns the registration ID for the MapPartitionLostListener
    
    See Also:
    
    IMap.removePartitionLostListener(String), PartitionLostListener
  - removePartitionLostListener
```
public boolean removePartitionLostListener(String registrationId)
```
    Description copied from interface: IMap
    
    Removes the specified map partition lost listener.
    Returns silently if there is no such listener was added before.
    
    Specified by:
    
    removePartitionLostListener in interface IMap<K,V>
    
    Parameters:
    
    registrationId - ID of registered listener
    
    Returns:
    
    true if registration is removed, false otherwise
  - addEntryListener
```
public String addEntryListener(MapListener listener,
                               K key,
                               boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds a MapListener for this map. To receive an event, you should implement a corresponding MapListener sub-interface for that event.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Specified by:
    
    addEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - MapListener for this map
    
    key - key to listen for
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
    
    See Also:
    
    MapListener
  - addEntryListener
```
public String addEntryListener(EntryListener listener,
                               K key,
                               boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds the specified entry listener for the specified key.
    The listener will get notified for all add/remove/update/evict events of the specified key only.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Specified by:
    
    addEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - specified entry listener
    
    key - key to listen for
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
  - addEntryListener
```
public String addEntryListener(MapListener listener,
                               Predicate<K,V> predicate,
                               K key,
                               boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds a MapListener for this map.
    To receive an event, you should implement a corresponding MapListener sub-interface for that event.
    
    Specified by:
    
    addEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - the continuous MapListener for this map
    
    predicate - predicate for filtering entries
    
    key - key to listen for
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
    
    See Also:
    
    MapListener
  - addEntryListener
```
public String addEntryListener(EntryListener listener,
                               Predicate<K,V> predicate,
                               K key,
                               boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds an continuous entry listener for this map.
    The listener will get notified for map add/remove/update/evict events filtered by the given predicate.
    
    Specified by:
    
    addEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - the continuous entry listener for this map
    
    predicate - predicate for filtering entries
    
    key - key to listen for
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
  - addEntryListener
```
public String addEntryListener(MapListener listener,
                               Predicate<K,V> predicate,
                               boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds a MapListener for this map.
    To receive an event, you should implement a corresponding MapListener sub-interface for that event.
    
    Specified by:
    
    addEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - the added continuous MapListener for this map
    
    predicate - predicate for filtering entries
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
    
    See Also:
    
    MapListener
  - addEntryListener
```
public String addEntryListener(EntryListener listener,
                               Predicate<K,V> predicate,
                               boolean includeValue)
```
    Description copied from interface: IMap
    
    Adds an continuous entry listener for this map.
    The listener will get notified for map add/remove/update/evict events filtered by the given predicate.
    
    Specified by:
    
    addEntryListener in interface IMap<K,V>
    
    Parameters:
    
    listener - the added continuous entry listener for this map
    
    predicate - predicate for filtering entries
    
    includeValue - true if EntryEvent should contain the value
    
    Returns:
    
    a UUID.randomUUID().toString() which is used as a key to remove the listener
  - getEntryView
```
public EntryView<K,V> getEntryView(K key)
```
    Description copied from interface: IMap
    
    Returns the EntryView for the specified key.
    Warning 1:
    This method returns a clone of original mapping, modifying the returned value does not change the actual value in the map. One should put modified value back to make changes visible to all nodes.
    Warning 2:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Specified by:
    
    getEntryView in interface IMap<K,V>
    
    Parameters:
    
    key - the key of the entry
    
    Returns:
    
    EntryView of the specified key
    
    See Also:
    
    EntryView
  - evict
```
public boolean evict(K key)
```
    Description copied from interface: IMap
    
    Evicts the specified key from this map.
    If a MapStore is defined for this map, then the entry is not deleted from the underlying MapStore, evict only removes the entry from the memory. Use IMap.delete(Object) or IMap.remove(Object) if MapStore.delete(Object) needs to be called.
    Warning:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    
    Specified by:
    
    evict in interface IMap<K,V>
    
    Parameters:
    
    key - the specified key to evict from this map
    
    Returns:
    
    true if the key is evicted, false otherwise
    
    See Also:
    
    IMap.delete(Object), IMap.remove(Object)
  - evictInternal
```
protected boolean evictInternal(Object key)
```
  - evictAll
```
public void evictAll()
```
    Description copied from interface: IMap
    
    Evicts all keys from this map except the locked ones.
    If a MapStore is defined for this map, deleteAll is not called by this method. If you do want to MapStore.deleteAll(Collection) to be called use the IMap.clear() method.
    The EVICT_ALL event is fired for any registered listeners. See MapEvictedListener.mapEvicted(MapEvent) .
    
    Specified by:
    
    evictAll in interface IMap<K,V>
    
    See Also:
    
    IMap.clear()
  - loadAll
```
public void loadAll(boolean replaceExistingValues)
```
    Description copied from interface: IMap
    
    Loads all keys into the store. This is a batch load operation so that an implementation can optimize multiple loads.
    Interactions with the map store
    Calls MapLoader.loadAllKeys() and with the loaded keys calls MapLoader.loadAll(java.util.Collection) on each partition. Exceptions thrown by loadAllKeys() or loadAll() are not propagated to the caller.
    
    Specified by:
    
    loadAll in interface IMap<K,V>
    
    Parameters:
    
    replaceExistingValues - when true, existing values in the Map will be replaced by those loaded from the MapLoader IMap.loadAll(boolean)
  - loadAll
```
public void loadAll(Set<K> keys,
                    boolean replaceExistingValues)
```
    Description copied from interface: IMap
    
    Loads the given keys. This is a batch load operation so that an implementation can optimize multiple loads.
    Interactions with the map store
    Calls MapLoader.loadAll(java.util.Collection) on the partitions storing the values with the keys. Exceptions thrown by loadAll() are not propagated to the caller.
    
    Specified by:
    
    loadAll in interface IMap<K,V>
    
    Parameters:
    
    keys - keys of the values entries to load (keys inside the collection cannot be null)
    
    replaceExistingValues - when true, existing values in the Map will be replaced by those loaded from the MapLoader
  - loadAllInternal
```
protected void loadAllInternal(boolean replaceExistingValues,
                               Collection<?> keys)
```
  - keySet
```
public Set<K> keySet()
```
    Description copied from interface: IMap
    
    Returns a set clone of the keys contained in this map.
    Warning:
    The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
    This method is always executed by a distributed query, so it may throw a QueryResultSizeExceededException if GroupProperty.QUERY_RESULT_SIZE_LIMIT is configured.
    
    Specified by:
    
    keySet in interface BaseMap<K,V>
    
    Specified by:
    
    keySet in interface IMap<K,V>
    
    Specified by:
    
    keySet in interface Map<K,V>
    
    Returns:
    
    a set clone of the keys contained in this map
    
    See Also:
    
    GroupProperty.QUERY_RESULT_SIZE_LIMIT
  - getAll
```
public Map<K,V> getAll(Set<K> keys)
```
    Description copied from interface: IMap
    
    Returns the entries for the given keys.
    Warning 1:
    The returned map is NOT backed by the original map, so changes to the original map are NOT reflected in the returned map, and vice-versa.
    Warning 2:
    This method uses hashCode and equals of the binary form of the keys, not the actual implementations of hashCode and equals defined in the key's class.
    Interactions with the map store
    If any keys are not found in memory, MapLoader.loadAll(java.util.Collection) is called with the missing keys. Exceptions thrown by loadAll fail the operation and are propagated to the caller.
    
    Specified by:
    
    getAll in interface IMap<K,V>
    
    Parameters:
    
    keys - keys to get (keys inside the collection cannot be null)
    
    Returns:
    
    map of entries
  - getAllInternal
```
protected void getAllInternal(Set<K> keys,
                              Map<Integer,List<Data>> partitionToKeyData,
                              List<Object> resultingKeyValuePairs)
```
  - fillPartitionToKeyData
```
protected void fillPartitionToKeyData(Set<K> keys,
                                      Map<Integer,List<Data>> partitionToKeyData,
                                      Map<Object,Data> keyMap,
                                      Map<Data,Object> reverseKeyMap)
```
  - values
```
public Collection<V> values()
```
    Description copied from interface: IMap
    
    Returns a collection clone of the values contained in this map.
    Warning:
    The collection is NOT backed by the map, so changes to the map are NOT reflected in the collection, and vice-versa.
    This method is always executed by a distributed query, so it may throw a QueryResultSizeExceededException if GroupProperty.QUERY_RESULT_SIZE_LIMIT is configured.
    
    Specified by:
    
    values in interface BaseMap<K,V>
    
    Specified by:
    
    values in interface IMap<K,V>
    
    Specified by:
    
    values in interface Map<K,V>
    
    Returns:
    
    a collection clone of the values contained in this map
    
    See Also:
    
    GroupProperty.QUERY_RESULT_SIZE_LIMIT
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Description copied from interface: IMap
    
    Returns a Set clone of the mappings contained in this map.
    Warning:
    The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
    This method is always executed by a distributed query, so it may throw a QueryResultSizeExceededException if GroupProperty.QUERY_RESULT_SIZE_LIMIT is configured.
    
    Specified by:
    
    entrySet in interface IMap<K,V>
    
    Specified by:
    
    entrySet in interface Map<K,V>
    
    Returns:
    
    a set clone of the keys mappings in this map
    
    See Also:
    
    GroupProperty.QUERY_RESULT_SIZE_LIMIT
  - keySet
```
public Set<K> keySet(Predicate predicate)
```
    Description copied from interface: IMap
    
    Queries the map based on the specified predicate and returns the keys of matching entries.
    Specified predicate runs on all members in parallel.
    Warning:
    The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
    This method is always executed by a distributed query, so it may throw a QueryResultSizeExceededException if GroupProperty.QUERY_RESULT_SIZE_LIMIT is configured.
    
    Specified by:
    
    keySet in interface BaseMap<K,V>
    
    Specified by:
    
    keySet in interface IMap<K,V>
    
    Parameters:
    
    predicate - specified query criteria
    
    Returns:
    
    result key set of the query
    
    See Also:
    
    GroupProperty.QUERY_RESULT_SIZE_LIMIT
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet(Predicate predicate)
```
    Description copied from interface: IMap
    
    Queries the map based on the specified predicate and returns the matching entries.
    Specified predicate runs on all members in parallel.
    Warning:
    The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
    This method is always executed by a distributed query, so it may throw a QueryResultSizeExceededException if GroupProperty.QUERY_RESULT_SIZE_LIMIT is configured.
    
    Specified by:
    
    entrySet in interface IMap<K,V>
    
    Parameters:
    
    predicate - specified query criteria
    
    Returns:
    
    result entry set of the query
    
    See Also:
    
    GroupProperty.QUERY_RESULT_SIZE_LIMIT
  - values
```
public Collection<V> values(Predicate predicate)
```
    Description copied from interface: IMap
    
    Queries the map based on the specified predicate and returns the values of matching entries.
    Specified predicate runs on all members in parallel.
    Warning:
    The collection is NOT backed by the map, so changes to the map are NOT reflected in the collection, and vice-versa.
    This method is always executed by a distributed query, so it may throw a QueryResultSizeExceededException if GroupProperty.QUERY_RESULT_SIZE_LIMIT is configured.
    
    Specified by:
    
    values in interface BaseMap<K,V>
    
    Specified by:
    
    values in interface IMap<K,V>
    
    Parameters:
    
    predicate - specified query criteria
    
    Returns:
    
    result value collection of the query
    
    See Also:
    
    GroupProperty.QUERY_RESULT_SIZE_LIMIT
  - localKeySet
```
public Set<K> localKeySet()
```
    Description copied from interface: IMap
    
    Returns the locally owned set of keys.
    Each key in this map is owned and managed by a specific member in the cluster.
    Note that ownership of these keys might change over time so that key ownerships can be almost evenly distributed in the cluster.
    Warning:
    The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
    This method is always executed by a distributed query, so it may throw a QueryResultSizeExceededException if GroupProperty.QUERY_RESULT_SIZE_LIMIT is configured.
    
    Specified by:
    
    localKeySet in interface IMap<K,V>
    
    Returns:
    
    locally owned keys
    
    See Also:
    
    GroupProperty.QUERY_RESULT_SIZE_LIMIT
  - localKeySet
```
public Set<K> localKeySet(Predicate predicate)
```
    Description copied from interface: IMap
    
    Returns the keys of matching locally owned entries.
    Each key in this map is owned and managed by a specific member in the cluster.
    Note that ownership of these keys might change over time so that key ownerships can be almost evenly distributed in the cluster.
    Warning:
    The set is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.
    This method is always executed by a distributed query, so it may throw a QueryResultSizeExceededException if GroupProperty.QUERY_RESULT_SIZE_LIMIT is configured.
    
    Specified by:
    
    localKeySet in interface IMap<K,V>
    
    Parameters:
    
    predicate - specified query criteria
    
    Returns:
    
    keys of matching locally owned entries
    
    See Also:
    
    GroupProperty.QUERY_RESULT_SIZE_LIMIT
  - addIndex
```
public void addIndex(String attribute,
                     boolean ordered)
```
    Description copied from interface: IMap
    Adds an index to this map for the specified entries so that queries can run faster.
    Let's say your map values are Employee objects.
```
   public class Employee implements Serializable {
     private boolean active = false;
     private int age;
     private String name = null;
     // other fields

     // getters setter
   }
 
```
    If you are querying your values mostly based on age and active then you should consider indexing these fields.
```
   IMap imap = Hazelcast.getMap("employees");
   imap.addIndex("age", true);        // ordered, since we have ranged queries for this field
   imap.addIndex("active", false);    // not ordered, because boolean field cannot have range
 
```
    Index attribute should either have a getter method or be public. You should also make sure to add the indexes before adding entries to this map.
    Time to Index
    Indexing time is executed in parallel on each partition by operation threads. The Map is not blocked during this operation.
    The time taken in proportional to the size of the Map and the number Members.
    Searches while indexes are being built
    Until the index finishes being created, any searches for the attribute will use a full Map scan, thus avoiding using a partially built index and returning incorrect results.
    Specified by:
    
    addIndex in interface IMap<K,V>
    
    Parameters:
    
    attribute - index attribute of value
    
    ordered - true if index should be ordered, false otherwise.
  - getLocalMapStats
```
public LocalMapStats getLocalMapStats()
```
    Description copied from interface: IMap
    
    Returns LocalMapStats for this map.
    LocalMapStats are the statistics for the local portion of this distributed map and contains information such as ownedEntryCount backupEntryCount, lastUpdateTime, lockedEntryCount.
    Since this stats are only for the local portion of this map, if you need the cluster-wide MapStats then you need to get the LocalMapStats from all members of the cluster and combine them.
    It's guaranteed that the returned LocalMapStats instance contains an up-to-date statistics. But over the time some parts of the returned instance may become stale while others may be updated. To obtain a fresh up-to-date instance invoke the method one more time.
    
    Specified by:
    
    getLocalMapStats in interface IMap<K,V>
    
    Returns:
    
    this map's local statistics
  - setTtl
```
public boolean setTtl(K key,
                      long ttl,
                      TimeUnit timeunit)
```
    Description copied from interface: IMap
    
    Updates TTL (time to live) value of the entry specified by key with a new TTL value. New TTL value is valid starting from the time this operation is invoked, not since the time the entry was created. If the entry does not exist or is already expired, this call has no effect.
    The entry will expire and get evicted after the TTL. If the TTL is 0, then the entry lives forever. If the TTL is negative, then the TTL from the map configuration will be used (default: forever). If there is no entry with key key or is already expired, this call makes no changes to entries stored in this map. Warning:
    Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.
    
    Specified by:
    
    setTtl in interface IMap<K,V>
    
    Parameters:
    
    key - the key of the map entry
    
    ttl - maximum time for this entry to stay in the map (0 means infinite, negative means map config default)
    
    timeunit - time unit for the TTL
    
    Returns:
    
    true if the entry exists and its ttl value is changed, false otherwise
  - setTtlInternal
```
protected boolean setTtlInternal(Object key,
                                 long ttl,
                                 TimeUnit timeUnit)
```
  - executeOnKey
```
public Object executeOnKey(K key,
                           EntryProcessor entryProcessor)
```
    Description copied from interface: IMap
    Applies the user defined EntryProcessor to the entry mapped by the key. Returns the object which is the result of the EntryProcessor#process(Entry) method.
    The EntryProcessor may implement the Offloadable and ReadOnly interfaces.
    If the EntryProcessor implements the Offloadable interface, the processing will be offloaded to the given ExecutorService, allowing unblocking of the partition-thread, which means that other partition-operations may proceed. The key will be locked for the time-span of the processing in order to not generate a write-conflict. In this case the threading looks as follows:
    1. partition-thread (fetch & lock)
    2. execution-thread (process)
    3. partition-thread (set & unlock, or just unlock if no changes)
    If the EntryProcessor implements the Offloadable and ReadOnly interfaces, the processing will be offloaded to the given ExecutorService allowing unblocking the partition-thread. Since the EntryProcessor is not supposed to do any changes to the Entry, the key will NOT be locked for the time-span of the processing. In this case the threading looks as follows:
    1. partition-thread (fetch)
    2. execution-thread (process)
    In this case, the EntryProcessor.getBackupProcessor() has to return null; otherwise an IllegalArgumentException exception is thrown.
    If the EntryProcessor implements only ReadOnly without implementing Offloadable, the processing unit will not be offloaded, however, the EntryProcessor will not wait for the lock to be acquired, since the EP will not do any modifications.
    Using offloading is useful if the EntryProcessor encompasses heavy logic that may stall the partition-thread.
    If the EntryProcessor implements ReadOnly and modifies the entry it is processing, an UnsupportedOperationException will be thrown.
    Offloading will not be applied to backup partitions. It is possible to initialize the EntryBackupProcessor with some input provided by the EntryProcessor in the EntryProcessor.getBackupProcessor() method. The input allows providing context to the EntryBackupProcessor, for example the "delta", so that the EntryBackupProcessor does not have to calculate the "delta" but it may just apply it.
    See IMap.submitToKey(Object, EntryProcessor) for an async version of this method.
    Interactions with the map store
    If value with key is not found in memory, MapLoader.load(Object) is invoked to load the value from the map store backing the map.
    If the entryProcessor updates the entry and write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store.
    If the entryProcessor updates the entry's value to null value and write-through persistence mode is configured, before the value is removed from the memory, MapStore.delete(Object) is called to delete the value from the map store.
    Any exceptions thrown by the map store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    executeOnKey in interface IMap<K,V>
    
    Returns:
    
    result of EntryProcessor#process(Entry)
    
    See Also:
    
    Offloadable, ReadOnly
  - executeOnKeyInternal
```
public Object executeOnKeyInternal(Object key,
                                   EntryProcessor entryProcessor)
```
  - submitToKey
```
public void submitToKey(K key,
                        EntryProcessor entryProcessor,
                        ExecutionCallback callback)
```
    Description copied from interface: IMap
    Applies the user defined EntryProcessor to the entry mapped by the key with specified ExecutionCallback to listen event status and returns immediately.
    The EntryProcessor may implement the Offloadable and ReadOnly interfaces.
    If the EntryProcessor implements the Offloadable interface the processing will be offloaded to the given ExecutorService allowing unblocking of the partition-thread, which means that other partition-operations may proceed. The key will be locked for the time-span of the processing in order to not generate a write-conflict. In this case the threading looks as follows:
    1. partition-thread (fetch & lock)
    2. execution-thread (process)
    3. partition-thread (set & unlock, or just unlock if no changes)
    If the EntryProcessor implements the Offloadable and ReadOnly interfaces the processing will be offloaded to the given ExecutorService allowing unblocking the partition-thread. Since the EntryProcessor is not supposed to do any changes to the Entry the key will NOT be locked for the time-span of the processing. In this case the threading looks as follows:
    1. partition-thread (fetch & lock)
    2. execution-thread (process)
    In this case the EntryProcessor.getBackupProcessor() has to return null; otherwise an IllegalArgumentException exception is thrown.
    If the EntryProcessor implements only ReadOnly without implementing Offloadable the processing unit will not be offloaded, however, the EntryProcessor will not wait for the lock to be acquired, since the EP will not do any modifications.
    If the EntryProcessor implements ReadOnly and modifies the entry it is processing an UnsupportedOperationException will be thrown.
    Using offloading is useful if the EntryProcessor encompasses heavy logic that may stall the partition-thread.
    Offloading will not be applied to backup partitions. It is possible to initialize the EntryBackupProcessor with some input provided by the EntryProcessor in the EntryProcessor.getBackupProcessor() method. The input allows providing context to the EntryBackupProcessor - for example the "delta" so that the EntryBackupProcessor does not have to calculate the "delta" but it may just apply it.
    See IMap.executeOnKey(Object, EntryProcessor) for sync version of this method.
    Interactions with the map store
    If value with key is not found in memory MapLoader.load(Object) is invoked to load the value from the map store backing the map.
    If the entryProcessor updates the entry and write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store.
    If the entryProcessor updates the entry's value to null value and write-through persistence mode is configured, before the value is removed from the memory, MapStore.delete(Object) is called to delete the value from the map store.
    Any exception thrown by the map store fail the operation and are propagated to the provided callback via ExecutionCallback.onFailure(Throwable).
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    submitToKey in interface IMap<K,V>
    
    Parameters:
    
    key - key to be processed
    
    entryProcessor - processor to process the key
    
    callback - to listen whether operation is finished or not
    
    See Also:
    
    Offloadable, ReadOnly
  - submitToKeyInternal
```
public void submitToKeyInternal(Object key,
                                EntryProcessor entryProcessor,
                                ExecutionCallback callback)
```
  - submitToKey
```
public ICompletableFuture submitToKey(K key,
                                      EntryProcessor entryProcessor)
```
    Description copied from interface: IMap
    Applies the user defined EntryProcessor to the entry mapped by the key. Returns immediately with a ICompletableFuture representing that task.
    EntryProcessor is not cancellable, so calling ICompletableFuture.cancel() method won't cancel the operation of EntryProcessor.
    The EntryProcessor may implement the Offloadable and ReadOnly interfaces.
    If the EntryProcessor implements the Offloadable interface the processing will be offloaded to the given ExecutorService allowing unblocking the partition-thread, which means that other partition-operations may proceed. The key will be locked for the time-span of the processing in order to not generate a write-conflict. In this case the threading looks as follows:
    1. partition-thread (fetch & lock)
    2. execution-thread (process)
    3. partition-thread (set & unlock, or just unlock if no changes)
    If the EntryProcessor implements the Offloadable and ReadOnly interfaces the processing will be offloaded to the given ExecutorService allowing unblocking the partition-thread. Since the EntryProcessor is not supposed to do any changes to the Entry the key will NOT be locked for the time-span of the processing. In this case the threading looks as follows:
    1. partition-thread (fetch & lock)
    2. execution-thread (process)
    In this case the EntryProcessor.getBackupProcessor() has to return null; otherwise an IllegalArgumentException exception is thrown.
    If the EntryProcessor implements only ReadOnly without implementing Offloadable the processing unit will not be offloaded, however, the EntryProcessor will not wait for the lock to be acquired, since the EP will not do any modifications.
    If the EntryProcessor implements ReadOnly and modifies the entry it is processing a UnsupportedOperationException will be thrown.
    Using offloading is useful if the EntryProcessor encompasses heavy logic that may stall the partition-thread.
    Offloading will not be applied to backup partitions. It is possible to initialize the EntryBackupProcessor with some input provided by the EntryProcessor in the EntryProcessor.getBackupProcessor() method. The input allows providing context to the EntryBackupProcessor - for example the "delta" so that the EntryBackupProcessor does not have to calculate the "delta" but it may just apply it.
    See IMap.executeOnKey(Object, EntryProcessor) for sync version of this method.
    Interactions with the map store
    If value with key is not found in memory MapLoader.load(Object) is invoked to load the value from the map store backing the map.
    If the entryProcessor updates the entry and write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store.
    If the entryProcessor updates the entry's value to null value and write-through persistence mode is configured, before the value is removed from the memory, MapStore.delete(Object) is called to delete the value from the map store.
    Any exception thrown by the map store fail the operation and are propagated to the provided callback via ExecutionCallback.onFailure(Throwable).
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Specified by:
    
    submitToKey in interface IMap<K,V>
    
    Specified by:
    
    submitToKey in interface LegacyAsyncMap<K,V>
    
    Parameters:
    
    key - key to be processed
    
    entryProcessor - processor to process the key
    
    Returns:
    
    ICompletableFuture from which the result of the operation can be retrieved
    
    See Also:
    
    Offloadable, ReadOnly, ICompletableFuture
  - submitToKeyInternal
```
public ICompletableFuture submitToKeyInternal(Object key,
                                              EntryProcessor entryProcessor)
```
  - executeOnEntries
```
public Map<K,Object> executeOnEntries(EntryProcessor entryProcessor)
```
    Description copied from interface: IMap
    
    Applies the user defined EntryProcessor to the all entries in the map. Returns the results mapped by each key in the map.
    The operation is not lock-aware. The EntryProcessor will process the entries no matter if the keys are locked or not. For more details check Entry Processing section on IMap documentation.
    Interactions with the map store
    For each entry not found in memory MapLoader.load(Object) is invoked to load the value from the map store backing the map.
    If write-through persistence mode is configured, for each entry updated by the entryProcessor, before the updated value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store.
    If write-through persistence mode is configured, for each entry updated to null value, before the value is removed from the memory, MapStore.delete(Object) is called to delete the value from the map store.
    Any exceptions thrown by the map store fail the operation and are propagated to the caller. If an exception happened, the operation might already succeeded on some of the keys.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    executeOnEntries in interface IMap<K,V>
  - prepareResult
```
protected Map<K,Object> prepareResult(Collection<Map.Entry<Data,Data>> entries)
```
  - executeOnEntries
```
public Map<K,Object> executeOnEntries(EntryProcessor entryProcessor,
                                      Predicate predicate)
```
    Description copied from interface: IMap
    
    Applies the user defined EntryProcessor to the entries in the map which satisfy provided predicate. Returns the results mapped by each key in the map.
    The operation is not lock-aware. The EntryProcessor will process the entries no matter if the keys are locked or not. For more details check Entry Processing section on IMap documentation.
    Interactions with the map store
    For each entry not found in memory MapLoader.load(Object) is invoked to load the value from the map store backing the map.
    If write-through persistence mode is configured, for each entry updated by the entryProcessor, before the updated value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store.
    If write-through persistence mode is configured, for each entry updated to null value, before the value is removed from the memory, MapStore.delete(Object) is called to delete the value from the map store.
    Any exceptions thrown by the map store fail the operation and are propagated to the caller. If an exception happened, the operation might already succeeded on some of the keys.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    executeOnEntries in interface IMap<K,V>
  - aggregate
```
public <R> R aggregate(Aggregator<Map.Entry<K,V>,R> aggregator)
```
    Description copied from interface: IMap
    
    Applies the aggregation logic on all map entries and returns the result
    Fast-Aggregations are the successor of the Map-Reduce Aggregators. They are equivalent to the Map-Reduce Aggregators in most of the use-cases, but instead of running on the Map-Reduce engine they run on the Query infrastructure. Their performance is tens to hundreds times better due to the fact that they run in parallel for each partition and are highly optimized for speed and low memory consumption.
    
    Specified by:
    
    aggregate in interface IMap<K,V>
    
    Type Parameters:
    
    R - type of the result
    
    Parameters:
    
    aggregator - aggregator to aggregate the entries with
    
    Returns:
    
    the result of the given type
  - aggregate
```
public <R> R aggregate(Aggregator<Map.Entry<K,V>,R> aggregator,
                       Predicate<K,V> predicate)
```
    Description copied from interface: IMap
    
    Applies the aggregation logic on map entries filtered with the Predicated and returns the result
    Fast-Aggregations are the successor of the Map-Reduce Aggregators. They are equivalent to the Map-Reduce Aggregators in most of the use-cases, but instead of running on the Map-Reduce engine they run on the Query infrastructure. Their performance is tens to hundreds times better due to the fact that they run in parallel for each partition and are highly optimized for speed and low memory consumption.
    
    Specified by:
    
    aggregate in interface IMap<K,V>
    
    Type Parameters:
    
    R - type of the result
    
    Parameters:
    
    aggregator - aggregator to aggregate the entries with
    
    predicate - predicate to filter the entries with
    
    Returns:
    
    the result of the given type
  - project
```
public <R> Collection<R> project(Projection<Map.Entry<K,V>,R> projection)
```
    Description copied from interface: IMap
    
    Applies the projection logic on all map entries and returns the result
    
    Specified by:
    
    project in interface IMap<K,V>
    
    Type Parameters:
    
    R - type of the result
    
    Parameters:
    
    projection - projection to transform the entries with (may return null)
    
    Returns:
    
    the result of the given type
  - project
```
public <R> Collection<R> project(Projection<Map.Entry<K,V>,R> projection,
                                 Predicate<K,V> predicate)
```
    Description copied from interface: IMap
    
    Applies the projection logic on map entries filtered with the Predicated and returns the result
    
    Specified by:
    
    project in interface IMap<K,V>
    
    Type Parameters:
    
    R - type of the result
    
    Parameters:
    
    projection - projection to transform the entries with (may return null)
    
    predicate - predicate to filter the entries with
    
    Returns:
    
    the result of the given type
  - aggregate
```
public <SuppliedValue,Result> Result aggregate(Supplier<K,V,SuppliedValue> supplier,
                                               Aggregation<K,SuppliedValue,Result> aggregation)
```
    Description copied from interface: IMap
    
    Executes a predefined aggregation on the maps data set. The Supplier is used to either select or to select and extract a (sub-)value. A predefined set of aggregations can be found in Aggregations.
    
    Specified by:
    
    aggregate in interface IMap<K,V>
    
    Type Parameters:
    
    SuppliedValue - the final type emitted from the supplier
    
    Result - the resulting aggregation value type
    
    Parameters:
    
    supplier - the supplier to select and / or extract a (sub-)value from the map
    
    aggregation - the aggregation that is being executed against the map
    
    Returns:
    
    the aggregated value
  - aggregate
```
public <SuppliedValue,Result> Result aggregate(Supplier<K,V,SuppliedValue> supplier,
                                               Aggregation<K,SuppliedValue,Result> aggregation,
                                               JobTracker jobTracker)
```
    Description copied from interface: IMap
    
    Executes a predefined aggregation on the maps data set.
    The Supplier is used to either select or to select and extract a (sub-)value. A predefined set of aggregations can be found in Aggregations.
    
    Specified by:
    
    aggregate in interface IMap<K,V>
    
    Type Parameters:
    
    SuppliedValue - the final type emitted from the supplier
    
    Result - the resulting aggregation value type
    
    Parameters:
    
    supplier - the supplier to select and / or extract a (sub-)value from the map
    
    aggregation - the aggregation that is being executed against the map
    
    jobTracker - the JobTracker instance to execute the aggregation
    
    Returns:
    
    the aggregated value
  - getQueryCache
```
public QueryCache<K,V> getQueryCache(String name)
```
    Description copied from interface: IMap
    
    Returns corresponding QueryCache instance for the supplied name or null.
    If there is a previously created QueryCache with the supplied name or if a declarative configuration exists for the supplied name this method returns or creates the instance respectively, otherwise returns null.
    
    Specified by:
    
    getQueryCache in interface IMap<K,V>
    
    Parameters:
    
    name - the name of QueryCache
    
    Returns:
    
    the QueryCache instance or null if there is no corresponding QueryCacheConfig
    
    See Also:
    
    QueryCache
  - getQueryCache
```
public QueryCache<K,V> getQueryCache(String name,
                                     Predicate<K,V> predicate,
                                     boolean includeValue)
```
    Description copied from interface: IMap
    
    Creates an always up to date snapshot of this IMap according to the supplied parameters.
    If there is a previously created QueryCache with the supplied name, this method returns that QueryCache and ignores predicate and includeValue parameters. Otherwise it creates and returns a new QueryCache instance.
    Also note that if there exists a QueryCacheConfig for the supplied name, predicate and includeValue parameters will overwrite corresponding ones in QueryCacheConfig.
    
    Specified by:
    
    getQueryCache in interface IMap<K,V>
    
    Parameters:
    
    name - the name of QueryCache
    
    predicate - the predicate for filtering entries
    
    includeValue - true if this QueryCache is allowed to cache values of entries, otherwise false
    
    Returns:
    
    the QueryCache instance with the supplied name
    
    See Also:
    
    QueryCache
  - getQueryCache
```
public QueryCache<K,V> getQueryCache(String name,
                                     MapListener listener,
                                     Predicate<K,V> predicate,
                                     boolean includeValue)
```
    Description copied from interface: IMap
    
    Creates an always up to date snapshot of this IMap according to the supplied parameters.
    If there is a previously created QueryCache with the supplied name, this method returns that QueryCache and ignores listener, predicate and includeValue parameters. Otherwise it creates and returns a new QueryCache instance.
    Also note that if there exists a QueryCacheConfig for the supplied name, listener,predicate and includeValue parameters will overwrite corresponding ones in QueryCacheConfig.
    
    Specified by:
    
    getQueryCache in interface IMap<K,V>
    
    Parameters:
    
    name - the name of QueryCache
    
    listener - the MapListener which will be used to listen this QueryCache
    
    predicate - the predicate for filtering entries
    
    includeValue - true if this QueryCache is allowed to cache values of entries, otherwise false
    
    Returns:
    
    the QueryCache instance with the supplied name
    
    See Also:
    
    QueryCache
  - executeOnKeys
```
public Map<K,Object> executeOnKeys(Set<K> keys,
                                   EntryProcessor entryProcessor)
```
    Description copied from interface: IMap
    Applies the user defined EntryProcessor to the entries mapped by the collection of keys.
    The operation is not lock-aware. The EntryProcessor will process the entries no matter if the keys are locked or not. For more details check Entry Processing section on IMap documentation.
    Interactions with the map store
    For each entry not found in memory MapLoader.load(Object) is invoked to load the value from the map store backing the map.
    If write-through persistence mode is configured, for each entry updated by the entryProcessor, before the updated value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store.
    If write-through persistence mode is configured, for each entry updated to null value, before the value is removed from the memory, MapStore.delete(Object) is called to delete the value from the map store.
    Any exceptions thrown by the map store fail the operation and are propagated to the caller. If an exception happened, the operation might already succeeded on some of the keys.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    Performance note
    
    Keep the state of entryProcessor small, it will be serialized and one copy will be sent to each member. Additionally, the backup processor will also be serialized once for each affected partition and sent to each backup. For example, in this usage the entire additions map will be duplicated once for each member and once for each partition and backup:
```
   HashMap additions = ...;
   iMap.executeOnKeys(map.keySet(), new AbstractEntryProcessor<Integer, Integer>() {
             public Object process(Entry<Integer, Integer> entry) {
                 Integer updateBy = additions.get(entry.getKey());
                 entry.setValue(entry.getValue() + updateBy);
                 return null;
             }
         });
 
```
    Specified by:
    
    executeOnKeys in interface IMap<K,V>
    
    Parameters:
    
    keys - The keys to execute the entry processor on. Can be empty, in that case it's a local no-op
    
    Returns:
    
    results of EntryProcessor#process(Entry)
  - submitToKeys
```
public ICompletableFuture<Map<K,Object>> submitToKeys(Set<K> keys,
                                                      EntryProcessor entryProcessor)
```
    Async version of executeOnKeys(java.util.Set<K>, com.hazelcast.map.EntryProcessor).
  - set
```
public void set(K key,
                V value)
```
    Description copied from interface: IMap
    
    Puts an entry into this map without returning the old value (which is more efficient than put()).
    Warning 1:
    This method breaks the contract of EntryListener. When an entry is updated by set(), it fires an EntryEvent with a null oldValue.
    Warning 2:
    This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode and equals defined in the key's class.
    Interactions with the map store
    If write-through persistence mode is configured, before the value is stored in memory, MapStore.store(Object, Object) is called to write the value into the map store. Exceptions thrown by the store fail the operation and are propagated to the caller.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    set in interface BaseMap<K,V>
    
    Specified by:
    
    set in interface IMap<K,V>
    
    Parameters:
    
    key - key of the entry
    
    value - value of the entry
  - size
```
public int size()
```
    Description copied from interface: BaseMap
    
    Returns the number of entries in this map.
    
    Specified by:
    
    size in interface BaseMap<K,V>
    
    Specified by:
    
    size in interface Map<K,V>
    
    Returns:
    
    the number of entries in this map.
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: BaseMap
    
    Returns true if this map contains no entries.
    
    Specified by:
    
    isEmpty in interface BaseMap<K,V>
    
    Specified by:
    
    isEmpty in interface Map<K,V>
    
    Returns:
    
    true if this map contains no entries.
  - putAll
```
public void putAll(Map<? extends K,? extends V> map)
```
    Description copied from interface: IMap
    
    No atomicity guarantees are given. It could be that in case of failure some of the key/value-pairs get written, while others are not.
    Interactions with the map store
    For each element not found in memory MapLoader.load(Object) is invoked to load the value from the map store backing the map, which may come at a significant performance cost. Exceptions thrown by load fail the operation and are propagated to the caller. The elements which were added before the exception was thrown will remain in the map, the rest will not be added.
    If write-through persistence mode is configured, MapStore.store(Object, Object) is invoked for each element before the element is added in memory, which may come at a significant performance cost. Exceptions thrown by store fail the operation and are propagated to the caller. The elements which were added before the exception was thrown will remain in the map, the rest will not be added.
    If write-behind persistence mode is configured with write-coalescing turned off, ReachedMaxSizeException may be thrown if the write-behind queue has reached its per-node maximum capacity.
    
    Specified by:
    
    putAll in interface IMap<K,V>
    
    Specified by:
    
    putAll in interface Map<K,V>
  - putAllInternal
```
protected void putAllInternal(Map<? extends K,? extends V> map,
                              Map<Integer,List<Map.Entry<Data,Data>>> entryMap)
```
  - clear
```
public void clear()
```
    Description copied from interface: IMap
    
    Clears the map and deletes the items from the backing map store.
    The MAP_CLEARED event is fired for any registered listeners. See MapClearedListener.mapCleared(MapEvent).
    To clear the map without removing the items from the map store, use IMap.evictAll().
    Interactions with the map store
    Calls MapStore.deleteAll(Collection) on each partition with the keys that the given partition stores. Exceptions thrown by deleteAll() are not propagated to the caller.
    
    Specified by:
    
    clear in interface IMap<K,V>
    
    Specified by:
    
    clear in interface Map<K,V>
    
    See Also:
    
    IMap.evictAll()
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - iterator
```
public Iterator<Map.Entry<K,V>> iterator(int fetchSize,
                                         int partitionId,
                                         boolean prefetchValues)
```
    Returns an iterator for iterating entries in the partitionId. If prefetchValues is true, all values will be sent along with the keys and no additional data will be fetched when iterating. If false, the values will be fetched when iterating the entries.
    The values are not fetched one-by-one but rather in batches. You may control the size of the batch by changing the fetchSize parameter. A too small fetchSize can affect performance since more data will have to be sent to and from the partition owner. A too high fetchSize means that more data will be sent which can block other operations from being sent, including internal operations. The underlying implementation may send more values in one batch than fetchSize if it needs to get to a "safepoint" to later resume iteration.
    NOTE Iterating the map should be done only when the IMap is not being mutated and the cluster is stable (there are no migrations or membership changes). In other cases, the iterator may not return some entries or may return an entry twice.
    
    Parameters:
    
    fetchSize - the size of the batches which will be sent when iterating the data
    
    partitionId - the partition ID which is being iterated
    
    Returns:
    
    the iterator for the projected entries
  - iterator
```
public <R> Iterator<R> iterator(int fetchSize,
                                int partitionId,
                                Projection<Map.Entry<K,V>,R> projection,
                                Predicate<K,V> predicate)
```
    Returns an iterator for iterating the result of the projection on entries in the partitionId which satisfy the predicate. The Iterator.remove() method is not supported and will throw an UnsupportedOperationException.
    The values are not fetched one-by-one but rather in batches. You may control the size of the batch by changing the fetchSize parameter. A too small fetchSize can affect performance since more data will have to be sent to and from the partition owner. A too high fetchSize means that more data will be sent which can block other operations from being sent, including internal operations. The underlying implementation may send more values in one batch than fetchSize if it needs to get to a "safepoint" to later resume iteration. Predicates of type PagingPredicate are not supported.
    NOTE Iterating the map should be done only when the IMap is not being mutated and the cluster is stable (there are no migrations or membership changes). In other cases, the iterator may not return some entries or may return an entry twice.
    
    Type Parameters:
    
    R - the return type
    
    Parameters:
    
    fetchSize - the size of the batches which will be sent when iterating the data
    
    partitionId - the partition ID which is being iterated
    
    projection - the projection to apply before returning the value. null value is not allowed
    
    predicate - the predicate which the entries must match. null value is not allowed
    
    Returns:
    
    the iterator for the projected entries
    
    Throws:
    
    UnsupportedOperationException - if Iterator.remove() is invoked
    
    IllegalArgumentException - if the predicate is of type PagingPredicate
    
    Since:
    
    3.9
  - subscribeToEventJournal
```
public ICompletableFuture<EventJournalInitialSubscriberState> subscribeToEventJournal(int partitionId)
```
    Description copied from interface: EventJournalReader
    
    Subscribe to the event journal for this reader and a specific partition ID. The method will return the newest and oldest event journal sequence.
    
    Specified by:
    
    subscribeToEventJournal in interface EventJournalReader<EventJournalMapEvent<K,V>>
    
    Parameters:
    
    partitionId - the partition ID of the entries to which we are subscribing
    
    Returns:
    
    future with the initial subscriber state containing the newest and oldest event journal sequence
  - readFromEventJournal
```
public <T> ICompletableFuture<ReadResultSet<T>> readFromEventJournal(long startSequence,
                                                                     int minSize,
                                                                     int maxSize,
                                                                     int partitionId,
                                                                     Predicate<? super EventJournalMapEvent<K,V>> predicate,
                                                                     Projection<? super EventJournalMapEvent<K,V>,? extends T> projection)
```
    Description copied from interface: EventJournalReader
    
    Reads from the event journal. The returned future may throw UnsupportedOperationException if the cluster version is lower than 3.9 or there is no event journal configured for this data structure.
    NOTE: Configuring evictions may cause unexpected results when reading from the event journal and there are cluster changes (a backup replica is promoted into a partition owner). See MapEventJournal or CacheEventJournal for more details.
    
    Specified by:
    
    readFromEventJournal in interface EventJournalReader<EventJournalMapEvent<K,V>>
    
    Type Parameters:
    
    T - the return type of the projection. It is equal to the journal event type if the projection is null or it is the identity projection
    
    Parameters:
    
    startSequence - the sequence of the first item to read
    
    maxSize - the maximum number of items to read
    
    partitionId - the partition ID of the entries in the journal
    
    predicate - the predicate which the events must pass to be included in the response. May be null in which case all events pass the predicate
    
    projection - the projection which is applied to the events before returning. May be null in which case the event is returned without being projected
    
    Returns:
    
    the future with the filtered and projected journal items
  - getQueryCacheContext
```
public ClientQueryCacheContext getQueryCacheContext()
```
  - onDestroy
```
protected void onDestroy()
```
    Description copied from class: ClientProxy
    
    Called before proxy is destroyed. Overriding implementations should clean/release resources created during initialization.
    
    Overrides:
    
    onDestroy in class ClientProxy

Class ClientMapProxy<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Field Summary

Fields inherited from class com.hazelcast.client.spi.ClientProxy

Constructor Summary

Method Summary

Methods inherited from class com.hazelcast.client.spi.ClientProxy

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.concurrent.ConcurrentMap

Methods inherited from interface java.util.Map

Methods inherited from interface com.hazelcast.core.DistributedObject

Field Detail

NULL_LISTENER_IS_NOT_ALLOWED

NULL_KEY_IS_NOT_ALLOWED

NULL_VALUE_IS_NOT_ALLOWED

NULL_PREDICATE_IS_NOT_ALLOWED

NULL_AGGREGATOR_IS_NOT_ALLOWED

NULL_PROJECTION_IS_NOT_ALLOWED

Constructor Detail

ClientMapProxy

Method Detail

onInitialize

containsKey

containsKeyInternal

containsValue

get

getInternal

put

put

remove

removeInternal

remove

removeInternal

removeAll

removeAllInternal

delete

deleteInternal

flush

getAsync

getAsyncInternal

putAsync

putAsync

putAsync

putAsyncInternal

setAsync

setAsync

setAsync

setAsyncInternal

removeAsync

removeAsyncInternal

tryRemove

tryRemoveInternal

tryPut

tryPutInternal

put

putInternal

putTransient

putTransient

putTransientInternal

putIfAbsent

putIfAbsent

putIfAbsent

putIfAbsentInternal

replace

replaceIfSameInternal

replace

replaceInternal

set

set

setInternal

lock

lock

isLocked

tryLock

tryLock

tryLock

unlock

forceUnlock

addLocalEntryListener