#include <sp_heter_queue.h>

Public Member Functions
	consume_operation () noexcept=default

	consume_operation (const consume_operation &)=delete

consume_operation &	operator= (const consume_operation &)=delete

	consume_operation (consume_operation &&i_source) noexcept=default

consume_operation &	operator= (consume_operation &&i_source) noexcept=default

	~consume_operation ()

bool	empty () const noexcept

	operator bool () const noexcept

sp_heter_queue *	queue () const noexcept

void	commit () noexcept

void	commit_nodestroy () noexcept

void	cancel () noexcept

const RUNTIME_TYPE &	complete_type () const noexcept

void *	unaligned_element_ptr () const noexcept

void *	element_ptr () const noexcept

template<typename COMPLETE_ELEMENT_TYPE >
COMPLETE_ELEMENT_TYPE &	element () const noexcept

	consume_operation (PrivateType, sp_heter_queue *i_queue) noexcept

bool	start_consume_impl (PrivateType, sp_heter_queue *i_queue)

Friends
void	swap (consume_operation &i_first, consume_operation &i_second) noexcept

Detailed Description

template<typename RUNTIME_TYPE = runtime_type<>, typename ALLOCATOR_TYPE = default_allocator, concurrency_cardinality PROD_CARDINALITY = concurrency_multiple, concurrency_cardinality CONSUMER_CARDINALITY = concurrency_multiple, typename BUSY_WAIT_FUNC = default_busy_wait>
class density::sp_heter_queue< RUNTIME_TYPE, ALLOCATOR_TYPE, PROD_CARDINALITY, CONSUMER_CARDINALITY, BUSY_WAIT_FUNC >::consume_operation

Move-only class that can be bound to a consume operation, otherwise it's empty.

Consume functions on sp_heter_queue return a non-empty consume_operation that can be used to inspect or alter the element while it is not observable in the queue, and commit or cancel the consume.

A consume_operation is empty when:

it is default constructed
it is used as source for a move construction or move assignment
after a cancel or a commit

Calling commit, commit_nodestroy, cancel, element_ptr, unaligned_element_ptr, element or complete_type on an empty consume_operation triggers undefined behavior.

Constructor & Destructor Documentation

consume_operation ( )

defaultnoexcept

Constructs an empty consume_operation

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        typename SpQueue::consume_operation consume;
        assert(consume.empty());

consume_operation ( const consume_operation & )

delete

Copy construction is not allowed

    using SpQueue =
      sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
    static_assert(!std::is_copy_constructible<typename SpQueue::consume_operation>::value, "");

consume_operation ( consume_operation && i_source )

defaultnoexcept

Move constructor. The source is left in a valid but indeterminate state.

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        queue.push(42);
        auto consume = queue.try_start_consume();
        auto consume_1 = std::move(consume);
        assert(consume.empty() && !consume_1.empty());
        consume_1.commit();

~consume_operation ( )

inline

Destructor: cancel the operation (if any).

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        queue.push(42);
        // this consumed is started and destroyed before being committed, so it has no observable effects
        queue.try_start_consume();

Member Function Documentation

consume_operation& operator= ( const consume_operation & )

delete

Copy assignment is not allowed

static_assert(!std::is_copy_assignable<typename SpQueue::consume_operation>::value, "");

consume_operation& operator= ( consume_operation && i_source )

defaultnoexcept

Move assignment. The source is left in a valid but indeterminate state.

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        queue.push(42);
        queue.push(43);
        auto consume = queue.try_start_consume();
        typename SpQueue::consume_operation consume_1;
        consume_1 = std::move(consume);
        assert(consume.empty() && !consume_1.empty());
        consume_1.commit();

bool empty ( ) const

inlinenoexcept

Returns true whether this object does not hold the state of an operation.

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        queue.push(42);
        typename SpQueue::consume_operation consume;
        assert(consume.empty());
        consume = queue.try_start_consume();
        assert(!consume.empty());

operator bool ( ) const

inlineexplicitnoexcept

Returns true whether this object does not hold the state of an operation. Same to !consume_operation::empty.

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        typename SpQueue::consume_operation consume;
        assert(consume.empty() == !consume);
        consume = queue.try_start_consume();
        assert(consume.empty() == !consume);

sp_heter_queue* queue ( ) const

inlinenoexcept

Returns a pointer to the target queue if a transaction is bound, otherwise returns nullptr

void commit ( )

inlinenoexcept

Destroys the element, making the consume irreversible. This comnsume_operation becomes empty.

Precondition

The behavior is undefined if either:

this object is empty

Complexity: Constant.
Effects on iterators: no iterator is invalidated
Throws: Nothing.

void commit_nodestroy ( )

inlinenoexcept

Destroys the element, making the consume irreversible. This comnsume_operation becomes empty. The caller should destroy the element before calling this function. This object becomes empty.

Precondition

The behavior is undefined if either:

this object is empty

Complexity: Constant.
Effects on iterators: no iterator is invalidated
Throws: Nothing.

Note: this function may be used to combine a feature of the runtime type on the element with the destruction of the element. For example a function queue may improve the performances using a feature like invoke_destroy to do both the function call and the destruction of the capture in a single call, making a single pseudo v-call instead of two.

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        queue.template emplace<std::string>("abc");
        typename SpQueue::consume_operation consume = queue.try_start_consume();
        consume.complete_type().destroy(consume.element_ptr());
        // the string has already been destroyed. Calling commit would trigger an undefined behavior
        consume.commit_nodestroy();

void cancel ( )

inlinenoexcept

Cancel the operation. This consume_operation becomes empty.

Precondition

The behavior is undefined if either:

this object is empty

Complexity: Constant.
Effects on iterators: no iterator is invalidated
Throws: Nothing.

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        queue.push(42);
        typename SpQueue::consume_operation consume = queue.try_start_consume();
        consume.cancel();
        // there is still a 42 in the queue
        assert(queue.try_start_consume().template element<int>() == 42);

const RUNTIME_TYPE& complete_type ( ) const

inlinenoexcept

Returns the type of the element being consumed.

Precondition: The behavior is undefined if this consume_operation is empty.

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        queue.push(42);
        typename SpQueue::consume_operation consume = queue.try_start_consume();
        assert(consume.complete_type().template is<int>());
        assert(
          consume.complete_type() == runtime_type<>::make<int>()); // same to the previous assert
        assert(consume.template element<int>() == 42);
        consume.commit();

void* unaligned_element_ptr ( ) const

inlinenoexcept

Returns a pointer that, if properly aligned to the alignment of the element type, points to the element. The returned address is guaranteed to be aligned to min_alignment

Precondition: The behavior is undefined if this consume_operation is empty, that is it has been used as source for a move operation.

Postcondition: The returned address is aligned at least on sp_heter_queue::min_alignment.

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        queue.push(42);
        typename SpQueue::consume_operation consume        = queue.try_start_consume();
        bool const                          is_overaligned = alignof(int) > SpQueue::min_alignment;
        void * const                        unaligned_ptr  = consume.unaligned_element_ptr();
        int *                               element_ptr;
        if (is_overaligned)
        {
            element_ptr = static_cast<int *>(address_upper_align(unaligned_ptr, alignof(int)));
        }
        else
        {
            assert(unaligned_ptr == consume.element_ptr());
            element_ptr = static_cast<int *>(unaligned_ptr);
        }
        assert(address_is_aligned(element_ptr, alignof(int)));
        std::cout << "An int: " << *element_ptr << std::endl;
        consume.commit();

void* element_ptr ( ) const

inlinenoexcept

Returns a pointer to the element being consumed.

This call is equivalent to: address_upper_align(unaligned_element_ptr(), complete_type().alignment());

Precondition: The behavior is undefined if this consume_operation is empty, that is it has been committed or used as source for a move operation.

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        queue.push(42);
        typename SpQueue::consume_operation consume = queue.try_start_consume();
        ++*static_cast<int *>(consume.element_ptr());
        assert(consume.template element<int>() == 43);
        consume.commit();

COMPLETE_ELEMENT_TYPE& element ( ) const

inlinenoexcept

Returns a reference to the element being consumed.

Precondition: The behavior is undefined if this consume_operation is empty, that is it has been committed or used as source for a move operation.; The behavior is undefined if COMPLETE_ELEMENT_TYPE is not exactly the complete type of the element.

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        queue.push(42);
        typename SpQueue::consume_operation consume = queue.try_start_consume();
        assert(consume.complete_type().template is<int>());
        std::cout << "An int: " << consume.template element<int>() << std::endl;
        /* std::cout << "An float: " << consume.element<float>() << std::endl; this would
                trigger an undefined behavior, because the element is not a float */
        consume.commit();

Friends And Related Function Documentation

void swap	(	consume_operation &	i_first,
		consume_operation &	i_second
	)

friend

Swaps two instances of consume_operation.

        using SpQueue =
          sp_heter_queue<runtime_type<>, default_allocator, PROD_CARDINALITY, CONSUMER_CARDINALITY>;
        SpQueue queue;
        queue.push(42);
        typename SpQueue::consume_operation consume_1 = queue.try_start_consume();
        typename SpQueue::consume_operation consume_2;
        {
            using namespace std;
            swap(consume_1, consume_2);
        }
        assert(consume_2.complete_type().template is<int>());
        assert(
          consume_2.complete_type() == runtime_type<>::make<int>()); // same to the previous assert
        assert(consume_2.template element<int>() == 42);
        consume_2.commit();
        assert(queue.empty());

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

C:/projects/density/include/density/sp_heter_queue.h

Public Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation