Struct OpToDecoratorIds 

pub struct OpToDecoratorIds { /* private fields */ }

A two-level compressed sparse row (CSR) representation for indexing decorator IDs per operation per node.

This structure provides efficient access to decorator IDs in a hierarchical manner:

1. First level: Node -> Operations (operations belong to nodes)
2. Second level: Operation -> Decorator IDs (decorator IDs belong to operations)

The data layout follows CSR format at both levels:

• decorator_ids contains all the DecoratorId values in a single flat array. These are the actual decorator identifiers that need to be accessed. We store them contiguously to minimize memory overhead and improve cache locality when iterating.

• op_indptr_for_dec_ids stores pointer indices that map operations to their position within the decorator_ids array. For each operation, it contains the start index where that operation’s decorator IDs begin in the flat storage.

• node_indptr_for_op_idx stores pointer indices that map nodes to their position within the op_indptr_for_dec_ids array. For each node, it contains the start index where that node’s operation pointers begin.

Together, these three arrays form a two-level index structure that allows efficient lookup of decorator IDs for any operation in any node, while minimizing memory usage for sparse decorator data.

Example

Consider this COO (Coordinate format) representation:

Node 0, Op 0: [decorator_id_0, decorator_id_1]
Node 0, Op 1: [decorator_id_2]
Node 1, Op 0: [decorator_id_3, decorator_id_4, decorator_id_5]

This would be stored as:

decorator_ids:         [0, 1, 2, 3, 4, 5]
op_indptr_for_dec_ids: [0, 2, 3, 6]  // Node 0: ops [0,2], [2,3]; Node 1: ops [3,6]
node_indptr_for_op_idx: [0, 2, 3]   // Node 0: [0,2], Node 1: [2,3]

See the unit test test_csr_and_coo_produce_same_elements for a comprehensive example demonstrating how this encoding works and verifying round-trip conversion from COO to CSR.

Implementations

impl OpToDecoratorIds

pub fn with_capacity( nodes_capacity: usize, operations_capacity: usize, decorator_ids_capacity: usize, ) -> OpToDecoratorIds

Create a new empty OpToDecoratorIds with the specified capacity.

Arguments

• nodes_capacity - Expected number of nodes
• operations_capacity - Expected total number of operations across all nodes
• decorator_ids_capacity - Expected total number of decorator IDs across all operations

pub fn new() -> OpToDecoratorIds

Create a new empty OpToDecoratorIds.

pub fn is_empty(&self) -> bool

pub fn num_nodes(&self) -> usize

Get the number of nodes in this storage.

pub fn num_decorator_ids(&self) -> usize

Get the total number of decorator IDs across all operations.

pub fn add_decorator_info_for_node( &mut self, node: MastNodeId, decorators_info: Vec<(usize, DecoratorId)>, ) -> Result<(), DecoratorIndexError>

Add decorator information for a node incrementally.

This method allows building up the OpToDecoratorIds structure by adding decorator IDs for nodes in sequential order only.

Arguments

• node - The node ID to add decorator IDs for. Must be the next sequential node.
• decorators_info - Vector of (operation_index, decorator_id) tuples. The operation indices should be sorted (as guaranteed by validate_decorators). Operations not present in this vector will have no decorator IDs.

Returns

Ok(()) if successful, Err(DecoratorIndexError) if the node is not the next sequential node.

Behavior

• Can only add decorator IDs for the next sequential node ID
• Automatically creates empty operations for gaps in operation indices
• Maintains the two-level CSR structure invariant

pub fn num_decorator_ids_for_operation( &self, node: MastNodeId, operation: usize, ) -> Result<usize, DecoratorIndexError>

Get the number of decorator IDs for a specific operation within a node.

Arguments

• node - The node ID
• operation - The operation index within the node

Returns

The number of decorator IDs for the operation, or an error if indices are invalid.

pub fn decorator_ids_for_operation( &self, node: MastNodeId, operation: usize, ) -> Result<&[DecoratorId], DecoratorIndexError>

Get all decorator IDs for a specific operation within a node.

Arguments

• node - The node ID
• operation - The operation index within the node

Returns

A slice of decorator IDs for the operation, or an error if indices are invalid.

pub fn decorator_ids_for_node( &self, node: MastNodeId, ) -> Result<impl Iterator<Item = (usize, &[DecoratorId])>, DecoratorIndexError>

Get an iterator over all operations and their decorator IDs for a given node.

Arguments

• node - The node ID

Returns

An iterator yielding (operation_index, decorator_ids_slice) tuples, or an error if the node is invalid.

pub fn decorator_links_for_node<'a>( &'a self, node: MastNodeId, ) -> Result<DecoratedLinks<'a>, DecoratorIndexError>

Named, zero-alloc view flattened to (relative_op_idx, DecoratorId).

pub fn operation_has_decorator_ids( &self, node: MastNodeId, operation: usize, ) -> Result<bool, DecoratorIndexError>

Check if a specific operation within a node has any decorator IDs.

Arguments

• node - The node ID
• operation - The operation index within the node

Returns

True if the operation has at least one decorator ID, false otherwise, or an error if indices are invalid.

pub fn operation_range_for_node( &self, node: MastNodeId, ) -> Result<Range<usize>, DecoratorIndexError>

Get the range of operation indices for a given node.

Arguments

• node - The node ID

Returns

A range representing the start and end (exclusive) operation indices for the node.

Trait Implementations

impl Clone for OpToDecoratorIds

fn clone(&self) -> OpToDecoratorIds

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OpToDecoratorIds

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

Formats the value using the given formatter.

impl Default for OpToDecoratorIds

fn default() -> OpToDecoratorIds

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OpToDecoratorIds

fn deserialize<__D>( __deserializer: __D, ) -> Result<OpToDecoratorIds, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OpToDecoratorIds

fn eq(&self, other: &OpToDecoratorIds) -> 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 Serialize for OpToDecoratorIds

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for OpToDecoratorIds

impl StructuralPartialEq for OpToDecoratorIds