Struct Sender 

pub struct Sender<T: MachineImpl> {
    pub sender: Sender<T>,
    /* private fields */
}

Wrap the crossbeam sender to allow the executor to handle a block. This requires that a send which would block, parks the send. It also requires that prior to sending a check is made to determine if the sender is already blocked. What makes this work is that the repeat send is bound to the executor. Consequently, TLS data can be inspected to determine if we need to not complete the send.

Otherwise, the Sender is a wrapper aruond the Crossbeam sender. It intentionally limits the surface of the sender. Much of this is just boilerplate wrapping

Fields

sender: Sender<T>

Implementations

impl<T> Sender<T>

where T: MachineImpl,

pub fn get_id(&self) -> usize

pub fn bind(&mut self, recevier_machine: Weak<MachineAdapter>)

pub fn try_send(&self, msg: T) -> Result<(), TrySendError<T>>

pub fn sender(&self) -> Sender<T>

pub fn send(&self, msg: T) -> Result<(), SendError<T>>

where T: MachineImpl + MachineImpl<InstructionSet = T> + Debug,

pub fn send_timeout( &self, msg: T, timeout: Duration, ) -> Result<(), SendTimeoutError<T>>

pub fn is_full(&self) -> bool

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn capacity(&self) -> Option<usize>

Trait Implementations

impl<T> Clone for Sender<T>

where T: MachineImpl,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Sender<T>

where T: MachineImpl,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Drop for Sender<T>

where T: MachineImpl,

fn drop(&mut self)

Executes the destructor for this type.

impl<T> PartialEq for Sender<T>

where T: MachineImpl,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for Sender<T>

where T: MachineImpl,