sim-lib-stream-core 0.1.0

Core stream metadata, packets, envelopes, and buffer values.
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use sim_kernel::{ContentId, Coordinate, Error, Expr, HandleId, Ref, Result, Symbol};

use crate::buffer::{expr_kind, field, string_field, symbol_field};

pub(super) fn ref_expr(reference: &Ref) -> Expr {
    match reference {
        Ref::Symbol(symbol) => Expr::Symbol(symbol.clone()),
        Ref::Content(content) => content_ref_expr(content),
        Ref::Handle(handle) => Expr::Map(vec![
            (
                Expr::Symbol(Symbol::new("ref")),
                Expr::Symbol(Symbol::qualified("stream/ref", "handle")),
            ),
            (
                Expr::Symbol(Symbol::new("id")),
                Expr::String(handle.0.to_string()),
            ),
        ]),
        Ref::Coord(coordinate) => Expr::Map(vec![
            (
                Expr::Symbol(Symbol::new("ref")),
                Expr::Symbol(Symbol::qualified("stream/ref", "coord")),
            ),
            (
                Expr::Symbol(Symbol::new("space")),
                Expr::Symbol(coordinate.space.clone()),
            ),
            (
                Expr::Symbol(Symbol::new("ordinal")),
                content_ref_expr(&coordinate.ordinal),
            ),
        ]),
    }
}

pub(super) fn ref_from_expr(expr: &Expr) -> Result<Ref> {
    match expr {
        Expr::Symbol(symbol) => Ok(Ref::Symbol(symbol.clone())),
        Expr::Map(entries) => {
            let tag = symbol_field(entries, "ref")?;
            match tag.as_qualified_str().as_str() {
                "stream/ref/content" => Ok(Ref::Content(content_from_entries(entries)?)),
                "stream/ref/handle" => {
                    let id = string_field(entries, "id")?
                        .parse::<u128>()
                        .map_err(|err| Error::Eval(format!("invalid stream handle ref: {err}")))?;
                    Ok(Ref::Handle(HandleId(id)))
                }
                "stream/ref/coord" => {
                    ensure_fields(entries, &["ref", "space", "ordinal"])?;
                    let ordinal = match ref_from_expr(field(entries, "ordinal")?)? {
                        Ref::Content(content) => content,
                        _ => {
                            return Err(Error::Eval(
                                "stream coordinate ordinal must be a content ref".to_owned(),
                            ));
                        }
                    };
                    Ok(Ref::Coord(Coordinate {
                        space: symbol_field(entries, "space")?.clone(),
                        ordinal,
                    }))
                }
                other => Err(Error::Eval(format!("unknown stream ref tag {other}"))),
            }
        }
        other => Err(Error::TypeMismatch {
            expected: "stream ref expression",
            found: expr_kind(other),
        }),
    }
}

fn content_ref_expr(content: &ContentId) -> Expr {
    Expr::Map(vec![
        (
            Expr::Symbol(Symbol::new("ref")),
            Expr::Symbol(Symbol::qualified("stream/ref", "content")),
        ),
        (
            Expr::Symbol(Symbol::new("algorithm")),
            Expr::Symbol(content.algorithm.clone()),
        ),
        (
            Expr::Symbol(Symbol::new("bytes")),
            Expr::Bytes(content.bytes.to_vec()),
        ),
    ])
}

fn content_from_entries(entries: &[(Expr, Expr)]) -> Result<ContentId> {
    ensure_fields(entries, &["ref", "algorithm", "bytes"])?;
    let bytes = match field(entries, "bytes")? {
        Expr::Bytes(bytes) => bytes,
        other => {
            return Err(Error::TypeMismatch {
                expected: "content bytes",
                found: expr_kind(other),
            });
        }
    };
    let bytes: [u8; 32] = bytes
        .as_slice()
        .try_into()
        .map_err(|_| Error::Eval("stream content ref bytes must be 32 bytes".to_owned()))?;
    Ok(ContentId::from_bytes(
        symbol_field(entries, "algorithm")?.clone(),
        bytes,
    ))
}

fn ensure_fields(entries: &[(Expr, Expr)], allowed: &[&str]) -> Result<()> {
    for (key, _) in entries {
        let Expr::Symbol(symbol) = key else {
            return Err(Error::TypeMismatch {
                expected: "symbol stream ref field",
                found: expr_kind(key),
            });
        };
        if symbol.namespace.is_none() && allowed.contains(&symbol.name.as_ref()) {
            continue;
        }
        return Err(Error::Eval(format!(
            "unknown stream ref field {}",
            symbol.as_qualified_str()
        )));
    }
    Ok(())
}