Struct Sequencer 

pub struct Sequencer<REQ: 'static, RSP: 'static = REQ> { /* private fields */ }

The sequencer: a queue of items feeding one driver.

It is a component — it has a path and appears in the hierarchy — and a cheap Clone handle, so an env can file one in the ConfigDb for a test to find (pyuvm’s "SEQR" idiom). Clones share state.

Implementations

impl<REQ: 'static, RSP: 'static> Sequencer<REQ, RSP>

pub fn new() -> Sequencer<REQ, RSP>

pub fn handle(&self) -> Sequencer<REQ, RSP>

Another handle to the same sequencer — for the ConfigDb.

pub fn seq_item_export(&self) -> SeqItemExport<REQ, RSP>

The driver-side endpoint, connected in the parent’s connect phase.

Trait Implementations

impl<REQ, RSP> Clone for Sequencer<REQ, RSP>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<REQ: 'static, RSP: 'static> Component for Sequencer<REQ, RSP>

fn build(&mut self, ctx: &mut RustdvCtx)

build — top-down. Where a component constructs its children (D6); the gap between “a component exists” and “its children exist” that all late binding lives in.

fn connect(&mut self, ctx: &mut RustdvCtx)

connect — bottom-up. Wire children together once they exist.

fn end_of_elaboration(&mut self, ctx: &mut RustdvCtx)

end_of_elaboration — top-down. The hierarchy is final.

fn start_of_simulation(&mut self, ctx: &mut RustdvCtx)

start_of_simulation — top-down. Last chance before time moves.

async fn run(&mut self, ctx: &mut RustdvCtx) -> Result<(), TestError>

run — bottom-up, async, objection-gated. The test body; Err fails the test.

fn extract(&mut self, ctx: &mut RustdvCtx)

extract — top-down, post-run.

fn check(&mut self, ctx: &mut RustdvCtx, errors: &mut CheckSink)

check — top-down. Report failures into the sink.

fn report(&mut self, ctx: &mut RustdvCtx)

report — top-down.

fn final_phase(&mut self, ctx: &mut RustdvCtx)

final_phase — top-down. (final is a Rust keyword.)

fn start(&mut self, ctx: &mut RustdvCtx)

Transitional spawn hook, pre-dating the restored run traversal. tinyalu_tb and the not-yet-converted chapters still spawn free-running behavior here; it folds into run as each converts. Not part of the nine-phase lifecycle.

fn comp_name() -> &'static str

where Self: Sized,

This type’s registered short name, used as the factory override key. The last path segment of the type name (Foo from crate::mod::Foo), which matches the name #[derive(Component)] registers.

fn new_comp() -> RustdvComp

where Self: Sized + Default + ComponentNode + 'static,

Build this component the normal way and drop it in an crate::factory::RustdvComp slot — the analogue of UVM’s new (D75). Not overridable.

fn create_comp() -> RustdvComp

where Self: Sized + Default + ComponentNode + 'static,

Build this component through the factory — the analogue of UVM’s create (D75). The default is built now and the slot is flagged; the build walk swaps in an override if one applies.

impl<REQ: 'static, RSP: 'static> ComponentNode for Sequencer<REQ, RSP>

fn node_name(&self) -> &'static str

The component’s type-level name (hierarchical path is synthesized from field names during traversal).

fn children_mut(&mut self) -> Vec<(String, &mut (dyn ComponentNode + 'static))>

Direct children as (field-derived name, node) pairs, in declaration order. An owned Vec, not a visit_children-style sync callback: run_all awaits inside the walk, and a higher-ranked closure cannot yield a child borrow that outlives the call, so the borrows have to come back in a value the caller holds. An Option<T> child created during build (D6) appears here only once it is Some.

fn port_slot(&self, name: &str) -> Option<Rc<dyn Any>>

This node’s port binding cell of the given name, erased (D83).

fn port_infos(&self) -> Vec<PortInfo>

Every port this node declares, for the elaboration report.

fn resolve_children(&mut self, ctx: &RustdvCtx)

Resolve factory overrides for this node’s RustdvComp fields (D75). The derive generates this to call field.resolve(ctx, "field") for each RustdvComp field; the default is a no-op for nodes with none. Called by build_all after build, before descending — so a swapped-out default’s own phases never run.

fn take_children(&mut self) -> Vec<(String, Box<dyn ComponentNode>)>

Move this node’s RustdvComp children out, for the run phase (D82b).

fn restore_children(&mut self, taken: Vec<(String, Box<dyn ComponentNode>)>)

Put back what ComponentNode::take_children removed, in the same order. Called unconditionally after the run phase — including on error — so the post-run phases walk a whole tree.

impl<REQ: 'static, RSP: 'static> Debug for Sequencer<REQ, RSP>

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

ConfigDb values must be Debug for its dump (D68). A sequencer has nothing worth dumping; say which object it is.

impl<REQ: 'static, RSP: 'static> Default for Sequencer<REQ, RSP>

fn default() -> Self

Returns the “default value” for a type.