Concurrent, blocking, distributed, observable, client queue. More...

#include <iqueue.h>

Inheritance diagram for hazelcast::client::iqueue:

Public Member Functions
boost::future< boost::uuids::uuid >	add_item_listener (item_listener &&listener, bool include_value)
	Adds an item listener for this collection. More...

template<typename E >
boost::future< bool >	offer (const E &element)
	Inserts the specified element into this queue. More...

template<typename E >
boost::future< void >	put (const E &element)
	Puts the element into queue. More...

template<typename E >
boost::future< bool >	offer (const E &element, std::chrono::milliseconds timeout)
	Inserts the specified element into this queue. More...

template<typename E >
boost::future< boost::optional< E > >	take ()

template<typename E >
boost::future< boost::optional< E > >	poll (std::chrono::milliseconds timeout)

template<typename E >
boost::future< bool >	remove (const E &element)

template<typename E >
boost::future< bool >	contains (const E &element)

template<typename E >
boost::future< size_t >	drain_to (std::vector< E > &elements)
	Note that elements will be pushed_back to vector. More...

template<typename E >
boost::future< size_t >	drain_to (std::vector< E > &elements, size_t max_elements)
	Note that elements will be pushed_back to vector. More...

template<typename E >
boost::future< boost::optional< E > >	poll ()
	Returns immediately without waiting. More...

template<typename E >
boost::future< boost::optional< E > >	peek ()
	Returns immediately without waiting. More...

template<typename E >
boost::future< std::vector< E > >	to_array ()

template<typename E >
boost::future< bool >	contains_all (const std::vector< E > &elements)

template<typename E >
boost::future< bool >	add_all (const std::vector< E > &elements)

template<typename E >
boost::future< bool >	remove_all (const std::vector< E > &elements)

template<typename E >
boost::future< bool >	retain_all (const std::vector< E > &elements)
	Removes the elements from this queue that are not available in given "elements" vector. More...

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

Friends
class	spi::ProxyManager

Detailed Description

Concurrent, blocking, distributed, observable, client queue.

Definition at line 29 of file iqueue.h.

Member Function Documentation

◆ add_all()

template<typename E >

boost::future<bool> hazelcast::client::iqueue::add_all ( const std::vector< E > & elements )

inline

Parameters

elements std::vector<E>

Returns: true if all elements given in vector can be added to queue.

Definition at line 208 of file iqueue.h.

                                                                     {
                 return proxy::IQueueImpl::add_all_data(to_data_collection(elements));
             }

◆ add_item_listener()

boost::future<boost::uuids::uuid> hazelcast::client::iqueue::add_item_listener	(	item_listener &&	listener,
		bool	include_value
	)

inline

Adds an item listener for this collection.

Listener will get notified for all collection add/remove 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	item listener
includeValue	`true` updated item should be passed to the item listener, `false` otherwise.

Returns: returns registration id.

Definition at line 48 of file iqueue.h.

                                                                                                         {
                 std::unique_ptr<impl::item_event_handler<protocol::codec::queue_addlistener_handler>> itemEventHandler(
                         new impl::item_event_handler<protocol::codec::queue_addlistener_handler>(
                                 get_name(), get_context().get_client_cluster_service(),
                                 get_context().get_serialization_service(),
                                 std::move(listener),
                                 include_value));
  
                 return proxy::IQueueImpl::add_item_listener(std::move(itemEventHandler), include_value);
             }

◆ contains()

template<typename E >

boost::future<bool> hazelcast::client::iqueue::contains ( const E & element )

inline

Parameters

element to be checked.

Returns: true if queue contains the element.

Definition at line 129 of file iqueue.h.

                                                          {
                 return proxy::IQueueImpl::contains(to_data(element));
             }

◆ contains_all()

template<typename E >

boost::future<bool> hazelcast::client::iqueue::contains_all ( const std::vector< E > & elements )

inline

Parameters

elements std::vector<E>

Returns: true if this queue contains all elements given in vector.

Definition at line 198 of file iqueue.h.

                                                                          {
                 return proxy::IQueueImpl::contains_all_data(to_data_collection(elements));
             }

◆ drain_to() [1/2]

template<typename E >

boost::future<size_t> hazelcast::client::iqueue::drain_to ( std::vector< E > & elements )

inline

Note that elements will be pushed_back to vector.

Parameters

elements the vector that elements will be drained to.

Returns: number of elements drained.

Definition at line 140 of file iqueue.h.

                                                                  {
                 return proxy::IQueueImpl::drain_to_data().then(boost::launch::sync,
                                                                [&](boost::future<std::vector<serialization::pimpl::data>> f) {
                                                                    return drain_items(std::move(f), elements);
                                                                });
             }

◆ drain_to() [2/2]

template<typename E >

boost::future<size_t> hazelcast::client::iqueue::drain_to	(	std::vector< E > &	elements,
		size_t	max_elements
	)

inline

Note that elements will be pushed_back to vector.

Parameters

maxElements	upper limit to be filled to vector.
elements	vector that elements will be drained to.

Returns: number of elements drained.

Definition at line 155 of file iqueue.h.

                                                                                       {
                 return proxy::IQueueImpl::drain_to_data(max_elements).then(boost::launch::sync,
                                                                            [&](boost::future<std::vector<serialization::pimpl::data>> f) {
                                                                                return drain_items(std::move(f),
                                                                                                   elements);
                                                                            });
             }

◆ offer() [1/2]

template<typename E >

boost::future<bool> hazelcast::client::iqueue::offer ( const E & element )

inline

Inserts the specified element into this queue.

Parameters

element to add

Returns: true if the element was added to this queue, else false

Definition at line 67 of file iqueue.h.

                                                       {
                 return offer(element, std::chrono::milliseconds(0));
             }

◆ offer() [2/2]

template<typename E >

boost::future<bool> hazelcast::client::iqueue::offer	(	const E &	element,
		std::chrono::milliseconds	timeout
	)

inline

Inserts the specified element into this queue.

If queue is full waits for space to became available for specified time.

Parameters

element	to add
timeout	how long to wait before giving up

Returns: true if successful, or false if the specified waiting time elapses before space is available

Definition at line 90 of file iqueue.h.

                                                                                      {
                 return proxy::IQueueImpl::offer(to_data(element), timeout);
             }

◆ peek()

template<typename E >

boost::future<boost::optional<E> > hazelcast::client::iqueue::peek ( )

inline

Returns immediately without waiting.

Returns: head of queue without removing it. If not available returns empty constructed shared_ptr.

Definition at line 179 of file iqueue.h.

                                                  {
                 return to_object<E>(proxy::IQueueImpl::peek_data());
             }

◆ poll() [1/2]

template<typename E >

boost::future<boost::optional<E> > hazelcast::client::iqueue::poll ( )

inline

Returns immediately without waiting.

Returns: removes head of the queue and returns it to user . If not available returns empty constructed shared_ptr.

Definition at line 169 of file iqueue.h.

                                                  {
                 return poll<E>(std::chrono::milliseconds(0));
             }

◆ poll() [2/2]

template<typename E >

boost::future<boost::optional<E> > hazelcast::client::iqueue::poll ( std::chrono::milliseconds timeout )

inline

Parameters

timeout time to wait if item is not available.

Returns: the head of the queue. If queue is empty waits for specified time.

Definition at line 109 of file iqueue.h.

                                                                               {
                 return to_object<E>(proxy::IQueueImpl::poll_data(timeout));
             }

◆ put()

template<typename E >

boost::future<void> hazelcast::client::iqueue::put ( const E & element )

inline

Puts the element into queue.

If queue is full waits for space to became available.

Definition at line 76 of file iqueue.h.

                                                     {
                 return proxy::IQueueImpl::put(to_data(element));
             }

◆ remove()

template<typename E >

boost::future<bool> hazelcast::client::iqueue::remove ( const E & element )

inline

Parameters

element to be removed.

Returns: true if element removed successfully.

Definition at line 119 of file iqueue.h.

                                                        {
                 return proxy::IQueueImpl::remove(to_data(element));
             }

◆ remove_all()

template<typename E >

boost::future<bool> hazelcast::client::iqueue::remove_all ( const std::vector< E > & elements )

inline

Parameters

elements std::vector<E>

Returns: true if all elements are removed successfully.

Definition at line 218 of file iqueue.h.

                                                                        {
                 return proxy::IQueueImpl::remove_all_data(to_data_collection(elements));
             }

◆ retain_all()

template<typename E >

boost::future<bool> hazelcast::client::iqueue::retain_all ( const std::vector< E > & elements )

inline

Removes the elements from this queue that are not available in given "elements" vector.

Parameters

elements std::vector<E>

Returns: true if operation is successful.

Definition at line 229 of file iqueue.h.

                                                                        {
                 return proxy::IQueueImpl::retain_all_data(to_data_collection(elements));
             }

◆ take()

template<typename E >

boost::future<boost::optional<E> > hazelcast::client::iqueue::take ( )

inline

Returns: the head of the queue. If queue is empty waits for an item to be added.

Definition at line 99 of file iqueue.h.

                                                  {
                 return to_object<E>(proxy::IQueueImpl::take_data());
             }

◆ to_array()

template<typename E >

boost::future<std::vector<E> > hazelcast::client::iqueue::to_array ( )

inline

Returns: all elements as std::vector

Definition at line 188 of file iqueue.h.

                                                  {
                 return to_object_vector<E>(proxy::IQueueImpl::to_array_data());
             }

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

hazelcast/include/hazelcast/client/iqueue.h

Public Member Functions

Static Public Attributes

Friends

Detailed Description

Member Function Documentation

◆ add_all()

◆ add_item_listener()

◆ contains()

◆ contains_all()

◆ drain_to() [1/2]

◆ drain_to() [2/2]

◆ offer() [1/2]

◆ offer() [2/2]

◆ peek()

◆ poll() [1/2]

◆ poll() [2/2]

◆ put()

◆ remove()

◆ remove_all()

◆ retain_all()

◆ take()

◆ to_array()