How do I parse JSON with different Structures? - json

Question

I have a the following structure:
JSON a:
{
"type": "A",
"data": {
"aSpecific": 64
}
}
or JSON b:
{
"type": "B",
"data": {
"bSpecific": "hello"
}
}
Now how does the structure look like to parse any of the above in one go?
enum DataType {
case "A"
case "B"
}
struct Example: Codable {
struct ASpecific: Codable {
var aSpecifiv: Int
}
struct BSpecific: Codable {
var bSpecifiv: String
}
var type: DataType
var data: ??? // Aspecific or BSpecific
}
I want the var data to be specific for the type of the JSON.
How do I do this?

Answer 1

First of all, use String as rawType of enum DataType
enum DataType: String, Decodable {
case A, B
}
Now, you can create init(from:) in the struct Root and add custom parsing as per the JSON.
struct Root: Decodable {
let type: DataType
let aSpecific: Int?
let bSpecific: String?
enum CodingKeys: String, CodingKey {
case type, data, aSpecific, bSpecific
}
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
type = try container.decode(DataType.self, forKey: .type)
let data = try container.nestedContainer(keyedBy: CodingKeys.self, forKey: .data)
aSpecific = try data.decodeIfPresent(Int.self, forKey: .aSpecific)
bSpecific = try data.decodeIfPresent(String.self, forKey: .bSpecific)
}
}
Parsing:
do {
let response = try JSONDecoder().decode(Root.self, from: data)
print(response)
} catch {
print(error)
}

Answer 2

For two different types and one common key my suggestion is an enum with associated values. It's easy to distinguish on the basis of the type and you don't need any optionals.
enum DataType : String, Decodable {
case A, B
}
struct ASpecific: Decodable {
var aSpecific: Int
}
struct BSpecific: Decodable {
var bSpecific: String
}
enum Response : Decodable {
case aType(ASpecific)
case bType(BSpecific)
private enum CodingKeys : String, CodingKey {
case type, data
}
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
let type = try container.decode(DataType.self, forKey: .type)
switch type {
case .A: self = .aType(try container.decode(ASpecific.self, forKey: .data))
case .B: self = .bType(try container.decode(BSpecific.self, forKey: .data))
}
}
}