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
146
147
148
149

// This file has been generated by Specta. DO NOT EDIT.
import Foundation

public enum ApiResult<T> {
    case success(ApiResultSuccessData)
    case error(ApiResultErrorData)
    case loading(ApiResultLoadingData)
}
public struct ApiResultSuccessData: Codable {
    public let data: T
    public let status: UInt16
}

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

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

// MARK: - ApiResult Codable Implementation
extension ApiResult: 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(ApiResultSuccessData.self, forKey: .success)
            self = .success(data)
        case .error:
            let data = try container.decode(ApiResultErrorData.self, forKey: .error)
            self = .error(data)
        case .loading:
            let data = try container.decode(ApiResultLoadingData.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: String?
    public let role: UserRole
}

public enum UserRole {
    case guest
    case user(UserRoleUserData)
    case admin(UserRoleAdminData)
    case superAdmin(UserRoleSuperAdminData)
}
public struct UserRoleUserData: Codable {
    public let permissions: [String]
}

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

public struct UserRoleSuperAdminData: Codable {
    public let accessLevel: UInt32

    private enum CodingKeys: String, CodingKey {
        case accessLevel = "access_level"
    }
}

// MARK: - UserRole Codable Implementation
extension UserRole: Codable {
    private enum CodingKeys: String, CodingKey {
        case guest = "Guest"
        case user = "User"
        case admin = "Admin"
        case superAdmin = "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(UserRoleUserData.self, forKey: .user)
            self = .user(data)
        case .admin:
            let data = try container.decode(UserRoleAdminData.self, forKey: .admin)
            self = .admin(data)
        case .superAdmin:
            let data = try container.decode(UserRoleSuperAdminData.self, forKey: .superAdmin)
            self = .superAdmin(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 .superAdmin(let data):
            try container.encode(data, forKey: .superAdmin)
        }
    }
}