A specialized distributed map client whose keys can be associated with multiple values. More...

#include <multi_map.h>

Inheritance diagram for hazelcast::client::multi_map:

Public Member Functions
template<typename K , typename V >
boost::future< bool >	put (const K &key, const V &value)
	Stores a key-value pair in the multimap. More...

template<typename K , typename V >
boost::future< std::vector< V > >	get (const K &key)
	Returns the multimap of values associated with the key. More...

template<typename K , typename V >
boost::future< bool >	remove (const K &key, const V &value)
	Removes the given key value pair from the multimap. More...

template<typename K , typename V >
boost::future< std::vector< V > >	remove (const K &key)
	Removes all the entries with the given key. More...

template<typename K >
boost::future< std::vector< K > >	key_set ()
	Returns the set of keys in the multimap. More...

template<typename V >
boost::future< std::vector< V > >	values ()
	Returns the multimap of values in the multimap. More...

template<typename K , typename V >
boost::future< std::vector< std::pair< K, V > > >	entry_set ()
	Returns the set of key-value pairs in the multimap. More...

template<typename K >
boost::future< bool >	contains_key (const K &key)
	Returns whether the multimap contains an entry with the key. More...

template<typename V >
boost::future< bool >	contains_value (const V &value)
	Returns whether the multimap contains an entry with the value. More...

template<typename K , typename V >
boost::future< bool >	contains_entry (const K &key, const V &value)
	Returns whether the multimap contains the given key-value pair. More...

template<typename K >
boost::future< int >	value_count (const K &key)
	Returns number of values matching to given key in the multimap. More...

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

template<typename K >
boost::future< boost::uuids::uuid >	add_entry_listener (entry_listener &&listener, const K &key, bool include_value)
	Adds the specified entry listener for the specified key. 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...

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

Friends
class	spi::ProxyManager

Detailed Description

A specialized distributed map client whose keys can be associated with multiple values.

See also: IMap

Definition at line 30 of file multi_map.h.

Member Function Documentation

◆ add_entry_listener() [1/2]

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

inline

Adds an entry listener for this multimap.

Listener will get notified for all multimap add/remove/update/evict events.

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: returns registration id.

Definition at line 177 of file multi_map.h.

                                                                                                           {
                 return proxy::MultiMapImpl::add_entry_listener(
                         std::unique_ptr<impl::BaseEventHandler>(
                                 new impl::EntryEventHandler<protocol::codec::multimap_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);
             }

◆ add_entry_listener() [2/2]

template<typename K >

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

inline

Adds the specified entry listener for the specified key.

The listener will get notified for all add/remove/update/evict events of the specified key only.

Warning 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	the key to listen
includeValue	`true` if `EntryEvent` should contain the value.

Returns: returns registration id.

Definition at line 202 of file multi_map.h.

                                                                                                                         {
                 return proxy::MultiMapImpl::add_entry_listener(
                         std::shared_ptr<impl::BaseEventHandler>(
                                 new impl::EntryEventHandler<protocol::codec::multimap_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(key));
             }

◆ contains_entry()

template<typename K , typename V >

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

inline

Returns whether the multimap contains the given key-value pair.

Parameters

key	the key whose existence is checked.
value	the value whose existence is checked.

Returns: true if the multimap contains the key-value pair, false otherwise.

Definition at line 147 of file multi_map.h.

                                                                            {
                 return proxy::MultiMapImpl::contains_entry(to_data(key), to_data(value));
             }

◆ contains_key()

template<typename K >

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

inline

Returns whether the multimap contains an entry with the key.

Parameters

key	the key whose existence is checked.

Returns: true if the multimap contains an entry with the key, false otherwise.

Definition at line 124 of file multi_map.h.

                                                          {
                 return proxy::MultiMapImpl::contains_key(to_data(key));
             }

◆ contains_value()

template<typename V >

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

inline

Returns whether the multimap contains an entry with the value.

Parameters

value the value whose existence is checked.

Returns: true if the multimap contains an entry with the value, false otherwise.

Definition at line 135 of file multi_map.h.

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

◆ entry_set()

template<typename K , typename V >

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

inline

Returns the set of key-value pairs in the multimap.

Returns: the set of key-value pairs in the multimap. Returned set might be modifiable but it has no effect on the multimap

Definition at line 113 of file multi_map.h.

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

◆ force_unlock()

template<typename K >

boost::future<void> hazelcast::client::multi_map::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 341 of file multi_map.h.

                                                          {
                 return proxy::MultiMapImpl::force_unlock(to_data(key));
             }

◆ get()

template<typename K , typename V >

boost::future<std::vector<V> > hazelcast::client::multi_map::get ( const K & key )

inline

Returns the multimap of values associated with the key.

Parameters

key	the key whose associated values are to be returned

Returns: the multimap of the values associated with the key.

Definition at line 56 of file multi_map.h.

                                                         {
                 return to_object_vector<V>(proxy::MultiMapImpl::get_data(to_data(key)));
             }

◆ is_locked()

template<typename K >

boost::future<bool> hazelcast::client::multi_map::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 260 of file multi_map.h.

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

◆ key_set()

template<typename K >

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

inline

Returns the set of keys in the multimap.

Returns: the set of keys in the multimap. Returned set might be modifiable but it has no effect on the multimap

Definition at line 91 of file multi_map.h.

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

◆ lock() [1/2]

template<typename K >

boost::future<void> hazelcast::client::multi_map::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 multimap only. Acquired lock is only for the key in this multimap.

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 227 of file multi_map.h.

                                                  {
                 return proxy::MultiMapImpl::lock(to_data(key));
             }

◆ lock() [2/2]

template<typename K >

boost::future<void> hazelcast::client::multi_map::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 248 of file multi_map.h.

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

◆ put()

template<typename K , typename V >

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

inline

Stores a key-value pair in the multimap.

Parameters

key	the key to be stored
value	the value to be stored

Returns: true if size of the multimap is increased, false if the multimap already contains the key-value pair.

Definition at line 45 of file multi_map.h.

                                                                 {
                 return proxy::MultiMapImpl::put(to_data(key), to_data(value));
             }

◆ remove() [1/2]

template<typename K , typename V >

boost::future<std::vector<V> > hazelcast::client::multi_map::remove ( const K & key )

inline

Removes all the entries with the given key.

Parameters

key

Returns: the multimap of removed values associated with the given key. Returned multimap might be modifiable but it has no effect on the multimap

Definition at line 80 of file multi_map.h.

                                                            {
                 return to_object_vector<V>(proxy::MultiMapImpl::remove_data(to_data(key)));
             }

◆ remove() [2/2]

template<typename K , typename V >

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

inline

Removes the given key value pair from the multimap.

Parameters

key
value

Returns: true if the size of the multimap changed after the remove operation, false otherwise.

Definition at line 68 of file multi_map.h.

                                                                    {
                 return proxy::MultiMapImpl::remove(to_data(key), to_data(value));
             }

◆ try_lock() [1/3]

template<typename K >

boost::future<bool> hazelcast::client::multi_map::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 274 of file multi_map.h.

                                                      {
                 return proxy::MultiMapImpl::try_lock(to_data(key));
             }

◆ try_lock() [2/3]

template<typename K >

boost::future<bool> hazelcast::client::multi_map::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	to be locked.
timeout	the maximum time 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 295 of file multi_map.h.

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

◆ try_lock() [3/3]

template<typename K >

boost::future<bool> hazelcast::client::multi_map::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	to be locked.
timeout	the 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 318 of file multi_map.h.

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

◆ unlock()

template<typename K >

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

inline

Releases the lock for the specified key.

It never blocks and returns immediately.

Parameters

key	key to lock.

Definition at line 330 of file multi_map.h.

                                                    {
                 return proxy::MultiMapImpl::unlock(to_data(key));
             }

◆ value_count()

template<typename K >

boost::future<int> hazelcast::client::multi_map::value_count ( const K & key )

inline

Returns number of values matching to given key in the multimap.

Parameters

key	the key whose values count are to be returned

Returns: number of values matching to given key in the multimap.

Definition at line 159 of file multi_map.h.

                                                        {
                 return proxy::MultiMapImpl::value_count(to_data(key));
             }

◆ values()

template<typename V >

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

inline

Returns the multimap of values in the multimap.

Returns: the multimap of values in the multimap. Returned multimap might be modifiable but it has no effect on the multimap

Definition at line 102 of file multi_map.h.

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

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

hazelcast/include/hazelcast/client/multi_map.h

Public Member Functions

Static Public Attributes

Friends

Detailed Description

Member Function Documentation

◆ add_entry_listener() [1/2]

◆ add_entry_listener() [2/2]

◆ contains_entry()

◆ contains_key()

◆ contains_value()

◆ entry_set()

◆ force_unlock()

◆ get()

◆ is_locked()

◆ key_set()

◆ lock() [1/2]

◆ lock() [2/2]

◆ put()

◆ remove() [1/2]

◆ remove() [2/2]

◆ try_lock() [1/3]

◆ try_lock() [2/3]

◆ try_lock() [3/3]

◆ unlock()

◆ value_count()

◆ values()