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
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

import Foundation

/// This is a comment.
struct ArcyColors: Codable {
    var red: UInt8
    var blue: String
    var green: [String]

    init(red: UInt8, blue: String, green: [String]) {
        self.red = red
        self.blue = blue
        self.green = green
    }
}

/// This is a comment.
struct MutexyColors: Codable {
    var blue: [String]
    var green: String

    init(blue: [String], green: String) {
        self.blue = blue
        self.green = green
    }
}

/// This is a comment.
struct RcyColors: Codable {
    var red: String
    var blue: [String]
    var green: String

    init(red: String, blue: [String], green: String) {
        self.red = red
        self.blue = blue
        self.green = green
    }
}

/// This is a comment.
struct CellyColors: Codable {
    var red: String
    var blue: [String]

    init(red: String, blue: [String]) {
        self.red = red
        self.blue = blue
    }
}

/// This is a comment.
struct LockyColors: Codable {
    var red: String

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

/// This is a comment.
struct CowyColors: Codable {
    var lifetime: String

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

/// This is a comment.
enum BoxyColors: Codable {
    case red
    case blue
    case green(String)

    enum `Type`: String, CodingKey, Codable, CaseIterable {
        case red = "Red"
        case blue = "Blue"
        case green = "Green"
    }

    var type: `Type` {
        switch self {
        case .red: return .red
        case .blue: return .blue
        case .green: return .green
        }
    }

    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 .red:
            self = .red
        case .blue:
            self = .blue
        case .green:
            let content = try container.decode(String.self, forKey: .content)
            self = .green(content)
        }
    }

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