com.hazelcast.client.impl.protocol.template

Interface MapCodecTemplate

public interface MapCodecTemplate

Method Summary

Modifier and Type	Method and Description
Object	addEntryListener(String name, boolean includeValue, int listenerFlags, boolean localOnly) Adds a MapListener for this map.
Object	addEntryListenerToKey(String name, Data key, boolean includeValue, int listenerFlags, boolean localOnly) Adds a MapListener for this map.
Object	addEntryListenerToKeyWithPredicate(String name, Data key, Data predicate, boolean includeValue, int listenerFlags, boolean localOnly) Adds a MapListener for this map.
Object	addEntryListenerWithPredicate(String name, Data predicate, boolean includeValue, int listenerFlags, boolean localOnly) Adds an continuous entry listener for this map.
void	addIndex(String name, String attribute, boolean ordered) Adds an index to this map for the specified entries so that queries can run faster.If you are querying your values mostly based on age and active then you should consider indexing these fields.
Object	addInterceptor(String name, Data interceptor) Adds an interceptor for this map.
Object	addNearCacheEntryListener(String name, int listenerFlags, boolean localOnly) Adds an entry listener for this map.
Object	addNearCacheInvalidationListener(String name, int listenerFlags, boolean localOnly) Adds listener to map.
Object	addPartitionLostListener(String name, boolean localOnly) Adds a MapPartitionLostListener.
Object	aggregate(String name, Data aggregator) Applies the aggregation logic on all map entries and returns the result
Object	aggregateWithPredicate(String name, Data aggregator, Data predicate) Applies the aggregation logic on map entries filtered with the Predicate and returns the result
Object	assignAndGetUuids() Assigns a new UUID to each partitions or gets existing ones.
void	clear(String name) This method clears the map and invokes MapStore#deleteAll deleteAll on MapStore which, if connected to a database, will delete the records from that database.
void	clearNearCache(String name, Address target)
Object	containsKey(String name, Data key, long threadId) Returns true if this map contains a mapping for the specified key.
Object	containsValue(String name, Data value) Returns true if this map maps one or more keys to the specified value.This operation will probably require time linear in the map size for most implementations of the Map interface.
void	delete(String name, Data key, long threadId) Removes the mapping for a key from this map if it is present.Unlike remove(Object), this operation does not return the removed value, which avoids the serialization cost of the returned value.If the removed value will not be used, a delete operation is preferred over a remove operation for better performance.
Object	entriesWithPagingPredicate(String name, Data predicate)
Object	entriesWithPredicate(String name, Data predicate) Queries the map based on the specified predicate and returns the matching entries.Specified predicate runs on all members in parallel.
Object	entrySet(String name) Returns a Set clone of the mappings contained in this map.
Object	eventJournalRead(String name, long startSequence, int minSize, int maxSize, Data predicate, Data projection) Reads from the map event journal in batches.
Object	eventJournalSubscribe(String name) Performs the initial subscription to the map event journal.
Object	evict(String name, Data key, long threadId) Evicts the specified key from this map.
void	evictAll(String name) Evicts all keys from this map except the locked ones.
Object	executeOnAllKeys(String name, Data entryProcessor) Applies the user defined EntryProcessor to the all entries in the map.Returns the results mapped by each key in the map.
Object	executeOnKey(String name, Data entryProcessor, Data key, long threadId) Applies the user defined EntryProcessor to the entry mapped by the key.
Object	executeOnKeys(String name, Data entryProcessor, List<Data> keys) Applies the user defined EntryProcessor to the entries mapped by the collection of keys.The results mapped by each key in the collection.
Object	executeWithPredicate(String name, Data entryProcessor, Data predicate) Applies the user defined EntryProcessor to the entries in the map which satisfies provided predicate.
Object	fetchEntries(String name, int partitionId, int tableIndex, int batch) Fetches specified number of entries from the specified partition starting from specified table index.
Object	fetchKeys(String name, int partitionId, int tableIndex, int batch) Fetches specified number of keys from the specified partition starting from specified table index.
Object	fetchNearCacheInvalidationMetadata(List<String> names, Address address) Fetches invalidation metadata from partitions of map.
Object	fetchWithQuery(String name, int tableIndex, int batch, Data projection, Data predicate) Fetches the specified number of entries from the specified partition starting from specified table index that match the predicate and applies the projection logic on them.
void	flush(String name) If this map has a MapStore, this method flushes all the local dirty entries by calling MapStore.storeAll() and/or MapStore.deleteAll().
void	forceUnlock(String name, Data key, long referenceId) Releases the lock for the specified key regardless of the lock owner.It always successfully unlocks the key, never blocks,and returns immediately.
Object	get(String name, Data key, long threadId) This method returns a clone of the original value, so modifying the returned value does not change the actual value in the map.
Object	getAll(String name, List<Data> keys) Returns the entries for the given keys.
Object	getEntryView(String name, Data key, long threadId) Returns the EntryView for the specified key.
Object	isEmpty(String name) Returns true if this map contains no key-value mappings.
Object	isLocked(String name, Data key) Checks the lock for the specified key.If the lock is acquired then returns true, else returns false.
Object	keySet(String name) Returns a set clone of the keys contained in this map.
Object	keySetWithPagingPredicate(String name, Data predicate)
Object	keySetWithPredicate(String name, Data predicate) Queries the map based on the specified predicate and returns the keys of matching entries.
void	loadAll(String name, boolean replaceExistingValues) Loads all keys into the store.
void	loadGivenKeys(String name, List<Data> keys, boolean replaceExistingValues) Loads the given keys.
void	lock(String name, Data key, long threadId, long ttl, long referenceId) Acquires the lock for the specified lease time.After lease time, 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.
Object	project(String name, Data projection) Applies the projection logic on all map entries and returns the result
Object	projectWithPredicate(String name, Data projection, Data predicate) Applies the projection logic on map entries filtered with the Predicate and returns the result
Object	put(String name, Data key, Data value, long threadId, long ttl) Puts an entry into this map with a given ttl (time to live) value.Entry will expire and get evicted after the ttl If ttl is 0, then the entry lives forever.This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.Time resolution for TTL is seconds.
void	putAll(String name, List<Map.Entry<Data,Data>> entries) Copies all of the mappings from the specified map to this map (optional operation).The effect of this call is equivalent to that of calling put(Object,Object) put(k, v) on this map once for each mapping from key k to value v in the specified map.The behavior of this operation is undefined if the specified map is modified while the operation is in progress.
Object	putIfAbsent(String name, Data key, Data value, long threadId, long ttl) 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.
void	putTransient(String name, Data key, Data value, long threadId, long ttl) Same as put except that MapStore, if defined, will not be called to store/persist the entry.
Object	remove(String name, Data key, long threadId) Removes the mapping for a key from this map if it is present (optional operation).
void	removeAll(String name, Data predicate) Removes all entries which match with the supplied predicate
Object	removeEntryListener(String name, String registrationId) Removes the specified entry listener.
Object	removeIfSame(String name, Data key, Data value, long threadId) Removes the mapping for a key from this map if existing value equal to the this value
Object	removeInterceptor(String name, String id) Removes the given interceptor for this map so it will not intercept operations anymore.
Object	removePartitionLostListener(String name, String registrationId) Removes the specified map partition lost listener.
Object	replace(String name, Data key, Data value, long threadId) Replaces the entry for a key only if currently mapped to a given value.
Object	replaceIfSame(String name, Data key, Data testValue, Data value, long threadId) Replaces the the entry for a key only if existing values equal to the testValue
void	set(String name, Data key, Data value, long threadId, long ttl) Puts an entry into this map with a given ttl (time to live) value.Entry will expire and get evicted after the ttl If ttl is 0, then the entry lives forever.
Object	size(String name) Returns the number of key-value mappings in this map.
Object	submitToKey(String name, Data entryProcessor, Data key, long threadId) Applies the user defined EntryProcessor to the entry mapped by the key.
Object	tryLock(String name, Data key, long threadId, long lease, long timeout, long referenceId) 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.
Object	tryPut(String name, Data key, Data value, long threadId, long timeout) Tries to put the given key and value into this map within a specified timeout value.
Object	tryRemove(String name, Data key, long threadId, long timeout) Tries to remove the entry with the given key from this map within the specified timeout value.
void	unlock(String name, Data key, long threadId, long referenceId) Releases the lock for the specified key.
Object	values(String name) Returns a collection clone of the values contained in this map.
Object	valuesWithPagingPredicate(String name, Data predicate) Queries the map based on the specified predicate and returns the values of matching entries.
Object	valuesWithPredicate(String name, Data predicate) Queries the map based on the specified predicate and returns the values of matching entries.Specified predicate runs on all members in parallel.

Method Detail

put

Object put(String name,
           Data key,
           Data value,
           long threadId,
           long ttl)

Puts an entry into this map with a given ttl (time to live) value.Entry will expire and get evicted after the ttl If ttl is 0, then the entry lives forever.This method returns a clone of the previous value, not the original (identically equal) value previously put into the map.Time resolution for TTL is seconds. The given TTL value is rounded to the next closest second value.

Parameters:

name - Name of the map.

key - Key for the map entry.

value - Value for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

ttl - The duration in milliseconds after which this entry shall be deleted. O means infinite.

Returns:

old value of the entry

get

Object get(String name,
           Data key,
           long threadId)

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.

Parameters:

name - Name of the map.

key - Key for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

Returns:

The value for the key if exists

remove

Object remove(String name,
              Data key,
              long threadId)

Removes the mapping for a key from this map if it is present (optional operation). Returns the value to which this map previously associated the key, or null if the map contained no mapping for the key. If this map permits null values, then a return value of null does not necessarily indicate that the map contained no mapping for the key; it's also possible that the map explicitly mapped the key to null. The map will not contain a mapping for the specified key once the call returns.

Parameters:

name - Name of the map.

key - Key for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

Returns:

Clone of the removed value, not the original (identically equal) value previously put into the map.

replace

Object replace(String name,
               Data key,
               Data value,
               long threadId)

Replaces the entry for a key only if currently mapped to a given value.

Parameters:

name - Name of the map.

key - Key for the map entry.

value - New value for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

Returns:

Clone of the previous value, not the original (identically equal) value previously put into the map.

replaceIfSame

Object replaceIfSame(String name,
                     Data key,
                     Data testValue,
                     Data value,
                     long threadId)

Replaces the the entry for a key only if existing values equal to the testValue

Parameters:

name - Name of the map.

key - Key for the map entry.

testValue - Test the existing value against this value to find if equal to this value.

value - New value for the map entry. Only replace with this value if existing value is equal to the testValue.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

Returns:

true if value is replaced with new one, false otherwise

containsKey

Object containsKey(String name,
                   Data key,
                   long threadId)

Returns true if this map contains a mapping for the specified key.

Parameters:

name - Name of the map.

key - Key for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

Returns:

Returns true if the key exists, otherwise returns false.

containsValue

Object containsValue(String name,
                     Data value)

Returns true if this map maps one or more keys to the specified value.This operation will probably require time linear in the map size for most implementations of the Map interface.

Parameters:

name - Name of the map.

value - Value to check if exists in the map.

Returns:

Returns true if the value exists, otherwise returns false.

removeIfSame

Object removeIfSame(String name,
                    Data key,
                    Data value,
                    long threadId)

Removes the mapping for a key from this map if existing value equal to the this value

Parameters:

name - Name of the map.

key - Key for the map entry.

value - Test the existing value against this value to find if equal to this value. Only remove the entry from the map if the value is equal to this value.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

Returns:

Returns true if the key exists and removed, otherwise returns false.

delete

void delete(String name,
            Data key,
            long threadId)

Removes the mapping for a key from this map if it is present.Unlike remove(Object), this operation does not return the removed value, which avoids the serialization cost of the returned value.If the removed value will not be used, a delete operation is preferred over a remove operation for better performance. The map will not contain a mapping for the specified key once the call returns. 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

Parameters:

name - Name of the map.

key - Key for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

flush

void flush(String name)

If this map has a MapStore, this method flushes all the local dirty entries by calling MapStore.storeAll() and/or MapStore.deleteAll().

Parameters:

name - Name of the map.

tryRemove

Object tryRemove(String name,
                 Data key,
                 long threadId,
                 long timeout)

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.

Parameters:

name - Name of the map.

key - Key for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

timeout - maximum time in milliseconds to wait for acquiring the lock for the key.

Returns:

Returns true if successful, otherwise returns false

tryPut

Object tryPut(String name,
              Data key,
              Data value,
              long threadId,
              long timeout)

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.

Parameters:

name - Name of the map.

key - Key for the map entry.

value - New value for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

timeout - maximum time in milliseconds to wait for acquiring the lock for the key.

Returns:

Returns true if successful, otherwise returns false

putTransient

void putTransient(String name,
                  Data key,
                  Data value,
                  long threadId,
                  long ttl)

Same as put except that MapStore, if defined, will not be called to store/persist the entry. If ttl is 0, then the entry lives forever.

Parameters:

name - Name of the map.

key - Key for the map entry.

value - New value for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

ttl - The duration in milliseconds after which this entry shall be deleted. O means infinite.

putIfAbsent

Object putIfAbsent(String name,
                   Data key,
                   Data value,
                   long threadId,
                   long ttl)

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. Entry will expire and get evicted after the ttl.

Parameters:

name - Name of the map.

key - Key for the map entry.

value - New value for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

ttl - The duration in milliseconds after which this entry shall be deleted. O means infinite.

Returns:

returns a clone of the previous value, not the original (identically equal) value previously put into the map.

set

void set(String name,
         Data key,
         Data value,
         long threadId,
         long ttl)

Puts an entry into this map with a given ttl (time to live) value.Entry will expire and get evicted after the ttl If ttl is 0, then the entry lives forever. Similar to the put operation except that set doesn't return the old value, which is more efficient.

Parameters:

name - Name of the map.

key - Key for the map entry.

value - New value for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

ttl - The duration in milliseconds after which this entry shall be deleted. O means infinite.

lock

void lock(String name,
          Data key,
          long threadId,
          long ttl,
          @Since(value="1.2")
          long referenceId)

Acquires the lock for the specified lease time.After lease time, 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.

Parameters:

name - Name of the map.

key - Key for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

ttl - The duration in milliseconds after which this entry shall be deleted. O means infinite.

referenceId - The client-wide unique id for this request. It is used to make the request idempotent by sending the same reference id during retries.

tryLock

Object tryLock(String name,
               Data key,
               long threadId,
               long lease,
               long timeout,
               @Since(value="1.2")
               long referenceId)

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.

Parameters:

name - Name of the map.

key - Key for the map entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

lease - time in milliseconds to wait before releasing the lock.

timeout - maximum time to wait for getting the lock.

referenceId - The client-wide unique id for this request. It is used to make the request idempotent by sending the same reference id during retries.

Returns:

Returns true if successful, otherwise returns false

isLocked

Object isLocked(String name,
                Data key)

Checks the lock for the specified key.If the lock is acquired then returns true, else returns false.

Parameters:

name - name of map

key - Key for the map entry to check if it is locked.

Returns:

Returns true if the entry is locked, otherwise returns false

unlock

void unlock(String name,
            Data key,
            long threadId,
            @Since(value="1.2")
            long referenceId)

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 ILLEGAL_MONITOR_STATE is thrown.

Parameters:

name - name of map

key - Key for the map entry to unlock

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

referenceId - The client-wide unique id for this request. It is used to make the request idempotent by sending the same reference id during retries.

addInterceptor

Object addInterceptor(String name,
                      Data interceptor)

Adds an interceptor for this map. Added interceptor will intercept operations and execute user defined methods and will cancel operations if user defined method throw exception.

Parameters:

name - name of map

interceptor - interceptor to add

Returns:

id of registered interceptor.

removeInterceptor

Object removeInterceptor(String name,
                         String id)

Removes the given interceptor for this map so it will not intercept operations anymore.

Parameters:

name - name of map

id - of interceptor

Returns:

Returns true if successful, otherwise returns false

addEntryListenerToKeyWithPredicate

Object addEntryListenerToKeyWithPredicate(String name,
                                          Data key,
                                          Data predicate,
                                          boolean includeValue,
                                          int listenerFlags,
                                          boolean localOnly)

Adds a MapListener for this map. To receive an event, you should implement a corresponding MapListener sub-interface for that event.

Parameters:

name - name of map

key - Key for the map entry.

predicate - predicate for filtering entries.

includeValue - true if EntryEvent should contain the value.

listenerFlags - flags of enabled listeners.

localOnly - if true fires events that originated from this node only, otherwise fires all events

Returns:

A unique string which is used as a key to remove the listener.

addEntryListenerWithPredicate

Object addEntryListenerWithPredicate(String name,
                                     Data predicate,
                                     boolean includeValue,
                                     int listenerFlags,
                                     boolean localOnly)

Adds an continuous entry listener for this map. Listener will get notified for map add/remove/update/evict events filtered by the given predicate.

Parameters:

name - name of map

predicate - predicate for filtering entries.

includeValue - true if EntryEvent should contain the value.

listenerFlags - flags of enabled listeners.

localOnly - if true fires events that originated from this node only, otherwise fires all events

Returns:

A unique string which is used as a key to remove the listener.

addEntryListenerToKey

Object addEntryListenerToKey(String name,
                             Data key,
                             boolean includeValue,
                             int listenerFlags,
                             boolean localOnly)

Adds a MapListener for this map. To receive an event, you should implement a corresponding MapListener sub-interface for that event.

Parameters:

name - name of map

key - Key for the map entry.

includeValue - true if EntryEvent should contain the value.

listenerFlags - flags of enabled listeners.

localOnly - if true fires events that originated from this node only, otherwise fires all events

Returns:

A unique string which is used as a key to remove the listener.

addEntryListener

Object addEntryListener(String name,
                        boolean includeValue,
                        int listenerFlags,
                        boolean localOnly)

Adds a MapListener for this map. To receive an event, you should implement a corresponding MapListener sub-interface for that event.

Parameters:

name - name of map

includeValue - true if EntryEvent should contain the value.

listenerFlags - flags of enabled listeners.

localOnly - if true fires events that originated from this node only, otherwise fires all events

Returns:

A unique string which is used as a key to remove the listener.

addNearCacheEntryListener

Object addNearCacheEntryListener(String name,
                                 int listenerFlags,
                                 boolean localOnly)

Adds an entry listener for this map. Listener will get notified for all map add/remove/update/evict events.

Parameters:

name - name of map

listenerFlags - flags of enabled listeners.

localOnly - if true fires events that originated from this node only, otherwise fires all events

Returns:

A unique string which is used as a key to remove the listener.

removeEntryListener

Object removeEntryListener(String name,
                           String registrationId)

Removes the specified entry listener. Returns silently if there is no such listener added before.

Parameters:

name - name of map

registrationId - id of registered listener.

Returns:

true if registration is removed, false otherwise.

addPartitionLostListener

Object addPartitionLostListener(String name,
                                boolean localOnly)

Adds a MapPartitionLostListener. The addPartitionLostListener returns a register-id. This id is needed to remove the MapPartitionLostListener using the removePartitionLostListener(String) method. There is no check for duplicate registrations, so if you register the listener twice, it will get events twice. IMPORTANT: Please see com.hazelcast.partition.PartitionLostListener for weaknesses. IMPORTANT: Listeners registered from HazelcastClient may miss some of the map partition lost events due to design limitations.

Parameters:

name - name of map

localOnly - if true fires events that originated from this node only, otherwise fires all events

Returns:

returns the registration id for the MapPartitionLostListener.

removePartitionLostListener

Object removePartitionLostListener(String name,
                                   String registrationId)

Removes the specified map partition lost listener. Returns silently if there is no such listener added before.

Parameters:

name - name of map

registrationId - id of register

Returns:

true if registration is removed, false otherwise.

getEntryView

Object getEntryView(String name,
                    Data key,
                    long threadId)

Returns the EntryView for the specified key. 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.

Parameters:

name - name of map

key - the key of the entry.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

Returns:

EntryView of the specified key.

evict

Object evict(String name,
             Data key,
             long threadId)

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.

Parameters:

name - name of map

key - the specified key to evict from this map.

threadId - The id of the user thread performing the operation. It is used to guarantee that only the lock holder thread (if a lock exists on the entry) can perform the requested operation.

Returns:

true if the key is evicted, false otherwise.

evictAll

void evictAll(String name)

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 deleteAll to be called use the clear method. The EVICT_ALL event is fired for any registered listeners.

Parameters:

name - name of map

loadAll

void loadAll(String name,
             boolean replaceExistingValues)

Loads all keys into the store. This is a batch load operation so that an implementation can optimize the multiple loads.

Parameters:

name - name of map

replaceExistingValues - when true, existing values in the Map will be replaced by those loaded from the MapLoader

loadGivenKeys

void loadGivenKeys(String name,
                   List<Data> keys,
                   boolean replaceExistingValues)

Loads the given keys. This is a batch load operation so that an implementation can optimize the multiple loads.

Parameters:

name - name of map

keys - keys to load

replaceExistingValues - when true, existing values in the Map will be replaced by those loaded from the MapLoader

keySet

Object keySet(String name)

Returns a set clone of the keys contained in this map. 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 query result size limit is configured.

Parameters:

name - name of the map

Returns:

a set clone of the keys contained in this map.

See Also:

com.hazelcast.instance.GroupProperty#QUERY_RESULT_SIZE_LIMIT

getAll

Object getAll(String name,
              List<Data> keys)

Returns the entries for the given keys. If any keys are not present in the Map, it will call loadAll 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. Please note that all the keys in the request should belong to the partition id to which this request is being sent, all keys matching to a different partition id shall be ignored. The API implementation using this request may need to send multiple of these request messages for filling a request for a key set if the keys belong to different partitions.

Parameters:

name - name of map

keys - keys to get

Returns:

values for the provided keys.

values

Object values(String name)

Returns a collection clone of the values contained in this map. 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 query result size limit is configured.

Parameters:

name - name of map

Returns:

All values in the map

See Also:

com.hazelcast.instance.GroupProperty#QUERY_RESULT_SIZE_LIMIT

entrySet

Object entrySet(String name)

Returns a Set clone of the mappings contained in this map. 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 query result size limit is configured.

Parameters:

name - name of map

Returns:

a set clone of the keys mappings in this map

See Also:

com.hazelcast.instance.GroupProperty#QUERY_RESULT_SIZE_LIMIT

keySetWithPredicate

Object keySetWithPredicate(String name,
                           Data predicate)

Queries the map based on the specified predicate and returns the keys of matching entries. Specified predicate runs on all members in parallel.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 query result size limit is configured.

Parameters:

name - name of map.

predicate - specified query criteria.

Returns:

result key set for the query.

See Also:

com.hazelcast.instance.GroupProperty#QUERY_RESULT_SIZE_LIMIT

valuesWithPredicate

Object valuesWithPredicate(String name,
                           Data predicate)

Queries the map based on the specified predicate and returns the values of matching entries.Specified predicate runs on all members in parallel. 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 query result size limit is configured.

Parameters:

name - name of map

predicate - specified query criteria.

Returns:

result value collection of the query.

See Also:

com.hazelcast.instance.GroupProperty#QUERY_RESULT_SIZE_LIMIT

entriesWithPredicate

Object entriesWithPredicate(String name,
                            Data predicate)

Queries the map based on the specified predicate and returns the matching entries.Specified predicate runs on all members in parallel. 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 query result size limit is configured.

Parameters:

name - name of map

predicate - specified query criteria.

Returns:

result key-value entry collection of the query.

See Also:

com.hazelcast.instance.GroupProperty#QUERY_RESULT_SIZE_LIMIT

addIndex

void addIndex(String name,
              String attribute,
              boolean ordered)

Adds an index to this map for the specified entries so that queries can run faster.If you are querying your values mostly based on age and active then you should consider indexing these fields. 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. 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. 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.

Parameters:

name - name of map

attribute - index attribute of value

ordered - true if index should be ordered, false otherwise.

size

Object size(String name)

Returns the number of key-value mappings in this map. If the map contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE

Parameters:

name - of map

Returns:

the number of key-value mappings in this map

isEmpty

Object isEmpty(String name)

Returns true if this map contains no key-value mappings.

Parameters:

name - name of map

Returns:

true if this map contains no key-value mappings

putAll

void putAll(String name,
            List<Map.Entry<Data,Data>> entries)

Copies all of the mappings from the specified map to this map (optional operation).The effect of this call is equivalent to that of calling put(Object,Object) put(k, v) on this map once for each mapping from key k to value v in the specified map.The behavior of this operation is undefined if the specified map is modified while the operation is in progress. Please note that all the keys in the request should belong to the partition id to which this request is being sent, all keys matching to a different partition id shall be ignored. The API implementation using this request may need to send multiple of these request messages for filling a request for a key set if the keys belong to different partitions.

Parameters:

name - name of map

entries - mappings to be stored in this map

clear

void clear(String name)

This method clears the map and invokes MapStore#deleteAll deleteAll on MapStore which, if connected to a database, will delete the records from that database. The MAP_CLEARED event is fired for any registered listeners. To clear a map without calling MapStore#deleteAll, use #evictAll.

Parameters:

name - of map

executeOnKey

Object executeOnKey(String name,
                    Data entryProcessor,
                    Data key,
                    long threadId)

Applies the user defined EntryProcessor to the entry mapped by the key. Returns the the object which is result of the process() method of EntryProcessor.

Parameters:

name - name of map

entryProcessor - processor to execute on the map entry

key - the key of the map entry.

Returns:

result of entry process.

submitToKey

Object submitToKey(String name,
                   Data entryProcessor,
                   Data key,
                   long threadId)

Applies the user defined EntryProcessor to the entry mapped by the key. Returns immediately with a Future representing that task.EntryProcessor is not cancellable, so calling Future.cancel() method won't cancel the operation of EntryProcessor.

Parameters:

name - name of map

entryProcessor - entry processor to be executed on the entry.

key - the key of the map entry.

Returns:

result of entry process.

executeOnAllKeys

Object executeOnAllKeys(String name,
                        Data entryProcessor)

Applies the user defined EntryProcessor to the all entries in the map.Returns the results mapped by each key in the map.

Parameters:

name - name of map

entryProcessor - entry processor to be executed.

Returns:

results of entry process on the entries

executeWithPredicate

Object executeWithPredicate(String name,
                            Data entryProcessor,
                            Data predicate)

Applies the user defined EntryProcessor to the entries in the map which satisfies provided predicate. Returns the results mapped by each key in the map.

Parameters:

name - name of map

entryProcessor - entry processor to be executed.

predicate - specified query criteria.

Returns:

results of entry process on the entries matching the query criteria

executeOnKeys

Object executeOnKeys(String name,
                     Data entryProcessor,
                     List<Data> keys)

Applies the user defined EntryProcessor to the entries mapped by the collection of keys.The results mapped by each key in the collection.

Parameters:

name - name of map

entryProcessor - entry processor to be executed.

keys - The keys for the entries for which the entry processor shall be executed on.

Returns:

results of entry process on the entries with the provided keys

forceUnlock

void forceUnlock(String name,
                 Data key,
                 @Since(value="1.2")
                 long referenceId)

Releases the lock for the specified key regardless of the lock owner.It always successfully unlocks the key, never blocks,and returns immediately.

Parameters:

name - name of map

key - the key of the map entry.

referenceId - The client-wide unique id for this request. It is used to make the request idempotent by sending the same reference id during retries.

keySetWithPagingPredicate

Object keySetWithPagingPredicate(String name,
                                 Data predicate)

Parameters:

name - name of map

predicate - specified query criteria.

Returns:

result keys for the query.

valuesWithPagingPredicate

Object valuesWithPagingPredicate(String name,
                                 Data predicate)

Queries the map based on the specified predicate and returns the values of matching entries. Specified predicate runs on all members in parallel. 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 query result size limit is configured.

Parameters:

name - name of map

predicate - specified query criteria.

Returns:

values for the query.

See Also:

com.hazelcast.instance.GroupProperty#QUERY_RESULT_SIZE_LIMIT

entriesWithPagingPredicate

Object entriesWithPagingPredicate(String name,
                                  Data predicate)

Parameters:

name - name of map

predicate - specified query criteria.

Returns:

key-value pairs for the query.

clearNearCache

void clearNearCache(String name,
                    Address target)

fetchKeys

@Since(value="1.1")
Object fetchKeys(String name,
                                     int partitionId,
                                     int tableIndex,
                                     int batch)

Fetches specified number of keys from the specified partition starting from specified table index.

Parameters:

name - Name of the map.

partitionId - The partition id which owns this record store.

tableIndex - The slot number (or index) to start the iterator

batch - The number of items to be batched

Returns:

last index processed and list of keys

fetchEntries

@Since(value="1.1")
Object fetchEntries(String name,
                                        int partitionId,
                                        int tableIndex,
                                        int batch)

Fetches specified number of entries from the specified partition starting from specified table index.

Parameters:

name - Name of the map.

partitionId - The partition id which owns this record store.

tableIndex - The slot number (or index) to start the iterator

batch - The number of items to be batched

Returns:

last index processed and list of entries

aggregate

@Since(value="1.4")
Object aggregate(String name,
                                     Data aggregator)

Applies the aggregation logic on all map entries and returns the result

Parameters:

name - Name of the map.

aggregator - aggregator to aggregate the entries with

Returns:

the aggregation result

aggregateWithPredicate

@Since(value="1.4")
Object aggregateWithPredicate(String name,
                                                  Data aggregator,
                                                  Data predicate)

Applies the aggregation logic on map entries filtered with the Predicate and returns the result

Parameters:

name - Name of the map.

aggregator - aggregator to aggregate the entries with

predicate - predicate to filter the entries with

Returns:

the aggregation result

project

@Since(value="1.4")
Object project(String name,
                                   Data projection)

Applies the projection logic on all map entries and returns the result

Parameters:

name - Name of the map.

projection - projection to transform the entries with. May return null.

Returns:

the resulted collection upon transformation to the type of the projection

projectWithPredicate

@Since(value="1.4")
Object projectWithPredicate(String name,
                                                Data projection,
                                                Data predicate)

Applies the projection logic on map entries filtered with the Predicate and returns the result

Parameters:

name - Name of the map.

projection - projection to transform the entries with. May return null.

predicate - predicate to filter the entries with

Returns:

the resulted collection upon transformation to the type of the projection

fetchNearCacheInvalidationMetadata

@Since(value="1.4")
Object fetchNearCacheInvalidationMetadata(List<String> names,
                                                              Address address)

Fetches invalidation metadata from partitions of map.

Parameters:

names - names of the maps

Returns:

metadata

assignAndGetUuids

@Since(value="1.4")
Object assignAndGetUuids()

Assigns a new UUID to each partitions or gets existing ones.

Returns:

partitionId to assigned uuid entry list

removeAll

@Since(value="1.4")
void removeAll(String name,
                                   Data predicate)

Removes all entries which match with the supplied predicate

Parameters:

name - map name.

predicate - used to select entries to be removed from map.

addNearCacheInvalidationListener

@Since(value="1.4")
Object addNearCacheInvalidationListener(String name,
                                                            int listenerFlags,
                                                            boolean localOnly)

Adds listener to map. This listener will be used to listen near cache invalidation events. Eventually consistent client near caches should use this method to add invalidation listeners instead of addNearCacheEntryListener(String, int, boolean)

Parameters:

name - name of the map

listenerFlags - flags of enabled listeners.

localOnly - if true fires events that originated from this node only, otherwise fires all events

Returns:

A unique string which is used as a key to remove the listener.

fetchWithQuery

@Since(value="1.5")
Object fetchWithQuery(String name,
                                          int tableIndex,
                                          int batch,
                                          Data projection,
                                          Data predicate)

Fetches the specified number of entries from the specified partition starting from specified table index that match the predicate and applies the projection logic on them.

Parameters:

name - Name of the map

tableIndex - The slot number (or index) to start the iterator

batch - The number of items to be batched

projection - projection to transform the entries with

predicate - predicate to filter the entries with

Returns:

last index processed and list of entries after applied to the projection

eventJournalSubscribe

@Since(value="1.5")
Object eventJournalSubscribe(String name)

Performs the initial subscription to the map event journal. This includes retrieving the event journal sequences of the oldest and newest event in the journal.

Parameters:

name - name of the map

Returns:

the map event journal subcription information

eventJournalRead

@Since(value="1.5")
Object eventJournalRead(String name,
                                            long startSequence,
                                            int minSize,
                                            int maxSize,
                                            @Nullable
                                            Data predicate,
                                            @Nullable
                                            Data projection)

Reads from the map event journal in batches. You may specify the start sequence, the minumum required number of items in the response, the maximum number of items in the response, a predicate that the events should pass and a projection to apply to the events in the journal. If the event journal currently contains less events than minSize, the call will wait until it has sufficient items. The predicate, filter and projection may be null in which case all elements are returned and no projection is applied.

Parameters:

name - name of the map

startSequence - the startSequence of the first item to read

minSize - the minimum number of items to read.

maxSize - the maximum number of items to read.

predicate - the predicate to apply before processing events

projection - the projection to apply to journal events

Returns:

read event journal items