specta-swift 0.0.3

Export your Rust types to Swift
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

// Generated by MyApp - Custom Header
import Foundation

public enum api_result<T> {
    case success(api_resultSuccessData)
    case error(api_resultErrorData)
    case loading(api_resultLoadingData)
}
public struct api_resultSuccessData: Codable {
    public let data: T
    public let status: UInt16
}

public struct api_resultErrorData: Codable {
    public let message: String
    public let code: UInt32
}

public struct api_resultLoadingData: Codable {
    public let progress: Float
}

// MARK: - api_result Codable Implementation
extension api_result: Codable {
    private enum CodingKeys: String, CodingKey {
        case success = "Success"
        case error = "Error"
        case loading = "Loading"
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        
        if container.allKeys.count != 1 {
            throw DecodingError.dataCorrupted(
                DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Invalid number of keys found, expected one.")
            )
        }

        let key = container.allKeys.first!
        switch key {
        case .success:
            let data = try container.decode(api_resultSuccessData.self, forKey: .success)
            self = .success(data)
        case .error:
            let data = try container.decode(api_resultErrorData.self, forKey: .error)
            self = .error(data)
        case .loading:
            let data = try container.decode(api_resultLoadingData.self, forKey: .loading)
            self = .loading(data)
        }
    }

    public func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        
        switch self {
        case .success(let data):
            try container.encode(data, forKey: .success)
        case .error(let data):
            try container.encode(data, forKey: .error)
        case .loading(let data):
            try container.encode(data, forKey: .loading)
        }
    }
}


public struct user: Codable {
    public let id: UInt32
    public let name: String
    public let email: Optional<String>
    public let role: user_role
}

public enum user_role {
    case guest
    case user(user_roleUserData)
    case admin(user_roleAdminData)
    case super_admin(user_roleSuperAdminData)
}
public struct user_roleUserData: Codable {
    public let permissions: [String]
}

public struct user_roleAdminData: Codable {
    public let level: UInt8
    public let department: String
}

public struct user_roleSuperAdminData: Codable {
    public let access_level: UInt32
}

// MARK: - user_role Codable Implementation
extension user_role: Codable {
    private enum CodingKeys: String, CodingKey {
        case guest = "Guest"
        case user = "User"
        case admin = "Admin"
        case super_admin = "SuperAdmin"
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        
        if container.allKeys.count != 1 {
            throw DecodingError.dataCorrupted(
                DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Invalid number of keys found, expected one.")
            )
        }

        let key = container.allKeys.first!
        switch key {
        case .guest:
            self = .guest
        case .user:
            let data = try container.decode(user_roleUserData.self, forKey: .user)
            self = .user(data)
        case .admin:
            let data = try container.decode(user_roleAdminData.self, forKey: .admin)
            self = .admin(data)
        case .super_admin:
            let data = try container.decode(user_roleSuperAdminData.self, forKey: .super_admin)
            self = .super_admin(data)
        }
    }

    public func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        
        switch self {
        case .guest:
            try container.encodeNil(forKey: .guest)
        case .user(let data):
            try container.encode(data, forKey: .user)
        case .admin(let data):
            try container.encode(data, forKey: .admin)
        case .super_admin(let data):
            try container.encode(data, forKey: .super_admin)
        }
    }
}