Skip to main content

chronon::sender::SingleThreadMessageQueue

More...

#include <MessageQueue.hpp>

Public Functions​

Name
std::optional< T >tryPop(uint64_t current_cycle)
size_tsize() const
voidsetCapacity(size_t capacity)
boolpush(T data, uint64_t arrive_cycle)
voidpopAllInto(std::vector< T > & out, uint64_t current_cycle)
std::vector< T >popAll(uint64_t current_cycle)
SingleThreadMessageQueue &operator=(const SingleThreadMessageQueue & ) =delete
SingleThreadMessageQueue &operator=(SingleThreadMessageQueue && ) =default
std::optional< uint64_t >minArrivalCycle() const
Earliest arrival cycle of pending messages.
boolhasReady(uint64_t current_cycle) const
boolfull() const
boolempty() const
voidclear()
size_tcapacity() const
size_tavailable() const
SingleThreadMessageQueue(size_t capacity =UNLIMITED_CAPACITY)
SingleThreadMessageQueue(const SingleThreadMessageQueue & ) =delete
SingleThreadMessageQueue(SingleThreadMessageQueue && ) =default

Public Attributes​

Name
size_tUNLIMITED_CAPACITY

Detailed Description​

template <typename T >
class chronon::sender::SingleThreadMessageQueue;

SingleThreadMessageQueue - Non-thread-safe priority queue for single-thread access.

This queue provides the registered-edge interface for single-thread producer/consumer pairs.

Features:

  • No mutex, no atomic operations
  • Priority ordering by arrival cycle with FIFO within same cycle

Usage: // Determined at initialization based on thread assignment SingleThreadMessageQueue queue; queue.push(42, current_cycle + delay); if (auto msg = queue.tryPop(current_cycle)) { process(*msg); }

Public Functions Documentation​

function tryPop​

inline std::optional< T > tryPop(
    uint64_t current_cycle
)

Parameters:

  • current_cycle The current simulation cycle

Return: The message data if available, std::nullopt otherwise

Try to pop a message if one is ready.

function size​

inline size_t size() const

function setCapacity​

inline void setCapacity(
    size_t capacity
)

function push​

inline bool push(
    T data,
    uint64_t arrive_cycle
)

Parameters:

  • data The message data
  • arrive_cycle The cycle at which the message should be delivered

Return: true if push succeeded, false if queue is full (back pressure)

Push a message to arrive at a specific cycle.

function popAllInto​

inline void popAllInto(
    std::vector< T > & out,
    uint64_t current_cycle
)

function popAll​

inline std::vector< T > popAll(
    uint64_t current_cycle
)

function operator=​

SingleThreadMessageQueue & operator=(
    const SingleThreadMessageQueue & 
) =delete

function operator=​

SingleThreadMessageQueue & operator=(
    SingleThreadMessageQueue && 
) =default

function minArrivalCycle​

inline std::optional< uint64_t > minArrivalCycle() const

Earliest arrival cycle of pending messages.

function hasReady​

inline bool hasReady(
    uint64_t current_cycle
) const

function full​

inline bool full() const

function empty​

inline bool empty() const

function clear​

inline void clear()

function capacity​

inline size_t capacity() const

function available​

inline size_t available() const

function SingleThreadMessageQueue​

inline explicit SingleThreadMessageQueue(
    size_t capacity =UNLIMITED_CAPACITY
)

Parameters:

  • capacity Maximum number of messages (default unlimited)

Create a single-thread message queue.

function SingleThreadMessageQueue​

SingleThreadMessageQueue(
    const SingleThreadMessageQueue & 
) =delete

function SingleThreadMessageQueue​

SingleThreadMessageQueue(
    SingleThreadMessageQueue && 
) =default

Public Attributes Documentation​

variable UNLIMITED_CAPACITY​

static size_t UNLIMITED_CAPACITY = std::numeric_limits<size_t>::max();

Updated on 2026-07-06 at 09:03:33 +0000