Struct kernel::object::channel::ChannelEnd

pub struct ChannelEnd {
    pub id: KernelObjectId,
    pub owner: KernelObjectId,
    pub messages: Spinlock<VecDeque<Message>>,
    /* private fields */
}

Fields

id: KernelObjectId

owner: KernelObjectId

messages: Spinlock<VecDeque<Message>>

Implementations

impl ChannelEnd

pub fn new_channel(owner: KernelObjectId) -> (Arc<ChannelEnd>, Arc<ChannelEnd>)

pub fn new_kernel_channel(owner: KernelObjectId) -> Arc<ChannelEnd>

pub fn add_message(&self, message: Message)

Add a message to this ChannelEnd. Use send if you want to send a message through this ChannelEnd (i.e. to the other end of the Channel).

pub fn send(&self, message: Message) -> Result<(), SendMessageError>

Send a message through this ChannelEnd, to be received by the other end. If this is a kernel channel, the message is discarded.

pub fn receive<F, R>(&self, f: F) -> Result<R, GetMessageError>

where F: FnOnce(Message) -> Result<R, (Message, GetMessageError)>,

Try to “receive” a message from this ChannelEnd, potentially removing it from the queue. Note that this keeps a lock over the message queue while the passed function is called - if the handling of the message fails (for example, the buffer to put it into is too small), the passed function can return it with Err((message, some_error)), and the message will be placed back into the queue (preserving message order), and the error will be returned.

Trait Implementations

impl Debug for ChannelEnd

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

Formats the value using the given formatter.

impl KernelObject for ChannelEnd

fn id(&self) -> KernelObjectId

fn typ(&self) -> KernelObjectType