JSON 解码为 Swift 中的递归枚举并从其编码

Question

我有一个 JSON 文件，看起来像这样：

{
    "items" : [
        { "name": "a name", "version": "a version" },
        { "version": "a 2nd version" },
        {
            "any_of": [
                { "name": "some name" },
                { "name": "some other name", "version": "some other version" },
                [
                    { "name": "another name" },
                    { "version": "another version" },
                    {
                        "any_of": [
                            [
                                { "version": "some version" },
                                { "version": "some version" }
                            ],
                            { "version": "yet another version" }
                        ]
                    }
                ]
            ]
        },
        {
            "any_of" : [
                { "name": "a name" },
                { "name": "another name" }
            ]
        }
    ]
}

JSON 文件具有递归结构。的any_of键表示一个OR其数组中的所有元素之间的关系，以及缺乏any_of键表示AND的关系。我想使用 Swift 的Codable协议解码（和编码）JSON 文件，目前我有一个Codable表示name versionJSON 对象的结构：

{
    "items" : [
        { "name": "a name", "version": "a version" },
        { "version": "a 2nd version" },
        {
            "any_of": [
                { "name": "some name" },
                { "name": "some other name", "version": "some other version" },
                [
                    { "name": "another name" },
                    { "version": "another version" },
                    {
                        "any_of": [
                            [
                                { "version": "some version" },
                                { "version": "some version" }
                            ],
                            { "version": "yet another version" }
                        ]
                    }
                ]
            ]
        },
        {
            "any_of" : [
                { "name": "a name" },
                { "name": "another name" }
            ]
        }
    ]
}

和一个Codable代表整个 JSON 结构的枚举：

struct NameVersion: Codable {
    let name: String?
    let version: String?

    func toString() -> String { "\(name ?? "")\(version ?? "")" }
}

我在实现枚举的init(from:)和encode(to:)函数时遇到问题Items。我检查了 Stack Overflow 问题Swift Codable protocol with recursive enums，但我的情况与之不同，我的 enum 没有嵌套在结构中，并且我item的NameVersiontype的关联值不直接来自键值对。

Answer 1

在尝试了几乎所有方法之后，我发现解码 JSON 的最佳方法是通过UnkeyedDecodingContainer协议。

根据文档，无键容器“用于按顺序保存可解码类型的编码属性，没有键。” 这描述了给定 JSON 结构的完美匹配。

因为Codable只是Decodableand的别名Encodable，所以让我们先Items符合Decodablebefore Encodable。

Decodable 一致性

鉴于这种Codable包含底层 JSON 对象的结构：

struct NameVersion: Codable {
    let name: String?
    let version: String?
}

要解码 JSON：

struct NameVersion: Codable {
    let name: String?
    let version: String?
}

尽管存在一种.nestedContainer()从非键控容器中获取嵌套键控容器的方法，该方法保存了{ "any_of": [] }JSON 对象的数据，但嵌套容器无法调用该decode(forKey:, from:)方法来解码 JSON。

相反，我按照这个解决方案来解码嵌套数据，并创建了以下服务结构来解码{ "any_of": [] }JSON 对象。

struct AnyOfItems: Codable {

    /**
    Initialises an `Items` instance by decoding from the given `decoder`.

    - Parameter decoder: The decoder to read data from.
    */
    init(from decoder: Decoder) throws {
        var itemsSet: Set<Items> = []

        var unkeyedValues = try decoder.unkeyedContainer()

        while unkeyedValues.count! > unkeyedValues.currentIndex {
            let containerIndexBeforeLoop = unkeyedValues.currentIndex

            if let nameVersion = try? unkeyedValues.decode(NameVersion.self) {
                itemsSet.insert(Items.item(nameVersion))
            } else if let anyOfItems = try? unkeyedValues.decode(AnyOfItems.self) {
                itemsSet.insert(anyOfItems.items)
            } else if let items = try? unkeyedValues.decode(Items.self) {
                itemsSet.insert(items)
            }

            if unkeyedValues.currentIndex <= containerIndexBeforeLoop { break }
        }

        if itemsSet.count == 1 {
            items = itemsSet.popFirst()!
        } else {
            //  The decoding part for AnyOfItems is largely the same as that for 
            //  Items, but they differ in that for AnyOfItems, the set of Items 
            //  are given to the .anyOfItems case.
            itsms = Items.anyOfItems(itemsSet)
        }
    }

    let items: Items
}

大部分重复的代码可以提取到自己的函数中：

indirect enum Items: Codable {
    init(from decoder: Decoder) throws {
        //  Still has to be a variable, because .popFirst() is a mutating method.
        var itemsSet: Set<Items> = try decodeItems(from: decoder)
        if itemsSet.count == 1 { self = ItemsSet.popFirst()! } 
        else { self = .allOfItems(itemsSet) }
    }

    func encode(to encoder: Encoder) throws {
        //  TODO: encode to JSON here
    }

    case item(NameVersion)
    case anyOfItems(Set<Items>)
    case allOfItems(Set<Items>)
}

struct AnyOfItems: Codable {
    init(from decoder: Decoder) throws {
        var itemsSet: Set<Items> = try decodeItems(from: decoder)
        if itemsSet.count == 1 { items = itemsSet.popFirst()! } 
        else { items = Items.anyOfItems(itemsSet) }
    }

    let items: Items
}

func decodeItems(from decoder: Decoder) throws -> Set<Items> {
    var itemsSet: Set<Items> = []
    var unkeyedValues = try decoder.unkeyedContainer()

    while unkeyedValues.count! > unkeyedValues.currentIndex {
        let containerIndexBeforeLoop = unkeyedValues.currentIndex

        if let nameVersion = try? unkeyedValues.decode(NameVersion.self) {
            itemsSet.insert(Items.item(nameVersion))
        } else if let anyOfItems = try? unkeyedValues.decode(AnyOfItems.self) {
            itemsSet.insert(anyOfItems.items)
        } else if let items = try? unkeyedValues.decode(Items.self) {
            itemsSet.insert(items)
        }

        if unkeyedValues.currentIndex <= containerIndexBeforeLoop { break }
    }

    return itemsSet
}

Encodable 一致性

编码要简单得多。

indirect enum Items: Codable {
    init(from decoder: Decoder) throws {
        //  JSON decoded here
    }

    /**
    Encodes an `Items` instance`.

    - Parameter encoder: The encoder to encode data to.
    */
    func encode(to encoder: Encoder) throws {
        var container = encoder.unkeyedContainer()
        switch self {
        case .item(let item):
            try container.encode(item)
        case .allOfItems(let items):
            try container.encode(contentsOf: items)
        case .anyOfItems(let items):
            try container.encode(AnyOfItems(Items.anyOfItems(items)))
        }
    }

    case item(NameVersion)
    case anyOfItems(Set<Items>)
    case allOfItems(Set<Items>)
}

struct AnyOfItems: Codable {
    init(from decoder: Decoder) throws {
        //  JSON decoded here
    }

    /**
    Encodes an `Items` instance`.

    - Parameter encoder: The encoder to encode data to.
    */
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(items, forKey: .items)
    }

    /**
    A memberwise initialiser.
    */
    init(_ items: Items) {
        self.items = items
    }

    let items: Items

    private enum CodingKeys: String, CodingKey {
        case items = "any_of"
    }
}

Codable 一致性

最后，将所有内容放在一起：

indirect enum Items: Codable {

    /**
    Initialises an `Items` instance by decoding from the given `decoder`.

    - Parameter decoder: The decoder to read data from.
    */
    init(from decoder: Decoder) throws {
        var itemsSet: Set<Items> = try decodeItems(from: decoder)

        if itemsSet.count == 1 { 
            self = ItemsSet.popFirst()! 
        } else { 
            self = .allOfItems(itemsSet) 
        }
    }

    /**
    Encodes an `Items` instance`.

    - Parameter encoder: The encoder to encode data to.
    */
    func encode(to encoder: Encoder) throws {
        var container = encoder.unkeyedContainer()
        switch self {
        case .item(let item):
            try container.encode(item)
        case .allOfItems(let items):
            try container.encode(contentsOf: items)
        case .anyOfItems(let items):
            try container.encode(AnyOfItems(Items.anyOfItems(items)))
        }
    }

    case item(NameVersion)
    case anyOfItems(Set<Items>)
    case allOfItems(Set<Items>)
}

struct AnyOfItems: Codable {

    /**
    Initialises an `Items` instance by decoding from the given `decoder`.

    - Parameter decoder: The decoder to read data from.
    */
    init(from decoder: Decoder) throws {
        var itemsSet: Set<Items> = try decodeItems(from: decoder)

        if itemsSet.count == 1 { 
            items = itemsSet.popFirst()! 
        } else { 
            items = Items.anyOfItems(itemsSet) 
        }
    }

    /**
    Encodes an `Items` instance`.

    - Parameter encoder: The encoder to encode data to.
    */
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(items, forKey: .items)
    }

    /**
    A memberwise initialiser.
    */
    init(_ items: Items) {
        self.items = items
    }

    let items: Items

    private enum CodingKeys: String, CodingKey {
        case items = "any_of"
    }
}

func decodeItems(from decoder: Decoder) throws -> Set<Items> {
    var itemsSet: Set<Items> = []
    var unkeyedValues = try decoder.unkeyedContainer()

    while unkeyedValues.count! > unkeyedValues.currentIndex {
        let containerIndexBeforeLoop = unkeyedValues.currentIndex

        if let nameVersion = try? unkeyedValues.decode(NameVersion.self) {
            itemsSet.insert(Items.item(nameVersion))
        } else if let anyOfItems = try? unkeyedValues.decode(AnyOfItems.self) {
            itemsSet.insert(anyOfItems.items)
        } else if let items = try? unkeyedValues.decode(Items.self) {
            itemsSet.insert(items)
        }

        if unkeyedValues.currentIndex <= containerIndexBeforeLoop { break }
    }

    return itemsSet
}