Concurrent, distributed, observable and queryable map client. More...

#include <imap.h>

Inheritance diagram for hazelcast::client::imap:

Public Member Functions
	imap (const std::string &instance_name, spi::ClientContext *context)

template<typename K >
boost::future< bool >	contains_key (const K &key)
	check if this map contains key. More...

template<typename V >
boost::future< bool >	contains_value (const V &value)
	check if this map contains value. More...

template<typename K , typename V >
boost::future< boost::optional< V > >	get (const K &key)
	get the value. More...

template<typename K , typename V , typename R = V>
boost::future< boost::optional< R > >	put (const K &key, const V &value)
	put new entry into map. More...

template<typename K , typename V , typename R = V>
boost::future< boost::optional< R > >	put (const K &key, const V &value, std::chrono::milliseconds ttl)
	Puts an entry into this map with a given ttl (time to live) value. More...

template<typename K , typename V >
boost::future< boost::optional< V > >	remove (const K &key)
	remove entry form map More...

template<typename K , typename V >
boost::future< bool >	remove (const K &key, const V &value)
	removes entry from map if there is an entry with same key and value. More...

template<typename P >
boost::future< void >	remove_all (const P &predicate)
	Removes all entries which match with the supplied predicate. More...

template<typename K >
boost::future< void >	delete_entry (const K &key)
	removes entry from map. More...

template<typename K >
boost::future< bool >	try_remove (const K &key, std::chrono::milliseconds timeout)
	Tries to remove the entry with the given key from this map within specified timeout value. More...

template<typename K , typename V >
boost::future< bool >	try_put (const K &key, const V &value, std::chrono::milliseconds timeout)
	Tries to put the given key, value into this map within specified timeout value. More...

template<typename K , typename V >
boost::future< void >	put_transient (const K &key, const V &value, std::chrono::milliseconds ttl)
	Same as put(K, V, int64_t, TimeUnit) but MapStore, if defined, will not be called to store/persist the entry. More...

template<typename K , typename V , typename R = V>
boost::future< boost::optional< V > >	put_if_absent (const K &key, const V &value)
	Puts an entry into this map, if the specified key is not already associated with a value. More...

template<typename K , typename V , typename R = V>
boost::future< boost::optional< V > >	put_if_absent (const K &key, const V &value, std::chrono::milliseconds 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. More...

template<typename K , typename V , typename N = V>
boost::future< bool >	replace (const K &key, const V &old_value, const N &new_value)
	Replaces the entry for a key only if currently mapped to a given value. More...

template<typename K , typename V , typename R = V>
boost::future< boost::optional< R > >	replace (const K &key, const V &value)
	Replaces the entry for a key only if currently mapped to some value. More...

template<typename K , typename V , typename R = V>
boost::future< void >	set (const K &key, const V &value)
	Puts an entry into this map. More...

template<typename K , typename V >
boost::future< void >	set (const K &key, const V &value, std::chrono::milliseconds ttl)
	Puts an entry into this map. More...

template<typename K >
boost::future< void >	lock (const K &key)
	Acquires the lock for the specified key. More...

template<typename K >
boost::future< void >	lock (const K &key, std::chrono::milliseconds lease_time)
	Acquires the lock for the specified key for the specified lease time. More...

template<typename K >
boost::future< bool >	is_locked (const K &key)
	Checks the lock for the specified key. More...

template<typename K >
boost::future< bool >	try_lock (const K &key)
	Tries to acquire the lock for the specified key. More...

template<typename K >
boost::future< bool >	try_lock (const K &key, std::chrono::milliseconds timeout)
	Tries to acquire the lock for the specified key. More...

template<typename K >
boost::future< bool >	try_lock (const K &key, std::chrono::milliseconds timeout, std::chrono::milliseconds lease_time)
	Tries to acquire the lock for the specified key for the specified lease time. More...

template<typename K >
boost::future< void >	unlock (const K &key)
	Releases the lock for the specified key. More...

template<typename K >
boost::future< void >	force_unlock (const K &key)
	Releases the lock for the specified key regardless of the lock owner. More...

template<typename MapInterceptor >
boost::future< std::string >	add_interceptor (const MapInterceptor &interceptor)
	Adds an interceptor for this map. More...

boost::future< boost::uuids::uuid >	add_entry_listener (entry_listener &&listener, bool include_value)
	Adds an entry listener for this map. More...

template<typename P >
boost::future< boost::uuids::uuid >	add_entry_listener (entry_listener &&listener, const P &predicate, bool include_value)
	Adds an entry listener for this map. More...

template<typename K >
boost::future< boost::uuids::uuid >	add_entry_listener (entry_listener &&listener, bool include_value, const K &key)
	Adds the specified entry listener for the specified key. More...

template<typename K , typename V >
boost::future< boost::optional< entry_view< K, V > > >	get_entry_view (const K &key)
	Returns the `EntryView` for the specified key. More...

template<typename K >
boost::future< bool >	evict (const K &key)
	Evicts the specified key from this map. More...

template<typename K , typename V >
boost::future< std::unordered_map< K, V > >	get_all (const std::unordered_set< K > &keys)
	Returns the entries for the given keys. More...

template<typename K >
boost::future< std::vector< K > >	key_set ()
	Returns a vector clone of the keys contained in this map. More...

template<typename K , typename P , class = typename std::enable_if<!std::is_base_of<query::paging_predicate_marker, P>::value>::type>
boost::future< std::vector< K > >	key_set (const P &predicate)
	Queries the map based on the specified predicate and returns the keys of matching entries. More...

template<typename K , typename V >
boost::future< std::vector< K > >	key_set (query::paging_predicate< K, V > &predicate)
	Queries the map based on the specified predicate and returns the keys of matching entries. More...

template<typename V >
boost::future< std::vector< V > >	values ()
	Returns a vector clone of the values contained in this map. More...

template<typename V , typename P , class = typename std::enable_if<!std::is_base_of<query::paging_predicate_marker, P>::value>::type>
boost::future< std::vector< V > >	values (const P &predicate)
	Returns a vector clone of the values contained in this map. More...

template<typename K , typename V >
boost::future< std::vector< V > >	values (query::paging_predicate< K, V > &predicate)
	Returns a vector clone of the values contained in this map. More...

template<typename K , typename V >
boost::future< std::vector< std::pair< K, V > > >	entry_set ()
	Returns a std::vector< std::pair<K, V> > clone of the mappings contained in this map. More...

template<typename K , typename V , typename P , class = typename std::enable_if<!std::is_base_of<query::paging_predicate_marker, P>::value>::type>
boost::future< std::vector< std::pair< K, V > > >	entry_set (const P &predicate)
	Queries the map based on the specified predicate and returns the matching entries. More...

template<typename K , typename V >
boost::future< std::vector< std::pair< K, V > > >	entry_set (query::paging_predicate< K, V > &predicate)
	Queries the map based on the specified predicate and returns the matching entries. More...

boost::future< void >	add_index (const config::index_config &config)
	Adds an index to this map for the specified entries so that queries can run faster. More...

template<typename ... T>
boost::future< void >	add_index (config::index_config::index_type type, T... attributes)
	Convenient method to add an index to this map with the given type and attributes. More...

boost::future< void >	clear ()

template<typename K , typename ResultType , typename EntryProcessor >
boost::future< boost::optional< ResultType > >	execute_on_key (const K &key, const EntryProcessor &entry_processor)
	Applies the user defined EntryProcessor to the entry mapped by the key. More...

template<typename K , typename ResultType , typename EntryProcessor >
boost::future< boost::optional< ResultType > >	submit_to_key (const K &key, const EntryProcessor &entry_processor)
	Applies the user defined EntryProcessor to the entry mapped by the key. More...

template<typename K , typename ResultType , typename EntryProcessor >
boost::future< std::unordered_map< K, boost::optional< ResultType > > >	execute_on_keys (const std::unordered_set< K > &keys, const EntryProcessor &entry_processor)
	Applies the user defined EntryProcessor to the entries mapped by the collection of keys. More...

template<typename K , typename ResultType , typename EntryProcessor >
boost::future< std::unordered_map< K, boost::optional< ResultType > > >	execute_on_entries (const EntryProcessor &entry_processor)
	Applies the user defined EntryProcessor to the all entries in the map. More...

template<typename K , typename ResultType , typename EntryProcessor , typename P >
boost::future< std::unordered_map< K, boost::optional< ResultType > > >	execute_on_entries (const EntryProcessor &entry_processor, const P &predicate)
	Applies the user defined EntryProcessor to the all entries in the map. More...

template<typename K , typename V >
boost::future< void >	put_all (const std::unordered_map< K, V > &entries)
	Copies all of the mappings from the specified map to this map (optional operation). More...

monitor::local_map_stats &	get_local_map_stats ()
	Returns LocalMapStats for this map. More...

template<typename K , typename V >
query::paging_predicate< K, V >	new_paging_predicate (size_t predicate_page_size)

template<typename K , typename V , typename INNER_PREDICATE >
query::paging_predicate< K, V >	new_paging_predicate (size_t predicate_page_size, const INNER_PREDICATE &predicate)

template<typename K , typename V , typename COMPARATOR >
query::paging_predicate< K, V >	new_paging_predicate (COMPARATOR &&comparator, size_t predicate_page_size)

template<typename K , typename V , typename INNER_PREDICATE , typename COMPARATOR >
query::paging_predicate< K, V >	new_paging_predicate (const INNER_PREDICATE &predicate, COMPARATOR &&comparator, size_t predicate_page_size)

Static Public Attributes
static constexpr const char *	SERVICE_NAME = "hz:impl:mapService"

Protected Member Functions
virtual boost::future< boost::optional< serialization::pimpl::data > >	get_internal (const serialization::pimpl::data &key_data)

virtual boost::future< bool >	contains_key_internal (const serialization::pimpl::data &key_data)

virtual boost::future< boost::optional< serialization::pimpl::data > >	remove_internal (const serialization::pimpl::data &key_data)

virtual boost::future< bool >	remove_internal (const serialization::pimpl::data &key_data, const serialization::pimpl::data &value_data)

virtual boost::future< protocol::ClientMessage >	remove_all_internal (const serialization::pimpl::data &predicate_data)

virtual boost::future< protocol::ClientMessage >	delete_internal (const serialization::pimpl::data &key_data)

virtual boost::future< bool >	try_remove_internal (const serialization::pimpl::data &key_data, std::chrono::milliseconds timeout)

virtual boost::future< bool >	try_put_internal (const serialization::pimpl::data &key_data, const serialization::pimpl::data &value_data, std::chrono::milliseconds timeout)

virtual boost::future< boost::optional< serialization::pimpl::data > >	put_internal (const serialization::pimpl::data &key_data, const serialization::pimpl::data &value_data, std::chrono::milliseconds ttl)

virtual boost::future< protocol::ClientMessage >	try_put_transient_internal (const serialization::pimpl::data &key_data, const serialization::pimpl::data &value_data, std::chrono::milliseconds ttl)

virtual boost::future< boost::optional< serialization::pimpl::data > >	put_if_absent_internal (const serialization::pimpl::data &key_data, const serialization::pimpl::data &value_data, std::chrono::milliseconds ttl)

virtual boost::future< bool >	replace_if_same_internal (const serialization::pimpl::data &key_data, const serialization::pimpl::data &value_data, const serialization::pimpl::data &new_value_data)

virtual boost::future< boost::optional< serialization::pimpl::data > >	replace_internal (const serialization::pimpl::data &key_data, const serialization::pimpl::data &value_data)

virtual boost::future< protocol::ClientMessage >	set_internal (const serialization::pimpl::data &key_data, const serialization::pimpl::data &value_data, std::chrono::milliseconds ttl)

virtual boost::future< bool >	evict_internal (const serialization::pimpl::data &key_data)

virtual boost::future< EntryVector >	get_all_internal (int partition_id, const std::vector< serialization::pimpl::data > &partition_keys)

virtual boost::future< boost::optional< serialization::pimpl::data > >	execute_on_key_internal (const serialization::pimpl::data &key_data, const serialization::pimpl::data &processor)

boost::future< boost::optional< serialization::pimpl::data > >	submit_to_key_internal (const serialization::pimpl::data &key_data, const serialization::pimpl::data &processor)

template<typename K , typename EntryProcessor >
boost::future< EntryVector >	execute_on_keys_internal (const std::unordered_set< K > &keys, const EntryProcessor &entry_processor)

virtual boost::future< protocol::ClientMessage >	put_all_internal (int partition_id, const EntryVector &entries)

Protected Attributes
monitor::impl::LocalMapStatsImpl	local_map_stats_

Static Protected Attributes
static constexpr std::chrono::milliseconds	UNSET {-1}
	Default TTL value of a record.

Friends
class	spi::ProxyManager

Detailed Description

Concurrent, distributed, observable and queryable map client.

Notice that this class have a private constructor. You can access get an IMap in the following way

 auto client = new_client().get();
 auto imap = client.get_map("aMap").get();

Definition at line 63 of file imap.h.

Member Function Documentation

◆ add_entry_listener() [1/3]

boost::future<boost::uuids::uuid> hazelcast::client::imap::add_entry_listener	(	entry_listener &&	listener,
		bool	include_value
	)

inline

Adds an entry listener for this map.

Warning 1: If listener should do a time consuming operation, off-load the operation to another thread. otherwise it will slow down the system.

Warning 2: Do not make a call to hazelcast. It can cause deadlock.

Parameters

listener	entry listener
includeValue	`true` if `EntryEvent` should contain the value.

Returns: registrationId of added listener that can be used to remove the entry listener.

Definition at line 471 of file imap.h.

                                                                                                           {
                 const auto listener_flags = listener.flags_;
                 return proxy::IMapImpl::add_entry_listener(
                         std::unique_ptr<impl::BaseEventHandler>(
                                 new impl::EntryEventHandler<protocol::codec::map_addentrylistener_handler>(
                                         get_name(), get_context().get_client_cluster_service(),
                                         get_context().get_serialization_service(),
                                         std::move(listener),
                                         include_value, get_context().get_logger())), include_value, listener_flags);
             }

◆ add_entry_listener() [2/3]

template<typename K >

boost::future<boost::uuids::uuid> hazelcast::client::imap::add_entry_listener	(	entry_listener &&	listener,
		bool	include_value,
		const K &	key
	)

inline

Adds the specified entry listener for the specified key.

Warning 1: If listener should do a time consuming operation, off-load the operation to another thread. otherwise it will slow down the system.

Warning 2: Do not make a call to hazelcast. It can cause deadlock.

Parameters

listener	entry listener
key	key to listen
includeValue	`true` if `EntryEvent` should contain the value.

Definition at line 524 of file imap.h.

                                                                                                                         {
                 const auto listener_flags = listener.flags_;
                 return proxy::IMapImpl::add_entry_listener(
                         std::shared_ptr<impl::BaseEventHandler>(
                                 new impl::EntryEventHandler<protocol::codec::map_addentrylistenertokey_handler>(
                                         get_name(), get_context().get_client_cluster_service(),
                                         get_context().get_serialization_service(),
                                         std::move(listener),
                                         include_value, get_context().get_logger())), include_value, to_data<K>(key), listener_flags);
             }

◆ add_entry_listener() [3/3]

template<typename P >

boost::future<boost::uuids::uuid> hazelcast::client::imap::add_entry_listener	(	entry_listener &&	listener,
		const P &	predicate,
		bool	include_value
	)

inline

Adds an entry listener for this map.

Warning 1: If listener should do a time consuming operation, off-load the operation to another thread. otherwise it will slow down the system.

Warning 2: Do not make a call to hazelcast. It can cause deadlock.

Parameters

listener	entry listener
predicate	The query filter to use when returning the events to the user.
includeValue	`true` if `EntryEvent` should contain the value.

Returns: registrationId of added listener that can be used to remove the entry listener.

Definition at line 499 of file imap.h.

                                                                                                   {
                 const auto listener_flags = listener.flags_;
                 return proxy::IMapImpl::add_entry_listener(
                         std::unique_ptr<impl::BaseEventHandler>(
                                 new impl::EntryEventHandler<protocol::codec::map_addentrylistenerwithpredicate_handler>(
                                         get_name(), get_context().get_client_cluster_service(),
                                         get_context().get_serialization_service(),
                                         std::move(listener),
                                         include_value, get_context().get_logger())), to_data<P>(predicate), include_value, listener_flags);
             }

◆ add_index() [1/2]

template<typename ... T>

boost::future<void> hazelcast::client::imap::add_index	(	config::index_config::index_type	type,
		T...	attributes
	)

inline

Convenient method to add an index to this map with the given type and attributes.

Attributes are indexed in ascending order.

Parameters

type	Index type.
attributes	Attributes to be indexed.

Definition at line 832 of file imap.h.

                                                                                             {
                 return add_index(config::index_config(type, std::forward<T>(attributes)...));
             }

◆ add_index() [2/2]

boost::future<void> hazelcast::client::imap::add_index ( const config::index_config & config )

inline

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.

  struct Employee {
    bool active;
    int32_t age;
    std::string name;
    // other fields

  }

If you are querying your values mostly based on age and active then you may consider indexing these fields.

  auto imap = client.getMap("employees");
  imap.addIndex(config::index_config(config::index_config::index_type::SORTED, "age"));  // Sorted index for range queries
  imap.addIndex(config::index_config(config::index_config::index_type::HASH, "active"));  // Sorted index for range queries

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.

Parameters

config Index configuration.

Definition at line 819 of file imap.h.

                                                                           {
                 return to_void_future(proxy::IMapImpl::add_index_data(config));
             }

◆ add_interceptor()

template<typename MapInterceptor >

boost::future<std::string> hazelcast::client::imap::add_interceptor ( const MapInterceptor & interceptor )

inline

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.

Interceptor should be serializable. Notice that map interceptor runs on the nodes. Because of that same class should be implemented in java side with same classId and factoryId.

Parameters

interceptor map interceptor

Returns: id of registered interceptor

Definition at line 453 of file imap.h.

                                                                                       {
                 return proxy::IMapImpl::add_interceptor(to_data(interceptor));
             }

◆ contains_key()

template<typename K >

boost::future<bool> hazelcast::client::imap::contains_key ( const K & key )

inline

check if this map contains key.

Parameters

key

Returns: true if contains, false otherwise

Definition at line 77 of file imap.h.

                                                          {
                 return contains_key_internal(to_data(key));
             }

◆ contains_value()

template<typename V >

boost::future<bool> hazelcast::client::imap::contains_value ( const V & value )

inline

check if this map contains value.

Parameters

value

Returns: true if contains, false otherwise

Definition at line 87 of file imap.h.

                                                              {
                 return proxy::IMapImpl::contains_value(to_data(value));
             }

◆ delete_entry()

template<typename K >

boost::future<void> hazelcast::client::imap::delete_entry ( const K & key )

inline

removes entry from map.

Does not return anything.

Parameters

key	The key of the map entry to remove.

Definition at line 168 of file imap.h.

                                                          {
                 return to_void_future(delete_internal(to_data(key)));
             }

◆ entry_set() [1/3]

template<typename K , typename V >

boost::future<std::vector<std::pair<K, V> > > hazelcast::client::imap::entry_set ( )

inline

Returns a std::vector< std::pair<K, V> > clone of the mappings contained in this map.

The vector is NOT backed by the map, so changes to the map are NOT reflected in the set, and vice-versa.

Returns: a vector clone of the keys mappings in this map

Definition at line 733 of file imap.h.

                                                               {
                 return to_entry_object_vector<K,V>(proxy::IMapImpl::entry_set_data());
             }

◆ entry_set() [2/3]

template<typename K , typename V , typename P , class = typename std::enable_if<!std::is_base_of<query::paging_predicate_marker, P>::value>::type>

boost::future<std::vector<std::pair<K, V> > > hazelcast::client::imap::entry_set ( const P & predicate )

inline

Queries the map based on the specified predicate and returns the matching entries.

Specified predicate runs on all members in parallel.

Parameters

predicate query criteria

Returns: result entry vector of the query

Definition at line 748 of file imap.h.

                                                                                 {
                 return to_entry_object_vector<K,V>(proxy::IMapImpl::entry_set_data(to_data(predicate)));
             }

◆ entry_set() [3/3]

template<typename K , typename V >

boost::future<std::vector<std::pair<K, V> > > hazelcast::client::imap::entry_set ( query::paging_predicate< K, V > & predicate )

inline

Queries the map based on the specified predicate and returns the matching entries.

Specified predicate runs on all members in parallel.

Parameters

predicate query criteria

Returns: result entry vector of the query

Definition at line 763 of file imap.h.

                                                                                                     {
                 predicate.set_iteration_type(query::iteration_type::ENTRY);
                 return entry_set_for_paging_predicate_data(
                         protocol::codec::holder::paging_predicate_holder::of(predicate, serialization_service_)).then(
                         [=, &predicate](boost::future<std::pair<EntryVector, query::anchor_data_list>> f) {
                     auto result = f.get();
                     predicate.set_anchor_data_list(std::move(result.second));
                     const auto &entries_data = result.first;
                     std::vector<std::pair<K, V>> entries;
                     entries.reserve(entries_data.size());
                     for(const auto &e : entries_data) {
                         entries.emplace_back(*to_object<K>(e.first), *to_object<V>(e.second));
                     }
                     return entries;
                 });
             }

◆ evict()

template<typename K >

boost::future<bool> hazelcast::client::imap::evict ( const K & key )

inline

Evicts the specified key from this map.

If a MapStore defined for this map, then the entry is not deleted from the underlying MapStore, evict only removes the entry from the memory.

Parameters

key	key to evict

Returns: true if the key is evicted, false otherwise.

Definition at line 566 of file imap.h.

                                                   {
                 return evict_internal(to_data(key));
             }

◆ execute_on_entries() [1/2]

template<typename K , typename ResultType , typename EntryProcessor >

boost::future<std::unordered_map<K, boost::optional<ResultType> > > hazelcast::client::imap::execute_on_entries ( const EntryProcessor & entry_processor )

inline

Applies the user defined EntryProcessor to the all entries in the map.

Returns the results mapped by each key in the map.

EntryProcessor should be serializable. Notice that map EntryProcessor runs on the nodes. Because of that, same class should be implemented in java side with same classId and factoryId.

Template Parameters

ResultType	that entry processor will return
EntryProcessor	type of entry processor class

Parameters

entryProcessor that will be applied

Definition at line 907 of file imap.h.

                                                                                                                                   {
                 return to_object_map<K, ResultType>(proxy::IMapImpl::execute_on_entries_data(to_data(entry_processor)));
             }

◆ execute_on_entries() [2/2]

template<typename K , typename ResultType , typename EntryProcessor , typename P >

boost::future<std::unordered_map<K, boost::optional<ResultType> > > hazelcast::client::imap::execute_on_entries	(	const EntryProcessor &	entry_processor,
		const P &	predicate
	)

inline

Applies the user defined EntryProcessor to the all entries in the map.

Returns the results mapped by each key in the map.

EntryProcessor should be serializable. Notice that map EntryProcessor runs on the nodes. Because of that, same class should be implemented in java side with same classId and factoryId.

Template Parameters

ResultType	that entry processor will return
EntryProcessor	type of entry processor class
predicate	The filter to apply for selecting the entries at the server side.

Parameters

entryProcessor that will be applied

Definition at line 927 of file imap.h.

                                                                                           {
                 return to_object_map<K, ResultType>(proxy::IMapImpl::execute_on_entries_data(to_data(entry_processor),
                                                                                  to_data(predicate)));
             }

◆ execute_on_key()

template<typename K , typename ResultType , typename EntryProcessor >

boost::future<boost::optional<ResultType> > hazelcast::client::imap::execute_on_key	(	const K &	key,
		const EntryProcessor &	entry_processor
	)

inline

Applies the user defined EntryProcessor to the entry mapped by the key.

Returns the the ResultType which is result of the process() method of EntryProcessor.

EntryProcessor should be serializable. Notice that map EntryProcessor runs on the nodes. Because of that, same class should be implemented in java side with same classId and factoryId.

Template Parameters

EntryProcessor	type of entry processor class
ResultType	that entry processor will return

Parameters

entryProcessor	that will be applied
key	of entry that entryProcessor will be applied on

Returns: result of entry process.

Definition at line 855 of file imap.h.

                                                                                                                        {
                 return to_object<ResultType>(execute_on_key_internal(to_data(key), to_data(entry_processor)));
             }

◆ execute_on_keys()

template<typename K , typename ResultType , typename EntryProcessor >

boost::future<std::unordered_map<K, boost::optional<ResultType> > > hazelcast::client::imap::execute_on_keys	(	const std::unordered_set< K > &	keys,
		const EntryProcessor &	entry_processor
	)

inline

Applies the user defined EntryProcessor to the entries mapped by the collection of keys.

Returns the results mapped by each key in the map.

Notice that map EntryProcessor runs on the nodes. Because of that, same class should be implemented in java side

Template Parameters

ResultType	that entry processor will return
EntryProcessor	type of entry processor class
keys	The keys for which the entry processor will be applied.

Parameters

entryProcessor that will be applied

Definition at line 889 of file imap.h.

                                                                                                     {
                 return to_object_map<K, ResultType>(execute_on_keys_internal<K, EntryProcessor>(keys, entry_processor));
             }

◆ force_unlock()

template<typename K >

boost::future<void> hazelcast::client::imap::force_unlock ( const K & key )

inline

Releases the lock for the specified key regardless of the lock owner.

It always successfully unlocks the key, never blocks and returns immediately.

Parameters

key	key to lock.

Definition at line 437 of file imap.h.

                                                          {
                 return to_void_future(proxy::IMapImpl::force_unlock(to_data(key)));
             }

◆ get()

template<typename K , typename V >

boost::future<boost::optional<V> > hazelcast::client::imap::get ( const K & key )

inline

get the value.

Parameters

key

Returns: value value, if there is no mapping for key then returns boost::none.

Definition at line 97 of file imap.h.

                                                             {
                 return to_object<V>(get_internal(to_data(key)));
             }

◆ get_all()

template<typename K , typename V >

boost::future<std::unordered_map<K, V> > hazelcast::client::imap::get_all ( const std::unordered_set< K > & keys )

inline

Returns the entries for the given keys.

Parameters

keys	keys to get

Returns: map of entries

Definition at line 577 of file imap.h.

                                                                                          {
                 if (keys.empty()) {
                     return boost::make_ready_future(std::unordered_map<K, V>());
                 }
  
                 std::unordered_map<int, std::vector<serialization::pimpl::data>> partition_to_key_data;
                 // group the request per server
                 for (auto &key : keys) {
                     auto key_data = to_data<K>(key);
  
                     auto partitionId = get_partition_id(key_data);
                     partition_to_key_data[partitionId].push_back(std::move(key_data));
                 }
  
                 std::vector<boost::future<EntryVector>> futures;
                 futures.reserve(partition_to_key_data.size());
                 for (auto &entry : partition_to_key_data) {
                     futures.push_back(get_all_internal(entry.first, entry.second));
                 }
  
                 return boost::when_all(futures.begin(), futures.end()).then(boost::launch::sync,
                                                                             [=](boost::future<boost::csbl::vector<boost::future<EntryVector>>> results_data) {
                                                                                 std::unordered_map<K, V> result;
                                                                                 for (auto &entryVectorFuture : results_data.get()) {
                                                                                     for (auto &entry : entryVectorFuture.get()) {
                                                                                         auto val = to_object<V>(
                                                                                                 entry.second);
                                                                                         // it is guaranteed that all values are non-null
                                                                                         assert(val.has_value());
                                                                                         result[to_object<K>(
                                                                                                 entry.first).value()] = std::move(
                                                                                                 val.value());
                                                                                     }
                                                                                 }
                                                                                 return result;
                                                                             });
             }

◆ get_entry_view()

template<typename K , typename V >

boost::future<boost::optional<entry_view<K, V> > > hazelcast::client::imap::get_entry_view ( const K & key )

inline

Returns the EntryView for the specified key.

Parameters

key	key of the entry

Returns: EntryView of the specified key

See also: EntryView

Definition at line 544 of file imap.h.

                                                                                       {
                 return proxy::IMapImpl::get_entry_view_data(to_data(key)).then([=] (boost::future<boost::optional<map::data_entry_view>> f) {
                     auto dataView = f.get();
                     if (!dataView) {
                         return boost::optional<entry_view<K, V>>();
                     }
                     auto v = to_object<V>(dataView->get_value());
                     return boost::make_optional(entry_view<K, V>(key, std::move(v).value(), *std::move(dataView)));
                 });
             }

◆ get_local_map_stats()

monitor::local_map_stats& hazelcast::client::imap::get_local_map_stats ( )

inline

Returns LocalMapStats for this map.

LocalMapStats is 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.

Returns: this map's local statistics.

Definition at line 976 of file imap.h.

                                                           {
                 return local_map_stats_;
             }

◆ is_locked()

template<typename K >

boost::future<bool> hazelcast::client::imap::is_locked ( const K & key )

inline

Checks the lock for the specified key.

If the lock is acquired then returns true, else false.

Parameters

key	key to lock to be checked.

Returns: true if lock is acquired, false otherwise.

Definition at line 347 of file imap.h.

                                                       {
                 return proxy::IMapImpl::is_locked(to_data(key));
             }

◆ key_set() [1/3]

template<typename K >

boost::future<std::vector<K> > hazelcast::client::imap::key_set ( )

inline

Returns a vector clone of the keys contained in this map.

The vector is NOT backed by the map, so changes to the map are NOT reflected in the vector, and vice-versa.

Returns: a vector clone of the keys contained in this map

Definition at line 623 of file imap.h.

                                                 {
                 return to_object_vector<K>(proxy::IMapImpl::key_set_data());
             }

◆ key_set() [2/3]

template<typename K , typename P , class = typename std::enable_if<!std::is_base_of<query::paging_predicate_marker, P>::value>::type>

boost::future<std::vector<K> > hazelcast::client::imap::key_set ( const P & predicate )

inline

Queries the map based on the specified predicate and returns the keys of matching entries.

Specified predicate runs on all members in parallel.

Parameters

predicate query criteria

Returns: result key set of the query

Definition at line 639 of file imap.h.

                                                                   {
                 return to_object_vector<K>(proxy::IMapImpl::key_set_data(to_data(predicate)));
             }

◆ key_set() [3/3]

template<typename K , typename V >

boost::future<std::vector<K> > hazelcast::client::imap::key_set ( query::paging_predicate< K, V > & predicate )

inline

Queries the map based on the specified predicate and returns the keys of matching entries.

Specified predicate runs on all members in parallel.

Parameters

predicate query criteria

Returns: result key set of the query

Definition at line 655 of file imap.h.

                                                                                       {
                 predicate.set_iteration_type(query::iteration_type::KEY);
                 return key_set_for_paging_predicate_data(
                         protocol::codec::holder::paging_predicate_holder::of(predicate, serialization_service_)).then(
                         [=, &predicate](
                                 boost::future<std::pair<std::vector<serialization::pimpl::data>, query::anchor_data_list>> f) {
                     auto result = f.get();
                     predicate.set_anchor_data_list(std::move(result.second));
                     const auto &entries = result.first;
                     std::vector<K> values;
                     values.reserve(entries.size());
                     for(const auto &e : entries) {
                         values.emplace_back(*to_object<K>(e));
                     }
                     return values;
                 });
             }

◆ lock() [1/2]

template<typename K >

boost::future<void> hazelcast::client::imap::lock ( const K & key )

inline

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.

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

key	key to lock.

Definition at line 311 of file imap.h.

                                                  {
                 return to_void_future(lock(key, UNSET));
             }

◆ lock() [2/2]

template<typename K >

boost::future<void> hazelcast::client::imap::lock	(	const K &	key,
		std::chrono::milliseconds	lease_time
	)

inline

Acquires the lock for the specified key 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

key	key to lock.
leaseTime	time to wait before releasing the lock.

Definition at line 334 of file imap.h.

                                                                                    {
                 return to_void_future(proxy::IMapImpl::lock(to_data(key), lease_time));
             }

◆ put() [1/2]

template<typename K , typename V , typename R = V>

boost::future<boost::optional<R> > hazelcast::client::imap::put	(	const K &	key,
		const V &	value
	)

inline

put new entry into map.

Parameters

key
value

Returns: the previous value. if there is no mapping for key, then returns boost::none.

Definition at line 108 of file imap.h.

                                                                             {
                 return put<K, V, R>(key, value, UNSET);
             }

◆ put() [2/2]

template<typename K , typename V , typename R = V>

boost::future<boost::optional<R> > hazelcast::client::imap::put	(	const K &	key,
		const V &	value,
		std::chrono::milliseconds	ttl
	)

inline

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.

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.

Returns: the previous value. if there is no mapping for key, then returns boost::none.

Definition at line 123 of file imap.h.

                                                                                                        {
                 return to_object<R>(put_internal(to_data(key), to_data(value), ttl));
             }

◆ put_all()

template<typename K , typename V >

boost::future<void> hazelcast::client::imap::put_all ( const std::unordered_map< K, V > & entries )

inline

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(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.

Parameters

entries mappings to be stored in this map

Definition at line 943 of file imap.h.

                                                                              {
                 std::unordered_map<int, EntryVector> entryMap;
                 for (auto &entry : entries) {
                     serialization::pimpl::data key_data = to_data(entry.first);
                     int partitionId = get_partition_id(key_data);
                     entryMap[partitionId].push_back(std::make_pair(key_data, to_data(entry.second)));
                 }
  
                 std::vector<boost::future<protocol::ClientMessage>> resultFutures;
                 for (auto &&partitionEntry : entryMap) {
                     auto partitionId = partitionEntry.first;
                     resultFutures.push_back(put_all_internal(partitionId, std::move(partitionEntry.second)));
                 }
                 return boost::when_all(resultFutures.begin(), resultFutures.end()).then(boost::launch::sync,
                                                                                         [](boost::future<boost::csbl::vector<boost::future<protocol::ClientMessage>>> futures) {
                                                                                             for (auto &f : futures.get()) {
                                                                                                 f.get();
                                                                                             }
                                                                                         });
             }

◆ put_if_absent() [1/2]

template<typename K , typename V , typename R = V>

boost::future<boost::optional<V> > hazelcast::client::imap::put_if_absent	(	const K &	key,
		const V &	value
	)

inline

Puts an entry into this map, if the specified key is not already associated with a value.

Parameters

key	key with which the specified value is to be associated
value

Returns: the previous value, if there is no mapping for key then returns boost::none.

Definition at line 226 of file imap.h.

                                                                                       {
                 return put_if_absent(key, value, UNSET);
             }

◆ put_if_absent() [2/2]

template<typename K , typename V , typename R = V>

boost::future<boost::optional<V> > hazelcast::client::imap::put_if_absent	(	const K &	key,
		const V &	value,
		std::chrono::milliseconds	ttl
	)

inline

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

key	key of the entry
value	value of the entry
ttl	maximum time for this entry to stay in the map

Returns: the previous value of the entry, if there is no mapping for key then returns boost::none.

Definition at line 242 of file imap.h.

                                                                                                                  {
                 return to_object<R>(put_if_absent_internal(to_data(key), to_data(value), ttl));
             }

◆ put_transient()

template<typename K , typename V >

boost::future<void> hazelcast::client::imap::put_transient	(	const K &	key,
		const V &	value,
		std::chrono::milliseconds	ttl
	)

inline

Same as put(K, V, int64_t, TimeUnit) but MapStore, if defined, will not be called to store/persist the entry.

If ttl is 0, then the entry lives forever.

Parameters

key	key of the entry
value	value of the entry
ttl	maximum time for this entry to stay in the map in milliseconds, 0 means infinite.

Definition at line 213 of file imap.h.

                                                                                                      {
                 return to_void_future(try_put_transient_internal(to_data(key), to_data(value), ttl));
             }

◆ remove() [1/2]

template<typename K , typename V >

boost::future<boost::optional<V> > hazelcast::client::imap::remove ( const K & key )

inline

remove entry form map

Parameters

key

Returns: the previous value. if there is no mapping for key then returns boost::none.

Definition at line 133 of file imap.h.

                                                                {
                 return to_object<V>(remove_internal(to_data(key)));
             }

◆ remove() [2/2]

template<typename K , typename V >

boost::future<bool> hazelcast::client::imap::remove	(	const K &	key,
		const V &	value
	)

inline

removes entry from map if there is an entry with same key and value.

Parameters

key	key of the entry to be removed
value	value of the entry to be removed

Returns: true if the entry with key and value exists and removed, false otherwise

Definition at line 144 of file imap.h.

                                                                    {
                 return remove_internal(to_data(key), to_data(value));
             }

◆ remove_all()

template<typename P >

boost::future<void> hazelcast::client::imap::remove_all ( const P & predicate )

inline

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.

Parameters

predicate matching entries with this predicate will be removed from this map

Definition at line 158 of file imap.h.

                                                              {
                 return to_void_future(remove_all_internal(to_data<P>(predicate)));
             }

◆ replace() [1/2]

template<typename K , typename V , typename N = V>

boost::future<bool> hazelcast::client::imap::replace	(	const K &	key,
		const V &	old_value,
		const N &	new_value
	)

inline

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

Parameters

key	key with which the specified value is associated
oldValue	value expected to be associated with the specified key
newValue

Returns: true if the value was replaced

Definition at line 254 of file imap.h.

                                                                                             {
                 return replace_if_same_internal(to_data(key), to_data(old_value), to_data(new_value));
             }

◆ replace() [2/2]

template<typename K , typename V , typename R = V>

boost::future<boost::optional<R> > hazelcast::client::imap::replace	(	const K &	key,
		const V &	value
	)

inline

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

Parameters

key	key with which the specified value is associated
value

Returns: the previous value of the entry, if there is no mapping for key then returns boost::none.

Definition at line 266 of file imap.h.

                                                                                 {
                 return to_object<R>(replace_internal(to_data(key), to_data(value)));
             }

◆ set() [1/2]

template<typename K , typename V , typename R = V>

boost::future<void> hazelcast::client::imap::set	(	const K &	key,
		const V &	value
	)

inline

Puts an entry into this map.

Similar to put operation except that set doesn't return the old value which is more efficient.

Parameters

key
value

Definition at line 278 of file imap.h.

                                                                 {
                 return to_void_future(set(key, value, UNSET));
             }

◆ set() [2/2]

template<typename K , typename V >

boost::future<void> hazelcast::client::imap::set	(	const K &	key,
		const V &	value,
		std::chrono::milliseconds	ttl
	)

inline

Puts an entry into this map.

Similar to put operation except that set doesn't return the old value which is more efficient.

Parameters

key	key with which the specified value is associated
value
ttl	maximum time in milliseconds for this entry to stay in the map 0 means infinite.

Definition at line 292 of file imap.h.

                                                                                            {
                 return to_void_future(set_internal(to_data(key), to_data(value), ttl));
             }

◆ submit_to_key()

template<typename K , typename ResultType , typename EntryProcessor >

boost::future<boost::optional<ResultType> > hazelcast::client::imap::submit_to_key	(	const K &	key,
		const EntryProcessor &	entry_processor
	)

inline

Applies the user defined EntryProcessor to the entry mapped by the key.

Returns immediately with a Future representing that task.

Parameters

key	key to be processed
entryProcessor	processor to process the key

Returns: Future from which the result of the operation can be retrieved.

Definition at line 871 of file imap.h.

                                                                                {
                 return to_object<ResultType>(submit_to_key_internal(to_data(key), to_data(entry_processor)));
             }

◆ try_lock() [1/3]

template<typename K >

boost::future<bool> hazelcast::client::imap::try_lock ( const K & key )

inline

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.

Parameters

key	key to lock.

Returns: true if lock is acquired, false otherwise.

Definition at line 361 of file imap.h.

                                                      {
                 return try_lock(key, std::chrono::milliseconds(0));
             }

◆ try_lock() [2/3]

template<typename K >

boost::future<bool> hazelcast::client::imap::try_lock	(	const K &	key,
		std::chrono::milliseconds	timeout
	)

inline

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

Parameters

key	key to lock in this map
timeout	maximum time in milliseconds to wait for the lock

Returns: true if the lock was acquired and false if the waiting time elapsed before the lock was acquired.

Definition at line 382 of file imap.h.

                                                                                     {
                 return proxy::IMapImpl::try_lock(to_data(key), timeout);
             }

◆ try_lock() [3/3]

template<typename K >

boost::future<bool> hazelcast::client::imap::try_lock	(	const K &	key,
		std::chrono::milliseconds	timeout,
		std::chrono::milliseconds	lease_time
	)

inline

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

key	key to lock in this map
timeout	maximum time to wait for the lock
leaseTime	time to wait before releasing the lock.

Returns: true if the lock was acquired and false if the waiting time elapsed before the lock was acquired.

Definition at line 406 of file imap.h.

                                                                                                                       {
                 return proxy::IMapImpl::try_lock(to_data(key), timeout, lease_time);
             }

◆ try_put()

template<typename K , typename V >

boost::future<bool> hazelcast::client::imap::try_put	(	const K &	key,
		const V &	value,
		std::chrono::milliseconds	timeout
	)

inline

Tries to put the given key, value into this map within specified timeout value.

If this method returns false, it means that the caller thread couldn't acquire the lock for the key within timeout duration, thus put operation is not successful.

Parameters

key	key of the entry
value	value of the entry
timeout	maximum time to wait

Returns: true if the put is successful, false otherwise.

Definition at line 199 of file imap.h.

                                                                                                    {
                 return try_put_internal(to_data(key), to_data(value), timeout);
             }

◆ try_remove()

template<typename K >

boost::future<bool> hazelcast::client::imap::try_remove	(	const K &	key,
		std::chrono::milliseconds	timeout
	)

inline

Tries to remove the entry with the given key from this map within specified timeout value.

If the key is already locked by another thread and/or member, then this operation will wait timeout amount for acquiring the lock.

Parameters

key	key of the entry
timeout	maximum time to wait for acquiring the lock for the key

Definition at line 182 of file imap.h.

                                                                                       {
                 return try_remove_internal(to_data(key), timeout);
             }

◆ unlock()

template<typename K >

boost::future<void> hazelcast::client::imap::unlock ( const K & key )

inline

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 now zero then the lock is released. If the current thread is not the holder of this lock then illegal_monitor_state is thrown.

Parameters

key	key to lock.

Exceptions

illegal_monitor_state if the current thread does not hold this lock MTODO

Definition at line 424 of file imap.h.

                                                    {
                 return to_void_future(proxy::IMapImpl::unlock(to_data(key)));
             }

◆ values() [1/3]

template<typename V >

boost::future<std::vector<V> > hazelcast::client::imap::values ( )

inline

Returns a vector clone of the values contained in this map.

The vector is NOT backed by the map, so changes to the map are NOT reflected in the collection, and vice-versa.

Returns: a vector clone of the values contained in this map

Definition at line 681 of file imap.h.

                                                {
                 return to_object_vector<V>(proxy::IMapImpl::values_data());
             }

◆ values() [2/3]

template<typename V , typename P , class = typename std::enable_if<!std::is_base_of<query::paging_predicate_marker, P>::value>::type>

boost::future<std::vector<V> > hazelcast::client::imap::values ( const P & predicate )

inline

Returns a vector clone of the values contained in this map.

The vector is NOT backed by the map, so changes to the map are NOT reflected in the collection, and vice-versa.

Parameters

predicate the criteria for values to match

Returns: a vector clone of the values contained in this map

Definition at line 694 of file imap.h.

                                                                  {
                 return to_object_vector<V>(proxy::IMapImpl::values_data(to_data(predicate)));
             }

◆ values() [3/3]

template<typename K , typename V >

boost::future<std::vector<V> > hazelcast::client::imap::values ( query::paging_predicate< K, V > & predicate )

inline

Returns a vector clone of the values contained in this map.

The vector is NOT backed by the map, so changes to the map are NOT reflected in the collection, and vice-versa.

Parameters

predicate the criteria for values to match

Returns: a vector clone of the values contained in this map

Definition at line 708 of file imap.h.

                                                                                      {
                 predicate.set_iteration_type(query::iteration_type::VALUE);
                 return values_for_paging_predicate_data(
                         protocol::codec::holder::paging_predicate_holder::of(predicate, serialization_service_)).then(
                         [=, &predicate](boost::future<std::pair<std::vector<serialization::pimpl::data>, query::anchor_data_list>> f) {
                     auto result = f.get();
                     predicate.set_anchor_data_list(std::move(result.second));
                     const auto &entries = result.first;
                     std::vector<V> values;
                     values.reserve(entries.size());
                     for(const auto &e : entries) {
                         values.emplace_back(*to_object<V>(e));
                     }
                     return values;
                 });
             }

The documentation for this class was generated from the following files:

hazelcast/include/hazelcast/client/imap.h
hazelcast/src/hazelcast/client/proxy.cpp

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Detailed Description

Member Function Documentation

◆ add_entry_listener() [1/3]

◆ add_entry_listener() [2/3]

◆ add_entry_listener() [3/3]

◆ add_index() [1/2]

◆ add_index() [2/2]

◆ add_interceptor()

◆ contains_key()

◆ contains_value()

◆ delete_entry()

◆ entry_set() [1/3]

◆ entry_set() [2/3]

◆ entry_set() [3/3]

◆ evict()

◆ execute_on_entries() [1/2]

◆ execute_on_entries() [2/2]

◆ execute_on_key()

◆ execute_on_keys()

◆ force_unlock()

◆ get()

◆ get_all()

◆ get_entry_view()

◆ get_local_map_stats()

◆ is_locked()

◆ key_set() [1/3]

◆ key_set() [2/3]

◆ key_set() [3/3]

◆ lock() [1/2]

◆ lock() [2/2]

◆ put() [1/2]

◆ put() [2/2]

◆ put_all()

◆ put_if_absent() [1/2]

◆ put_if_absent() [2/2]

◆ put_transient()

◆ remove() [1/2]

◆ remove() [2/2]

◆ remove_all()

◆ replace() [1/2]

◆ replace() [2/2]

◆ set() [1/2]

◆ set() [2/2]

◆ submit_to_key()

◆ try_lock() [1/3]

◆ try_lock() [2/3]

◆ try_lock() [3/3]

◆ try_put()

◆ try_remove()

◆ unlock()

◆ values() [1/3]

◆ values() [2/3]

◆ values() [3/3]