Struct OpSequence 

pub struct OpSequence { /* private fields */ }

Maps cycle numbers to op templates using a pre-computed LUT.

The LUT length equals the sum of all ratios (the “stanza length”). cycle % stanza_length indexes into the LUT to select an op.

Implementations

impl OpSequence

pub fn build( ops: Vec<ParsedOp>, ratios: &[u64], strategy: SequencerType, ) -> Self

Build a sequence from ops with explicit ratios and strategy.

pub fn uniform(ops: Vec<ParsedOp>) -> Self

Build with uniform ratios (1 each) using bucket sequencing.

pub fn from_ops(ops: Vec<ParsedOp>, strategy: SequencerType) -> Self

Build from ops, extracting ratios from the ratio param on each op template (defaults to 1). Build from ops, extracting ratios from the ratio field.

Checks params["ratio"] first (explicit params), then op["ratio"] (inline with op fields). Defaults to 1.

pub fn get(&self, cycle: u64) -> &ParsedOp

Get the op template for a given cycle.

pub fn get_with_index(&self, cycle: u64) -> (usize, &ParsedOp)

Get the op template and its index for a given cycle.

pub fn templates(&self) -> &[ParsedOp]

All unique op templates in declaration order.

pub fn op_count(&self) -> usize

Number of distinct op templates.

pub fn stanza_length(&self) -> usize

Stanza length (sum of all ratios = LUT length).

pub fn stanza_ops(&self, base_cycle: u64) -> Vec<(&ParsedOp, u64)>

Get all ops in a stanza starting at the given cycle.

Returns (op_template, cycle_within_stanza) pairs for each position in the stanza. Used by the capture-aware executor to process a full stanza as a unit.

pub fn sequencer_type(&self) -> SequencerType

The sequencing strategy used.

pub fn lut(&self) -> &[usize]

The raw LUT (for inspection/testing).