Hazelcast C++ Client
Hazelcast C++ Client Library
hazelcast::client::iqueue Class Reference

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
elementsstd::vector<E>
Returns
true if all elements given in vector can be added to queue.

Definition at line 208 of file iqueue.h.

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

◆ 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
listeneritem listener
includeValuetrue updated item should be passed to the item listener, false otherwise.
Returns
returns registration id.

Definition at line 48 of file iqueue.h.

48  {
49  std::unique_ptr<impl::item_event_handler<protocol::codec::queue_addlistener_handler>> itemEventHandler(
50  new impl::item_event_handler<protocol::codec::queue_addlistener_handler>(
51  get_name(), get_context().get_client_cluster_service(),
52  get_context().get_serialization_service(),
53  std::move(listener),
54  include_value));
55 
56  return proxy::IQueueImpl::add_item_listener(std::move(itemEventHandler), include_value);
57  }

◆ contains()

template<typename E >
boost::future<bool> hazelcast::client::iqueue::contains ( const E &  element)
inline
Parameters
elementto be checked.
Returns
true if queue contains the element.

Definition at line 129 of file iqueue.h.

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

◆ contains_all()

template<typename E >
boost::future<bool> hazelcast::client::iqueue::contains_all ( const std::vector< E > &  elements)
inline
Parameters
elementsstd::vector<E>
Returns
true if this queue contains all elements given in vector.

Definition at line 198 of file iqueue.h.

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

◆ 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
elementsthe vector that elements will be drained to.
Returns
number of elements drained.

Definition at line 140 of file iqueue.h.

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

◆ 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
maxElementsupper limit to be filled to vector.
elementsvector that elements will be drained to.
Returns
number of elements drained.

Definition at line 155 of file iqueue.h.

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

◆ 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
elementto add
Returns
true if the element was added to this queue, else false

Definition at line 67 of file iqueue.h.

67  {
68  return offer(element, std::chrono::milliseconds(0));
69  }
boost::future< bool > offer(const E &element)
Inserts the specified element into this queue.
Definition: iqueue.h:67

◆ 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
elementto add
timeouthow 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.

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

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

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

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

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

◆ poll() [2/2]

template<typename E >
boost::future<boost::optional<E> > hazelcast::client::iqueue::poll ( std::chrono::milliseconds  timeout)
inline
Parameters
timeouttime 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.

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

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

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

◆ remove()

template<typename E >
boost::future<bool> hazelcast::client::iqueue::remove ( const E &  element)
inline
Parameters
elementto be removed.
Returns
true if element removed successfully.

Definition at line 119 of file iqueue.h.

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

◆ remove_all()

template<typename E >
boost::future<bool> hazelcast::client::iqueue::remove_all ( const std::vector< E > &  elements)
inline
Parameters
elementsstd::vector<E>
Returns
true if all elements are removed successfully.

Definition at line 218 of file iqueue.h.

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

◆ 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
elementsstd::vector<E>
Returns
true if operation is successful.

Definition at line 229 of file iqueue.h.

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

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

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

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

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

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