Struct brontes_types::tree::node::Node

pub struct Node {
    pub inner: Vec<Node>,
    pub finalized: bool,
    pub index: u64,
    pub subactions: Vec<usize>,
    pub trace_address: Vec<usize>,
    pub address: Address,
    pub data: usize,
}

Fields

inner: Vec<Node>

finalized: bool

index: u64

subactions: Vec<usize>

trace_address: Vec<usize>

address: Address

data: usize

Implementations

impl Node

pub fn new(index: u64, address: Address, trace_address: Vec<usize>) -> Self

pub fn is_finalized(&self) -> bool

pub fn get_all_children_for_complex_classification<V: NormalizedAction>( &mut self, head: &MultiCallFrameClassification<V>, nodes: &mut NodeData<V>, )

Iterates through the tree until the head node is hit. When the head node is hit, collects all child node actions that are specified by the head nodes classification types closure. This works by looking at pairs of child nodes. if the next node has a index that is greater than our target index. we know that the target index is contained in the current node. take the following tree: 0 /
1 4 / \ /
2 3 5 6

if my target node is 3: 4 > 3 so go to 1 1 has 3 as a child. it is found!

if my target node is 2: 4 > 2 go to 1 1 has child 2, it is found!

if my target node is 6: 1 < 6, check 4 4 < 6 check inf 6 < inf go to 4 4 has child 6, it is found!

pub fn modify_node_if_contains_childs<F, V: NormalizedAction>( &mut self, find: &TreeSearchBuilder<V>, modify: &F, data: &mut NodeData<V>, ) -> bool

where F: Fn(&mut Node, &mut NodeData<V>),

pub fn modify_node_spans<F, V: NormalizedAction>( &mut self, find: &TreeSearchBuilder<V>, modify: &F, data: &mut NodeData<V>, ) -> bool

where F: Fn(Vec<&mut Self>, &mut NodeData<V>),

pub fn finalize(&mut self)

pub fn insert<V: NormalizedAction>( &mut self, n: Node, data: Vec<V>, data_store: &mut NodeData<V>, )

The address here is the from address for the trace

pub fn get_all_inner_nodes<V: NormalizedAction>( &mut self, n: Node, data: Vec<V>, data_store: &mut NodeData<V>, trace_addr: Vec<usize>, )

pub fn get_all_sub_actions(&self) -> Vec<usize>

pub fn get_all_sub_actions_exclusive(&self) -> Vec<usize>

doesn’t append this node to inner subactions.

pub fn get_last_create_call<V: NormalizedAction>( &self, start_index: &mut u64, data_store: &NodeData<V>, )

returns the last create call index

pub fn get_all_parent_nodes_for_discovery( &self, res: &mut Vec<Node>, start_index: u64, trace_index: u64, )

pub fn get_immediate_parent_node(&self, tx_index: u64) -> Option<&Node>

pub fn tree_right_path(&self) -> Vec<Address>

pub fn all_sub_addresses(&self) -> Vec<Address>

pub fn current_call_stack(&self) -> Vec<Address>

pub fn get_bounded_info<F, R>( &self, lower: u64, upper: u64, res: &mut Vec<R>, info_fn: &F, )

where F: Fn(&Node) -> R,

pub fn clear_node_data<V: NormalizedAction>( &mut self, index: NodeDataIndex, data: &mut NodeData<V>, )

clears the data for the given node at the specified index. This is used for complex classification as we want to avoid the double count but don’t want to mess up the structure of the tree.

pub fn remove_node_and_children<V: NormalizedAction>( &mut self, index: u64, data: &mut NodeData<V>, )

pub fn collect_spans<V: NormalizedAction>( &self, result: &mut Vec<Vec<V>>, call: &TreeSearchBuilder<V>, data: &NodeData<V>, ) -> bool

pub fn collect<T, R, V: NormalizedAction>( &self, results: &mut Vec<R>, call: &TreeSearchBuilder<V>, wanted_data: &T, data: &NodeData<V>, )

where T: Fn(NodeWithDataRef<'_, V>) -> R,

Collects all actions that match the call closure. This is useful for fetching all actions that match a certain criteria.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 112 bytes