facet_generate 0.16.0

Generate Swift, Kotlin and TypeScript from types annotated with `#[derive(Facet)]`
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

import Foundation

struct GenericStruct<A: Codable, B: Codable>: Codable {
    var field_a: A
    var field_b: [B]

    init(field_a: A, field_b: [B]) {
        self.field_a = field_a
        self.field_b = field_b
    }
}

struct GenericStructUsingGenericStruct<T: Codable>: Codable {
    var struct_field: GenericStruct<String, T>
    var second_struct_field: GenericStruct<T, String>
    var third_struct_field: GenericStruct<T, [T]>

    init(struct_field: GenericStruct<String, T>, second_struct_field: GenericStruct<T, String>, third_struct_field: GenericStruct<T, [T]>) {
        self.struct_field = struct_field
        self.second_struct_field = second_struct_field
        self.third_struct_field = third_struct_field
    }
}

enum EnumUsingGenericStruct: Codable {
    case variantA(GenericStruct<String, Float>)
    case variantB(GenericStruct<String, Int32>)
    case variantC(GenericStruct<String, Bool>)
    case variantD(GenericStructUsingGenericStruct<CodableVoid>)

    enum `Type`: String, CodingKey, Codable, CaseIterable {
        case variantA = "VariantA"
        case variantB = "VariantB"
        case variantC = "VariantC"
        case variantD = "VariantD"
    }

    var type: `Type` {
        switch self {
        case .variantA: return .variantA
        case .variantB: return .variantB
        case .variantC: return .variantC
        case .variantD: return .variantD
        }
    }

    private enum CodingKeys: String, CodingKey {
        case type
        case content
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        let type = try container.decode(`Type`.self, forKey: .type)
        switch type {
        case .variantA:
            let content = try container.decode(GenericStruct<String, Float>.self, forKey: .content)
            self = .variantA(content)
        case .variantB:
            let content = try container.decode(GenericStruct<String, Int32>.self, forKey: .content)
            self = .variantB(content)
        case .variantC:
            let content = try container.decode(GenericStruct<String, Bool>.self, forKey: .content)
            self = .variantC(content)
        case .variantD:
            let content = try container.decode(GenericStructUsingGenericStruct<CodableVoid>.self, forKey: .content)
            self = .variantD(content)
        }
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        switch self {
        case .variantA(let content):
            try container.encode(`Type`.variantA, forKey: .type)
            try container.encode(content, forKey: .content)
        case .variantB(let content):
            try container.encode(`Type`.variantB, forKey: .type)
            try container.encode(content, forKey: .content)
        case .variantC(let content):
            try container.encode(`Type`.variantC, forKey: .type)
            try container.encode(content, forKey: .content)
        case .variantD(let content):
            try container.encode(`Type`.variantD, forKey: .type)
            try container.encode(content, forKey: .content)
        }
    }
}

/// () isn't codable, so we use this instead to represent Rust's unit type
struct CodableVoid: Codable, KeyPathMutable {
    public mutating func patch<C: Collection>(_ patch: PatchOperation, at keyPath: C) where C.Element == KeyPathElement {}
}