Struct Port 

pub struct Port<I: ?Sized + 'static> { /* private fields */ }

A port: a component’s request for an interface it does not own.

One generic struct serves all three kinds, since the only difference is which interface it holds — PutPort, GetPort and PeekPort are aliases, not separate types.

The binding lives behind Rc<RefCell<..>> because connection happens through erasure: connect reaches the port as an Rc<dyn Any> and must write to it, so the mutability has to be interior. The component’s own field and the handle connect obtains are two Rcs to the same cell.

Implementations

impl<I: ?Sized + 'static> Port<I>

pub fn new() -> Port<I>

A fresh, unconnected port. Default does the same; components get theirs from #[derive(Default)].

pub fn is_bound(&self) -> bool

Has this port been connected?

impl<T: 'static> Port<dyn PutIf<T>>

pub async fn put(&self, item: T)

Block until the far end has room, then hand the item over.

pub fn try_put(&self, item: T) -> Result<(), T>

Hand the item over only if it fits right now.

pub fn can_put(&self) -> bool

impl<T: 'static> Port<dyn GetIf<T>>

pub async fn get(&self) -> T

Block until there is an item, then take it out.

pub fn try_get(&self) -> Option<T>

pub fn can_get(&self) -> bool

impl<T: 'static> Port<dyn PeekIf<T>>

pub async fn peek(&self) -> T

Block until there is an item, then copy it, leaving it in place.

pub fn try_peek(&self) -> Option<T>

pub fn can_peek(&self) -> bool

impl<T: 'static> Port<dyn PublishIf<T>>

pub fn write(&self, item: &T)

Broadcast an item. Returns immediately, however many subscribers are listening — including none, which is why this does not panic on an unconnected port the way put does. A source that nobody watches is a legitimate testbench (D85).

pub fn has_subscribers(&self) -> bool

Is anyone listening?

impl<T: 'static> Port<dyn SinkHandle<T>>

pub fn subscribe<S: Subscriber<T>>(&self, subscriber: RustdvShared<S>)

Supply the receiver: hand the port a handle to the subscriber whose write should run for every item.

Called in the subscriber’s build, before any connect phase runs, so it is already in place when the hub comes looking for it. connect chooses the stream; subscribe supplies the receiver.

pub fn subscriber(&self) -> Option<Rc<dyn SinkHandle<T>>>

The subscriber this port was given, if subscribe was called.

impl<REQ: 'static, RSP: 'static> Port<dyn SeqItemIf<REQ, RSP>>

pub async fn get_next_item(&self) -> SeqItem<REQ>

Block until a sequence has an item ready for this driver.

pub fn try_next_item(&self) -> Option<SeqItem<REQ>>

Take an item only if one is waiting (the UVM’s try_next_item). A driver that must also do something else this clock edge cannot afford the blocking form.

pub fn item_done(&self, rsp: Option<RSP>)

Release the sequence, optionally with its answer.

pub fn put_response(&self, id: TxnId, rsp: RSP)

Answer a request that was released earlier — the pipelined case.

pub fn bind_iface(&self, iface: Rc<dyn SeqItemIf<REQ, RSP>>)

Bind this port directly, for a component that is handed its export at construction rather than wired in a connect phase.

Trait Implementations

impl<I: ?Sized + 'static> Clone for Port<I>

fn clone(&self) -> Self

Another handle to the same binding, not a second port.

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

Performs copy-assignment from source.

impl<I: ?Sized + 'static> Default for Port<I>

fn default() -> Self

Returns the “default value” for a type.

impl<I: ?Sized + 'static> PortField for Port<I>

type Iface = I

The interface this port demands: dyn PutIf<T>, dyn GetIf<T>, …

fn slot_any(&self) -> Rc<dyn Any>

The binding cell, erased, so connect can reach it through dyn.

fn bound(&self) -> bool

Has it been connected?