Concurrent, distributed, client implementation of list. More...

#include <ilist.h>

Inheritance diagram for hazelcast::client::ilist:

Public Member Functions
boost::future< boost::uuids::uuid >	add_item_listener (item_listener &&listener, bool include_value)
	Warning 1: If listener should do a time consuming operation, off-load the operation to another thread. More...

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

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

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

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

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 >	add_all (int32_t index, const std::vector< E > &elements)
	Adds elements in vector to the list with given order. More...

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 list that are not available in given "elements" vector. More...

template<typename E >
boost::future< boost::optional< E > >	get (int32_t index)
	You can check if element is available by. More...

template<typename E , typename R = E>
boost::future< boost::optional< R > >	set (int32_t index, const E &element)
	Replaced the element in the given index. More...

template<typename E >
boost::future< void >	add (int32_t index, const E &element)
	Adds the element to the given index. More...

template<typename E >
boost::future< boost::optional< E > >	remove (int32_t index)

template<typename E >
boost::future< int >	index_of (const E &element)

template<typename E >
boost::future< int32_t >	last_index_of (const E &element)

template<typename E >
boost::future< std::vector< E > >	sub_list (int32_t from_index, int32_t to_index)

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

Friends
class	spi::ProxyManager

Detailed Description

Concurrent, distributed, client implementation of list.

Definition at line 28 of file ilist.h.

Member Function Documentation

◆ add() [1/2]

template<typename E >

boost::future<bool> hazelcast::client::ilist::add ( const E & element )

inline

Parameters

element

Returns: true if element is added successfully.

Definition at line 80 of file ilist.h.

                                                     {
                 return proxy::IListImpl::add(to_data(element));
             }

◆ add() [2/2]

template<typename E >

boost::future<void> hazelcast::client::ilist::add	(	int32_t	index,
		const E &	element
	)

inline

Adds the element to the given index.

Shifts others to the right.

Parameters

index	insert position
element	to be inserted.

Exceptions

Iclass_cast	if the type of the specified element is incompatible with the server side.
index_out_of_bounds	if the index is out of range.

Definition at line 190 of file ilist.h.

                                                                    {
                 return proxy::IListImpl::add(index, to_data(element));
             }

◆ add_all() [1/2]

template<typename E >

boost::future<bool> hazelcast::client::ilist::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 list.

Definition at line 110 of file ilist.h.

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

◆ add_all() [2/2]

template<typename E >

boost::future<bool> hazelcast::client::ilist::add_all	(	int32_t	index,
		const std::vector< E > &	elements
	)

inline

Adds elements in vector to the list with given order.

Starts adding elements from given index, and shifts others to the right.

Parameters

index	start point of inserting given elements
elements	vector of elements that will be added to list

Returns: true if list elements are added.

Exceptions

index_out_of_bounds if the index is out of range.

Definition at line 125 of file ilist.h.

                                                                                    {
                 return proxy::IListImpl::add_all_data(index, to_data_collection(elements));
             }

◆ add_item_listener()

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

inline

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	that will be added
includeValue	bool value representing value should be included in ItemEvent or not.

Returns: registrationId that can be used to remove item listener

Definition at line 44 of file ilist.h.

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

◆ contains()

template<typename E >

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

inline

Parameters

element

Returns: true if list contains element

Definition at line 61 of file ilist.h.

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

◆ contains_all()

template<typename E >

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

inline

Parameters

elements std::vector<E>

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

Definition at line 100 of file ilist.h.

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

◆ get()

template<typename E >

boost::future<boost::optional<E> > hazelcast::client::ilist::get ( int32_t index )

inline

You can check if element is available by.

 auto e = list.get(5).get();
 if(e.has_value())
     //......;

Parameters

index

Returns: element in given index. If not available returns empty constructed shared_ptr.

Exceptions

index_out_of_bounds if the index is out of range.

Definition at line 163 of file ilist.h.

                                                              {
                 return to_object<E>(proxy::IListImpl::get_data(index));
             }

◆ index_of()

template<typename E >

boost::future<int> hazelcast::client::ilist::index_of ( const E & element )

inline

Parameters

element that will be searched

Returns: index of first occurrence of given element in the list. Returns -1 if element is not in the list.

Definition at line 213 of file ilist.h.

                                                         {
                 return proxy::IListImpl::index_of(to_data(element));
             }

◆ last_index_of()

template<typename E >

boost::future<int32_t> hazelcast::client::ilist::last_index_of ( const E & element )

inline

Parameters

element that will be searched

Returns: index of last occurrence of given element in the list. Returns -1 if element is not in the list.

Definition at line 223 of file ilist.h.

                                                                  {
                 return proxy::IListImpl::last_index_of(to_data(element));
             }

◆ remove() [1/2]

template<typename E >

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

inline

Parameters

element

Returns: true if element is removed successfully.

Definition at line 90 of file ilist.h.

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

◆ remove() [2/2]

template<typename E >

boost::future<boost::optional<E> > hazelcast::client::ilist::remove ( int32_t index )

inline

Parameters

index

Returns: element in given index. If not available returns empty constructed shared_ptr.

See also: get

Exceptions

index_out_of_bounds if the index is out of range.

Definition at line 202 of file ilist.h.

                                                                 {
                 return to_object<E>(proxy::IListImpl::remove_data(index));
             }

◆ remove_all()

template<typename E >

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

inline

Parameters

elements std::vector<E>

Returns: true if all elements are removed successfully.

Definition at line 135 of file ilist.h.

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

◆ retain_all()

template<typename E >

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

inline

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

Parameters

elements std::vector<E>

Returns: true if operation is successful.

Definition at line 146 of file ilist.h.

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

◆ set()

template<typename E , typename R = E>

boost::future<boost::optional<R> > hazelcast::client::ilist::set	(	int32_t	index,
		const E &	element
	)

inline

Replaced the element in the given index.

And returns element if there were entry before inserting.

Parameters

index	insert position
element	to be inserted.

Returns: oldElement in given index.

Exceptions

Iclass_cast	if the type of the specified element is incompatible with the server side.
index_out_of_bounds	if the index is out of range.

Definition at line 177 of file ilist.h.

                                                                                {
                 return to_object<R>(proxy::IListImpl::set_data(index, to_data(element)));
             }

◆ sub_list()

template<typename E >

boost::future<std::vector<E> > hazelcast::client::ilist::sub_list	(	int32_t	from_index,
		int32_t	to_index
	)

inline

Returns: the sublist as vector between given indexes.

Exceptions

index_out_of_bounds if the index is out of range.

Definition at line 233 of file ilist.h.

                                                                                      {
                 return to_object_vector<E>(proxy::IListImpl::sub_list_data(from_index, to_index));
             }

◆ to_array()

template<typename E >

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

inline

Returns: all elements as std::vector

Definition at line 70 of file ilist.h.

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

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

hazelcast/include/hazelcast/client/ilist.h

Public Member Functions

Static Public Attributes

Friends

Detailed Description

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ add_all() [1/2]

◆ add_all() [2/2]

◆ add_item_listener()

◆ contains()

◆ contains_all()

◆ get()

◆ index_of()

◆ last_index_of()

◆ remove() [1/2]

◆ remove() [2/2]

◆ remove_all()

◆ retain_all()

◆ set()

◆ sub_list()

◆ to_array()