Struct secc::SeccReceiver

pub struct SeccReceiver<T: Sync + Send + Clone> { /* fields omitted */ }

Receiver side of the channel.

Methods

impl<T: Sync + Send + Clone> SeccReceiver<T>

pub fn peek(&self) -> Result<T, SeccErrors<T>>

Peeks at the next receivable message in the channel and returns a Clone of the message. Note that the message isn't guaranteed to stay in the channel as a thread could pop the message off while another thread is looking at the value but the value shouldn't change under the peeking thread.

pub fn receive(&self) -> Result<T, SeccErrors<T>>

Receives the next message that is receivable. This will either receive the message at the head of the channel or, in the case that there is a skip cursor active, the next receivable message will be in the node pointed to by the skip cursor. This means that it is possible that receive could return an SeccErrors::Empty when there are actually messages in the channel because there will be none readable until the skip is reset.

pub fn pop(&self) -> Result<(), SeccErrors<T>>

Removes the next receivable message in the channel and abandons it or returns an error if the channel was empty.

pub fn receive_await_timeout(
    &self,
    timeout: Duration
) -> Result<T, SeccErrors<T>>

A helper to call SeccReceiver::receive and await receivable messages until a message is aailable or the specified timeout has expired.

pub fn receive_await(&self) -> Result<T, SeccErrors<T>>

pub fn skip(&self) -> Result<(), SeccErrors<T>>

Skips the next message to be received from the channel. If the skip succeeds than the number of receivable messages will drop by one. Calling this function will either set up a skip cursor in the channel or move an existing skip cursor. To receive skipped messages the user will need to clear the skip cursor by calling the function reset_skip prior to calling receive.

pub fn reset_skip(&self) -> Result<(), SeccErrors<T>>

Cancels skipping messages in the channel and resets the skipped and cursor pointers to NIL allowing previously skipped messages to be received. Note that calling this method on a channel with no skip cursor will do nothing.

pub fn receive_and_reset_skip(&self) -> Result<T, SeccErrors<T>>

Receive the message at the current cursor and then resets the skip cursor. If there is currently no skip cursor this is the same as calling [receive].

pub fn pop_and_reset_skip(&self) -> Result<(), SeccErrors<T>>

Pops the message at the current cursor and then resets the skip cursor. If there is currently no skip cursor this is the same as calling [pop].

Trait Implementations

impl<T: Sync + Send + Clone> SeccCoreOps<T> for SeccReceiver<T>

fn core(&self) -> &SeccCore<T>

Fetch the core of the channel.

fn capacity(&self) -> usize

Returns the capacity of the channel.

fn awaited_messages(&self) -> usize

Count of the number of times receivers of this channel waited for messages.

fn awaited_capacity(&self) -> usize

Count of the number of times senders to the channel waited for capacity.

fn pending(&self) -> usize

Returns the number of items are in the channel currently without regard to cursors.

fn receivable(&self) -> usize

Number of messages in the channel that are available to be received. This will normally be the same as pending unless there is a skip cursor active; in which case it may be smaller than pending or even 0.

fn sent(&self) -> usize

Returns the total number of messages that have been sent to the channel.

fn received(&self) -> usize

Returns the total number of messages that have been received from the channel.

impl<T: Sync + Send + Clone> Clone for SeccReceiver<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Send + Sync + Clone> Send for SeccReceiver<T>

impl<T: Send + Sync + Clone> Sync for SeccReceiver<T>

impl<T: Sync + Send + Clone> Debug for SeccReceiver<T>

This function will write a debug string for the SeccReceiver but be warned that it will acquire the mutex lock to the receive_ptrs to accomplish this so a deadlock could ensue if you have two threads asking for debug on both SeccSender and SeccReceiver, especially if they are doing so in a different order.

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.