Struct OpBatch 

pub struct OpBatch { /* private fields */ }

A batch of operations in a span block.

An operation batch consists of up to 8 operation groups, with each group containing up to 9 operations or a single immediate value.

Implementations

impl OpBatch

pub fn ops(&self) -> &[Operation]

Returns a list of operations contained in this batch. This will include padding noops, if any.

pub fn raw_ops(&self) -> impl Iterator<Item = &Operation>

Returns a list of operations contained in this batch, without any padding noops.

Note: the processor will insert NOOP operations to fill out the groups, so the true number of operations in the batch may be larger than the number of operations reported by this method.

pub fn groups(&self) -> &[BaseElement; 8]

Returns a list of operation groups contained in this batch.

Each group is represented by a single field element.

pub fn indptr(&self) -> &[usize; 9]

Returns a list of indexes in the ops array, marking the beginning and end of each group.

The array maintains the invariant that the i-th group (i <= BATCH_SIZE-1) is at self.ops[self.indptr[i]..self.indptr[i+1]].

pub fn padding(&self) -> &[bool; 8]

Returns a list of flags marking whether each group of the batch contains a final padding Noop

pub fn end_indices(&self) -> &[usize; 8]

Returns the end indexes of each group.

pub fn num_groups(&self) -> usize

Returns the number of groups in this batch.

pub fn op_idx_in_batch_to_group( &self, op_idx_in_batch: usize, ) -> Option<(usize, usize)>

Returns the (op_group_idx, op_idx_in_group) given an operation index in the batch. Returns None if the index is out of bounds.

This uses binary search (partition_point) on the group end indices to find the containing group. For batches with many operations, this can be expensive when called repeatedly.

Performance Consideration

For iterating over all operations in a batch, prefer using iter_with_groups() which tracks group boundaries incrementally in O(1) per operation rather than O(log m) per operation, where m is the number of groups.

pub fn iter_with_groups(&self) -> OpBatchIterator<'_>

Returns an iterator over operations in the batch with their group information.

This iterator yields tuples of (group_idx, op_idx_in_group, operation) for each operation in the batch, tracking group boundaries incrementally without binary search.

Returns

An iterator that produces tuples containing:

• group_idx: Index of the operation group within the batch (0-7)
• op_idx_in_group: Index of the operation within its group (0-8)
• operation: Reference to the operation itself

This is significantly more efficient than calling op_idx_in_batch_to_group() for each operation because it tracks group boundaries incrementally instead of using binary search for each operation (which would be O(n * log m) total, where m is the number of groups, and n is the number of operations).

pub fn next_op_group_index( &self, after_this_group_index: usize, ) -> Option<usize>

Returns the index of the first group that contains operations that comes after after_this_group_index, if any.

Since groups either contain immediate values or operations, this is equivalent to skipping all groups that contain immediate values after after_this_group_index and returns the index of the first group that contains operations.

Trait Implementations

impl Clone for OpBatch

fn clone(&self) -> OpBatch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OpBatch

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

Formats the value using the given formatter.

impl PartialEq for OpBatch

fn eq(&self, other: &OpBatch) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for OpBatch

impl StructuralPartialEq for OpBatch