sim-citizen 0.1.2

Citizen support outside the SIM kernel.
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

//! Builds the browse Card record for a registered citizen.

use sim_kernel::{Cx, Ref, Result, Symbol, Value, card::card_for_ref_with_fallback};

use crate::{CitizenInfo, NonCitizenInfo, parse_symbol};

/// Builds the browse Card record for one registered citizen.
///
/// The record is a real kernel `Card` with the fixed predicate schema plus
/// citizen-specific metadata such as the owning crate, version, arity, and any
/// loaded class members.
pub fn citizen_card(cx: &mut Cx, info: &CitizenInfo) -> Result<Value> {
    let subject = parse_symbol(info.symbol);
    let mut entries = vec![
        (
            Symbol::new("help"),
            cx.factory()
                .string("citizen class constructor surface".to_owned())?,
        ),
        (
            Symbol::new("kind"),
            cx.factory().symbol(Symbol::qualified("core", "class"))?,
        ),
        (
            Symbol::new("args"),
            cx.factory().symbol(Symbol::qualified("core", "Any"))?,
        ),
        (
            Symbol::new("result"),
            cx.factory().symbol(Symbol::qualified("core", "Any"))?,
        ),
        (Symbol::new("shape-known"), cx.factory().bool(false)?),
        (
            Symbol::new("version"),
            cx.factory()
                .number_literal(parse_symbol("citizen/int"), info.version.to_string())?,
        ),
        (
            Symbol::new("crate"),
            cx.factory().string(info.crate_name.to_owned())?,
        ),
        (
            Symbol::new("arity"),
            cx.factory()
                .number_literal(parse_symbol("citizen/int"), info.arity.to_string())?,
        ),
    ];
    append_loaded_members(cx, &mut entries, &subject)?;
    let fallback = cx.factory().table(entries)?;
    card_for_ref_with_fallback(
        cx,
        Ref::Symbol(subject),
        Some(fallback),
        Some(Symbol::qualified("core", "class")),
    )
}

/// Builds the browse Card record (a `core` table) for one non-citizen
/// exemption.
///
/// The record carries the exempt type's name, owning crate, reason, kind, and
/// descriptor strategy, rendered through `cx`'s factory.
pub fn non_citizen_card(cx: &mut Cx, info: &NonCitizenInfo) -> Result<Value> {
    cx.factory().table(vec![
        (
            Symbol::new("type_name"),
            cx.factory().string(info.type_name.to_owned())?,
        ),
        (
            Symbol::new("crate"),
            cx.factory().string(info.crate_name.to_owned())?,
        ),
        (
            Symbol::new("reason"),
            cx.factory().string(info.reason.to_owned())?,
        ),
        (
            Symbol::new("kind"),
            cx.factory().string(info.kind.to_owned())?,
        ),
        (
            Symbol::new("descriptor"),
            cx.factory().string(info.descriptor.to_owned())?,
        ),
    ])
}

fn append_loaded_members(
    cx: &mut Cx,
    entries: &mut Vec<(Symbol, Value)>,
    subject: &Symbol,
) -> Result<()> {
    let Some(class_value) = cx.registry().class_by_symbol(subject).cloned() else {
        return Ok(());
    };
    let Some(class) = class_value.object().as_class() else {
        return Ok(());
    };
    let members = class.members(cx)?;
    let Some(table) = members.object().as_table_impl() else {
        return Ok(());
    };
    for (key, value) in table.entries(cx)? {
        upsert_entry(entries, key, value);
    }
    Ok(())
}

fn upsert_entry(entries: &mut Vec<(Symbol, Value)>, key: Symbol, value: Value) {
    if let Some((_, slot)) = entries.iter_mut().find(|(existing, _)| *existing == key) {
        *slot = value;
    } else {
        entries.push((key, value));
    }
}