cppext::detail::shared_state< void > Struct Reference

Specialisation of the shared_state class for the type void. More...

#include <future_queue.hpp>

Inheritance diagram for cppext::detail::shared_state< void >:

Collaboration diagram for cppext::detail::shared_state< void >:

Public Member Functions
	shared_state (size_t length)
Public Member Functions inherited from cppext::detail::shared_state_base
	shared_state_base (size_t length)
virtual	~shared_state_base ()
	Destructor must be virtual so the destructor of the derived class gets called.
void	free ()
	Decreaces the reference count and calls "delete this" where appropriate.

Additional Inherited Members
Public Attributes inherited from cppext::detail::shared_state_base
std::atomic< size_t >	reference_count {0}
	reference count.
std::atomic< size_t >	when_any_index
	index used in wait_any to identify the queue
size_t	nBuffers
	the number of buffers we have allocated
std::vector< semaphore >	semaphores
	vector of semaphores corresponding to the buffers which allows the receiver to wait for new data
std::vector< std::exception_ptr >	exceptions
	vector of exception pointers, can be set instead of values through push_exception()
std::atomic< size_t >	writeIndex
	index of the element which will be next written
std::atomic< size_t >	readIndexMax
	maximum index which the receiver is currently allowed to read (after checking it semaphore).
std::atomic< size_t >	readIndex
	index of the element which will be next read
bool	hasFrontOwnership
	Flag if the receiver has already ownership over the front element.
bool	is_continuation_deferred {false}
	Flag whether this future_queue is a deferred-type continuation of another.
std::function< void(void)>	continuation_process_deferred
	Function to be called for deferred evaulation of a single value if this queue is a continuation.
std::function< void(void)>	continuation_process_deferred_wait
	Function to be called for deferred evaulation of a single value if this queue is a continuation.
bool	is_continuation_async {false}
	Flag whether this future_queue is a async-type continuation of another.
std::thread	continuation_process_async
	Thread handling async-type continuations.
std::atomic< bool >	continuation_process_async_terminated {false}
	Flag whether the internal thread continuation_process_async has been terminated.
bool	is_continuation_when_all {false}
	Flag whether this future_queue is a when_all-type continuation (of many other)
future_queue_base	continuation_origin
	If either is_continuation_deferred or is_continuation_async is true, this will point to the original queue of which *this is the continuation.
std::atomic< when_any_notification_info >	when_any_notification {when_any_notification_info()}

Detailed Description

Specialisation of the shared_state class for the type void.

Definition at line 449 of file future_queue.hpp.

Constructor & Destructor Documentation

shared_state()

cppext::detail::shared_state< void >::shared_state ( size_t  length )

inline

Definition at line 450 of file future_queue.hpp.

---

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

• /scratch/dragon/sources/ChimeraTK-cppext/include/future_queue.hpp