serde-generate 0.33.0

Library to generate (de)serialization code in multiple languages
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

//  Copyright (c) Facebook, Inc. and its affiliates.

import Foundation

public class BinarySerializer: Serializer {
    var output: [UInt8]
    private var containerDepthBudget: Int

    public init(maxContainerDepth: Int) {
        output = []
        output.reserveCapacity(64)
        containerDepthBudget = maxContainerDepth
    }

    public func increase_container_depth() throws {
        if containerDepthBudget == 0 {
            throw SerializationError.invalidValue(issue: "Exceeded maximum container depth")
        }
        containerDepthBudget -= 1
    }

    public func decrease_container_depth() {
        containerDepthBudget += 1
    }

    public func serialize_char(value _: Character) throws {
        throw SerializationError.invalidValue(issue: "Not implemented: char serialization")
    }

    public func serialize_f32(value: Float) throws {
        throw SerializationError.invalidValue(issue: "Not implemented: f32 serialization")
    }

    public func serialize_f64(value: Double) throws {
        throw SerializationError.invalidValue(issue: "Not implemented: f64 serialization")
    }

    public func get_bytes() -> [UInt8] {
        return output
    }

    public func serialize_str(value: String) throws {
        try serialize_bytes(value: Array(value.utf8))
    }

    public func serialize_bytes(value: [UInt8]) throws {
        try serialize_len(value: value.count)
        output.append(contentsOf: value)
    }

    public func serialize_bool(value: Bool) throws {
        writeByte(value ? 1 : 0)
    }

    public func serialize_unit(value _: Unit) throws {}

    func writeByte(_ value: UInt8) {
        output.append(value)
    }

    public func serialize_u8(value: UInt8) throws {
        writeByte(value)
    }

    public func serialize_u16(value: UInt16) throws {
        writeByte(UInt8(truncatingIfNeeded: value))
        writeByte(UInt8(truncatingIfNeeded: value >> 8))
    }

    public func serialize_u32(value: UInt32) throws {
        writeByte(UInt8(truncatingIfNeeded: value))
        writeByte(UInt8(truncatingIfNeeded: value >> 8))
        writeByte(UInt8(truncatingIfNeeded: value >> 16))
        writeByte(UInt8(truncatingIfNeeded: value >> 24))
    }

    public func serialize_u64(value: UInt64) throws {
        writeByte(UInt8(truncatingIfNeeded: value))
        writeByte(UInt8(truncatingIfNeeded: value >> 8))
        writeByte(UInt8(truncatingIfNeeded: value >> 16))
        writeByte(UInt8(truncatingIfNeeded: value >> 24))
        writeByte(UInt8(truncatingIfNeeded: value >> 32))
        writeByte(UInt8(truncatingIfNeeded: value >> 40))
        writeByte(UInt8(truncatingIfNeeded: value >> 48))
        writeByte(UInt8(truncatingIfNeeded: value >> 56))
    }

    public func serialize_u128(value: UInt128) throws {
        try serialize_u64(value: value.low)
        try serialize_u64(value: value.high)
    }

    public func serialize_i8(value: Int8) throws {
        try serialize_u8(value: UInt8(bitPattern: value))
    }

    public func serialize_i16(value: Int16) throws {
        try serialize_u16(value: UInt16(bitPattern: value))
    }

    public func serialize_i32(value: Int32) throws {
        try serialize_u32(value: UInt32(bitPattern: value))
    }

    public func serialize_i64(value: Int64) throws {
        try serialize_u64(value: UInt64(bitPattern: value))
    }

    public func serialize_i128(value: Int128) throws {
        try serialize_u64(value: value.low)
        try serialize_i64(value: value.high)
    }

    public func serialize_option_tag(value: Bool) throws {
        writeByte(value ? 1 : 0)
    }

    public func get_buffer_offset() -> Int {
        return output.count
    }

    public func serialize_len(value _: Int) throws {
        assertionFailure("Not implemented")
    }

    public func serialize_variant_index(value _: UInt32) throws {
        assertionFailure("Not implemented")
    }

    public func sort_map_entries(offsets _: [Int]) {
        assertionFailure("Not implemented")
    }
}