Struct SliceResult 

pub struct SliceResult {
    pub criterion: i64,
    pub slice_nodes: AHashSet<i64>,
    pub control_nodes: AHashSet<i64>,
    pub data_nodes: AHashSet<i64>,
    pub size: usize,
}

Result of a program slicing operation.

Contains the complete slice with separation between control-dependent and data-dependent nodes for debugging and analysis.

Fields

• criterion: The slicing criterion node (the target/source node)
• slice_nodes: All nodes in the slice (union of control + data)
• control_nodes: Nodes in the slice due to control dependence
• data_nodes: Nodes in the slice due to data dependence
• size: Number of nodes in the slice

Example

let result = backward_slice(&graph, &cdg, target)?;

println!("Slice size: {}", result.size);
println!("Control nodes: {:?}", result.control_nodes);
println!("Data nodes: {:?}", result.data_nodes);

// Check if a node is in the slice
if result.contains(node_id) {
    println!("Node {} is in the slice", node_id);
}

// Get deterministic sorted output
for node in result.sorted_nodes() {
    println!("Slice node: {}", node);
}

Fields

criterion: i64

The slicing criterion (node the slice is based on)

slice_nodes: AHashSet<i64>

All nodes in the slice (union of control + data dependence)

control_nodes: AHashSet<i64>

Control-dependent nodes in the slice (via CDG)

data_nodes: AHashSet<i64>

Data-dependent nodes in the slice (via reachability)

size: usize

Number of nodes in the slice

Implementations

impl SliceResult

pub fn contains(&self, node: i64) -> bool

Checks if a node is in the slice.

Returns true if the node is in the complete slice (either control or data dependence).

Arguments

• node - Node ID to check

Returns

true if node is in slice_nodes, false otherwise

Example

let result = backward_slice(&graph, &cdg, target)?;
if result.contains(some_node) {
    println!("Node {} is relevant to the criterion", some_node);
}

pub fn sorted_nodes(&self) -> Vec<i64>

Gets sorted slice nodes for deterministic output.

Returns nodes in ascending order by ID. Useful for testing, debugging, and consistent display.

Returns

Vector of node IDs sorted in ascending order

Example

let result = backward_slice(&graph, &cdg, target)?;
for node in result.sorted_nodes() {
    println!("Slice node: {}", node);
}

pub fn sorted_control_nodes(&self) -> Vec<i64>

Gets sorted control nodes for deterministic output.

Returns control-dependent nodes in ascending order by ID.

pub fn sorted_data_nodes(&self) -> Vec<i64>

Gets sorted data nodes for deterministic output.

Returns data-dependent nodes in ascending order by ID.

Trait Implementations

impl Clone for SliceResult

fn clone(&self) -> SliceResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SliceResult

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

Formats the value using the given formatter.