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

import Foundation

struct Bar: Codable, KeyPathMutable {
    var one: String

    init(one: String) {
        self.one = one
    }

    public mutating func patch<C: Collection>(_ patch: PatchOperation, at keyPath: C) where C.Element == KeyPathElement {
        guard let first = keyPath.first else {
            return apply(patch)
        }
        switch first {
        case let .field(field):
            switch field {
            case "one":
                let nextIndex = keyPath.index(keyPath.startIndex, offsetBy: 1)
                self.one.patch(patch, at: keyPath[nextIndex...])
            default:
                Logs.error("Invalid field: `Bar` has no patchable field \"\(field)\".")
            }
        default:
            Logs.error("Invalid key path: `Bar` only supports field-based keypath.")
        }
    }

    private mutating func apply(_ patch: PatchOperation) {
        switch patch {
            case let .update(value):
                if let newValue = value.value as? Bar {
                    self = newValue
                } else if let newValue = Bar.fromAnyCodable(value) {
                    self = newValue
                } else {
                    Logs.error("Trying to update `Bar` with \(value.value)")
                }
            case .splice:
                Logs.error("`Bar` does not support splice operations.")
        }
    }
}

struct Foo: Codable, KeyPathMutable {
    var bar: Bar?

    init(bar: Bar?) {
        self.bar = bar
    }

    public mutating func patch<C: Collection>(_ patch: PatchOperation, at keyPath: C) where C.Element == KeyPathElement {
        guard let first = keyPath.first else {
            return apply(patch)
        }
        switch first {
        case let .field(field):
            switch field {
            case "bar":
                let nextIndex = keyPath.index(keyPath.startIndex, offsetBy: 1)
                self.bar.patch(patch, at: keyPath[nextIndex...])
            default:
                Logs.error("Invalid field: `Foo` has no patchable field \"\(field)\".")
            }
        default:
            Logs.error("Invalid key path: `Foo` only supports field-based keypath.")
        }
    }

    private mutating func apply(_ patch: PatchOperation) {
        switch patch {
            case let .update(value):
                if let newValue = value.value as? Foo {
                    self = newValue
                } else if let newValue = Foo.fromAnyCodable(value) {
                    self = newValue
                } else {
                    Logs.error("Trying to update `Foo` with \(value.value)")
                }
            case .splice:
                Logs.error("`Foo` does not support splice operations.")
        }
    }
}