Struct SendPort

pub struct SendPort<TYPE: Send, const TYPENO: u16> {
    destination: KernelPID,
    _phantom: PhantomData<TYPE>,
}

Available on riot_module_core_msg and crate feature with_msg_v2 only.

Object through which messages of a precise type can be sent to a precise thread.

Unlike the ReceivePort, the SendPort is Send and Sync by adding the runtime information of the destination Kernel PID to it. That process / thread is guaranteed to be live (might have crashed to a non-unwinding panic but not been reused) by the construction of SendPort: A SendPort can only be created when the indicated thread gives the appropriate guarantees.

It is owned, but can be used through shared references (which are Send as well); ownership matters if one ever wants to stop accepting a certain type of message again.

If it is desired that multiple callers send on a single typeno (where the callers can not just share a shared reference), it would be possible to create a version of the SendPort that counts its clones at runtime and can only be returned when all of them are recombined, or just to create a version that can be cloned at will but never recombined any more. (One way to do the latter would be to add a const boolean type parameter “CLONED”; a .cloneable(self) -> Self would switch that from false to true, and then copy and clone would be implemented for the result, whereas recombination would only be implemented for the CLONED = false version).

Fields

destination: KernelPID

_phantom: PhantomData<TYPE>

Implementations

impl<TYPE: Send, const TYPENO: u16> SendPort<TYPE, TYPENO>

pub fn try_send(&self, data: TYPE) -> Result<(), TYPE>

Send a message to a given ticket.

On success, the data is received by (or enqueued in, if a queue is set up) the thread indicated in the ticket. Otherwise, the data is returned.

Note that while the underlying msg_try_send function knows two error cases (thread is not ready to receive, and invalid PID), the presence of a SendPort implies that the thread promised to still be around (it may have crashed, but it can’t have exited), so that error can not happen here. (If it still does due to errors in unsafe code, trips up a debug assert and else is handled like the other failure to send).

pub fn destination(&self) -> KernelPID

Access the port’s destination

This is particularly useful when messages are not sent directly through SendPort::try_send(), but the port is stored (or dropped) after having been typechecked to match the described API of a C function that will send messages – and after having extracted the destination for these messages with this function.

Trait Implementations

impl<TYPE: Send, const TYPENO: u16> Debug for SendPort<TYPE, TYPENO>

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

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 2 bytes