Struct Port 

pub struct Port {
    pub id: PortId,
    pub owner: TaskId,
    queue: ArrayQueue<IpcMessage>,
    destroyed: AtomicBool,
    send_waitq: WaitQueue,
    recv_waitq: WaitQueue,
}

An IPC port: a bounded message queue with blocking semantics.

Fields

id: PortId

Unique port identifier.

owner: TaskId

TaskId of the port’s creator/owner.

queue: ArrayQueue<IpcMessage>

The message queue (bounded to PORT_QUEUE_CAPACITY).

destroyed: AtomicBool

Set to true when the port is destroyed; blocked tasks wake with error.

send_waitq: WaitQueue

Tasks blocked because the queue is full (waiting to send).

recv_waitq: WaitQueue

Tasks blocked because the queue is empty (waiting to receive).

Implementations

impl Port

fn new(id: PortId, owner: TaskId) -> Self

Create a new port owned by the given task.

pub fn send(&self, msg: IpcMessage) -> Result<(), IpcError>

Send a message to this port.

If the queue is full, the calling task blocks until space is available. Returns Err(IpcError::PortDestroyed) if the port is destroyed while the sender is blocked.

pub fn recv(&self) -> Result<IpcMessage, IpcError>

Receive a message from this port.

If the queue is empty, the calling task blocks until a message arrives. Returns Err(IpcError::PortDestroyed) if the port is destroyed while the receiver is blocked.

pub fn try_send(&self, msg: IpcMessage) -> Result<(), IpcError>

Try to send a message to this port without blocking.

Returns Ok(()) if the message was queued, or Err(WouldBlock) if the queue is full.

pub fn try_recv(&self) -> Result<Option<IpcMessage>, IpcError>

Try to receive a message from this port without blocking.

Returns Ok(Some(msg)) if a message was available, Ok(None) if empty, or Err(IpcError::PortDestroyed) if the port is destroyed.

fn destroy(&self)

Mark the port as destroyed and wake all blocked tasks.

pub fn has_messages(&self) -> bool

Returns whether messages is available.

pub fn can_send(&self) -> bool

Returns whether this can send.

pub fn is_destroyed(&self) -> bool

Returns whether destroyed.