dprint-core 0.41.0

Core rust library for dprint.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use std::collections::HashSet;
use super::*;

/// Gets all the TracePrintNodes for analysis from the starting node.
pub fn get_trace_print_nodes(start_node: Option<PrintItemPath>) -> Vec<TracePrintNode> {
    let mut print_nodes = Vec::new();
    let mut path_stack = Vec::new();
    let mut handled_nodes = HashSet::new();

    if let Some(start_node) = start_node {
        path_stack.push(start_node);
    }

    // do not use recursion as it will easily overflow the stack
    while let Some(node) = path_stack.pop() {
        let node_id = node.get_node_id();
        if handled_nodes.contains(&node_id) {
            continue;
        }

        // get the trace print item
        let trace_print_item = match node.get_item() {
            PrintItem::String(text) => TracePrintItem::String(text.text.to_string()),
            PrintItem::Info(info) => TracePrintItem::Info(TraceInfo {
                info_id: info.get_unique_id(),
                name: info.get_name().to_string(),
            }),
            PrintItem::Condition(condition) => {
                if let Some(true_path) = condition.get_true_path() {
                    path_stack.push(true_path);
                }
                if let Some(false_path) = condition.get_false_path() {
                    path_stack.push(false_path);
                }
                TracePrintItem::Condition(TraceCondition {
                    condition_id: condition.get_unique_id(),
                    name: condition.get_name().to_string(),
                    is_stored: condition.is_stored,
                    dependent_infos: condition.dependent_infos.as_ref().map(|infos| infos.iter().map(|i| i.get_unique_id()).collect()),
                    true_path: condition.get_true_path().map(|p| p.get_node_id()),
                    false_path: condition.get_false_path().map(|p| p.get_node_id()),
                })
            },
            PrintItem::Signal(signal) => TracePrintItem::Signal(signal),
            PrintItem::RcPath(path) => {
                path_stack.push(path);
                TracePrintItem::RcPath(path.get_node_id())
            },
        };

        // create and store the trace print node
        print_nodes.push(TracePrintNode {
            print_node_id: node_id,
            next_print_node_id: node.get_next().map(|n| n.get_node_id()),
            print_item: trace_print_item,
        });

        if let Some(next) = node.get_next() {
            path_stack.push(next);
        }

        handled_nodes.insert(node_id);
    }

    print_nodes
}