postcard-bindgen-core 0.7.1

A crate to generate bindings for the postcard binary format for other languages than Rust - Core Crate
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

---
source: postcard-bindgen-core/tests/javascript.rs
expression: ser_file
snapshot_kind: text
---
function serialize_STRUCT_TYPE(s, v) {
    s.serialize_number(U32_BYTES, false, v.field_1);
    s.serialize_string(v.field_2);
    const lambda_v_field_3 = (s, v) => {
        s.serialize_number(U32_BYTES, false, v)
    };
    s.serialize_array(lambda_v_field_3, v.field_3);
    const lambda_v_field_4 = (s, v) => {
        serialize_STRUCT_TYPE(s, v)
    };
    s.serialize_array(lambda_v_field_4, v.field_4);
    s.serialize_number(U32_BYTES, false, v.field_5.start);
    s.serialize_number(U32_BYTES, false, v.field_5.end);
    s.serialize_string_key_map((s, v) => s.serialize_number(U32_BYTES, false, v), v.field_6);
    s.serialize_map((d, k, v) => [
        s.serialize_number(U32_BYTES, false, k),
        s.serialize_number(U32_BYTES, false, v)
    ], v.field_7);
    if (v.field_8 !== undefined) {
        s.serialize_number(U32_BYTES, false, 1);
        s.serialize_number(U32_BYTES, false, v.field_8)
    } else {
        s.serialize_number(U32_BYTES, false, 0)
    };
    s.serialize_bool(v.field_9);
    s.serialize_number(U32_BYTES, false, v.field_10[0]);
    s.serialize_string(v.field_10[1]);
    const lambda_v_field_11 = (s, v) => {
        s.serialize_string(v)
    };
    s.serialize_array(lambda_v_field_11, v.field_11, 3);
    const lambda_v_field_12 = (s, v) => {
        s.serialize_number(U32_BYTES, false, v)
    };
    s.serialize_array(lambda_v_field_12, v.field_12);
    s.serialize_number_float(U32_BYTES, v.field_13);
}

function serialize_UNIT_STRUCT_TYPE(s, v) {}

function serialize_TUPLE_STRUCT_TYPE(s, v) {
    s.serialize_number(U32_BYTES, false, v[0]);
    s.serialize_string(v[1]);
}

function serialize_ENUM_TYPE(s, v) {
    switch (v.tag) {
    case "AVariant":
        s.serialize_number(U32_BYTES, false, 0);
        break;
    case "BVariant":
        {
            s.serialize_number(U32_BYTES, false, 1);
            s.serialize_number(U32_BYTES, false, v.value[0]);
            s.serialize_string(v.value[1]);
        }
        break;
    case "CVariant":
        {
            s.serialize_number(U32_BYTES, false, 2);
            s.serialize_number(U32_BYTES, false, v.value.field_1);
            s.serialize_string(v.value.field_2);
            serialize_STRUCT_TYPE(s, v.value.struct_type);
        }
        break;
    default:
        throw "variant not implemented"
    }
}

function serialize_sub_module_ENUM_TYPE(s, v) {
    switch (v.tag) {
    case "AVariant":
        s.serialize_number(U32_BYTES, false, 0);
        break;
    case "BVariant":
        {
            s.serialize_number(U32_BYTES, false, 1);
            s.serialize_number(U32_BYTES, false, v.value[0]);
            s.serialize_string(v.value[1]);
        }
        break;
    case "CVariant":
        {
            s.serialize_number(U32_BYTES, false, 2);
            s.serialize_number(U32_BYTES, false, v.value.field_1);
            s.serialize_string(v.value.field_2);
            serialize_STRUCT_TYPE(s, v.value.struct_type);
        }
        break;
    default:
        throw "variant not implemented"
    }
}

/**
 * Serialize a value to an array of bytes.
 * @param {string} type - The type of the value to serialize.
 * @param {Object} value - The value to serialize.
 * @return {Uint8Array} The serialized value as an array of bytes.
 */
function serialize(type, value) {
    if (!(typeof type === "string")) {
        throw new Error("type must be a string");
    }
    const s = new Serializer();
    switch (type) {
    case "StructType":
        if (is_STRUCT_TYPE(value)) {
            serialize_STRUCT_TYPE(s, value);
        } else {
            throw new Error("Value " + "StructType" + " has wrong format");
        }
        break;
    case "UnitStructType":
        if (is_UNIT_STRUCT_TYPE(value)) {
            serialize_UNIT_STRUCT_TYPE(s, value);
        } else {
            throw new Error("Value " + "UnitStructType" + " has wrong format");
        }
        break;
    case "TupleStructType":
        if (is_TUPLE_STRUCT_TYPE(value)) {
            serialize_TUPLE_STRUCT_TYPE(s, value);
        } else {
            throw new Error("Value " + "TupleStructType" + " has wrong format");
        }
        break;
    case "EnumType":
        if (is_ENUM_TYPE(value)) {
            serialize_ENUM_TYPE(s, value);
        } else {
            throw new Error("Value " + "EnumType" + " has wrong format");
        }
        break;
    case "sub_module.EnumType":
        if (is_sub_module_ENUM_TYPE(value)) {
            serialize_sub_module_ENUM_TYPE(s, value);
        } else {
            throw new Error("Value " + "sub_module.EnumType" + " has wrong format");
        }
        break;
    default:
        throw "type not implemented";
    }
    return s.finish();
}

exports.serialize = serialize