tari_bor 0.13.0

The binary object representation (BOR) crate provides a binary encoding for template/engine data types
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

//   Copyright 2023 The Tari Project
//   SPDX-License-Identifier: BSD-3-Clause

use core::ops::ControlFlow;

use ciborium::value::Value;

pub fn walk_all<V, T>(value: &Value, visitor: &mut V, max_depth: usize) -> Result<(), V::Error>
where
    V: ValueVisitor<T>,
    for<'a> V::Error: From<&'a str>,
    T: FromTagAndValue<Error = V::Error>,
{
    let _ignore = walk_all_depth(value, visitor, max_depth, 0)?;
    Ok(())
}

fn walk_all_depth<V, T>(
    value: &Value,
    visitor: &mut V,
    max_depth: usize,
    depth: usize,
) -> Result<ControlFlow<()>, V::Error>
where
    V: ValueVisitor<T>,
    for<'a> V::Error: From<&'a str>,
    T: FromTagAndValue<Error = V::Error>,
{
    if depth >= max_depth {
        return Err(V::Error::from("Maximum depth exceeded"));
    }

    match value {
        Value::Integer(_) => {},
        Value::Bytes(_) => {},
        Value::Float(_) => {},
        Value::Text(_) => {},
        Value::Bool(_) => {},
        Value::Null => {},
        Value::Tag(tag, val) => {
            let val = T::try_from_tag_and_value(*tag, val)?;
            let flow = visitor.visit(val)?;
            return Ok(flow);
        },
        Value::Array(values) => {
            for value in values {
                if walk_all_depth(value, visitor, max_depth, depth + 1)?.is_break() {
                    return Ok(ControlFlow::Break(()));
                }
            }
        },
        Value::Map(value_pairs) => {
            for (key, value) in value_pairs {
                if walk_all_depth(key, visitor, max_depth, depth + 1)?.is_break() {
                    return Ok(ControlFlow::Break(()));
                }
                if walk_all_depth(value, visitor, max_depth, depth + 1)?.is_break() {
                    return Ok(ControlFlow::Break(()));
                }
            }
        },
        _ => {},
    }

    Ok(ControlFlow::Continue(()))
}

pub trait ValueVisitor<T> {
    type Error;

    fn visit(&mut self, value: T) -> Result<ControlFlow<()>, Self::Error>;
}

impl<F: FnMut(T) -> Result<ControlFlow<()>, E>, T, E> ValueVisitor<T> for F {
    type Error = E;

    fn visit(&mut self, value: T) -> Result<ControlFlow<()>, Self::Error> {
        self(value)
    }
}

pub trait FromTagAndValue {
    type Error;

    fn try_from_tag_and_value(tag: u64, value: &Value) -> Result<Self, Self::Error>
    where Self: Sized;
}