dcbor 0.25.2

Deterministic CBOR ("dCBOR") for Rust.
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use std::cell::RefCell;

use dcbor::{
    prelude::*,
    walk::{EdgeType, WalkElement},
};

fn main() {
    // Create a complex CBOR structure
    let mut map = Map::new();
    map.insert("name", "Alice");
    map.insert("age", 30);
    map.insert("hobbies", vec!["reading", "coding", "hiking"]);

    let mut nested_map = Map::new();
    nested_map.insert("city", "San Francisco");
    nested_map.insert("zip", 94102);
    map.insert("address", nested_map);

    let cbor = CBOR::from(map);

    println!(
        "CBOR structure (flat diagnostic): {}",
        cbor.diagnostic_flat()
    );
    println!("\nWalking the CBOR tree:");

    // Walk the structure and print each element
    let visitor = |element: &WalkElement,
                   level: usize,
                   edge: EdgeType,
                   _state: ()|
     -> ((), bool) {
        let indent = "  ".repeat(level);
        let edge_label = edge.label().unwrap_or_else(|| "root".to_string());

        println!("{}[{}] {}", indent, edge_label, element.diagnostic_flat());
        ((), false) // Continue traversal
    };

    cbor.walk((), &visitor);

    // Example: Count different types of elements
    println!("\nCounting elements by type:");

    #[derive(Clone)]
    struct Counter {
        total: usize,
        maps: usize,
        arrays: usize,
        strings: usize,
        numbers: usize,
        key_value_pairs: usize,
    }

    let final_count = RefCell::new(Counter {
        total: 0,
        maps: 0,
        arrays: 0,
        strings: 0,
        numbers: 0,
        key_value_pairs: 0,
    });

    let counter_visitor = |element: &WalkElement,
                           _level: usize,
                           _edge: EdgeType,
                           mut state: Counter|
     -> (Counter, bool) {
        state.total += 1;

        match element {
            WalkElement::KeyValue { .. } => state.key_value_pairs += 1,
            WalkElement::Single(cbor_elem) => match cbor_elem.as_case() {
                CBORCase::Map(_) => state.maps += 1,
                CBORCase::Array(_) => state.arrays += 1,
                CBORCase::Text(_) => state.strings += 1,
                CBORCase::Unsigned(_) | CBORCase::Negative(_) => {
                    state.numbers += 1
                }
                _ => {}
            },
        }

        // Store the state for final reporting
        *final_count.borrow_mut() = state.clone();

        (state, false)
    };

    cbor.walk(
        Counter {
            total: 0,
            maps: 0,
            arrays: 0,
            strings: 0,
            numbers: 0,
            key_value_pairs: 0,
        },
        &counter_visitor,
    );

    let counts = final_count.borrow();
    println!("Total elements: {}", counts.total);
    println!("Maps: {}", counts.maps);
    println!("Arrays: {}", counts.arrays);
    println!("Strings: {}", counts.strings);
    println!("Numbers: {}", counts.numbers);
    println!("Key-value pairs: {}", counts.key_value_pairs);
}