mutating func insert()

in Sources/StructuredFieldValues/Encoder/StructuredFieldValueEncoder.swift [780:843]
46 lines of code
16 McCabe index (conditional complexity)

        mutating func insert(_ childData: NodeType, atKey key: _StructuredHeaderCodingKey) throws {
            // Only some things can be inside other things, and often that relies on
            // the specifics of the key.
            switch (self, childData) {
            case (.item(var item), .parameters(let params)) where key.stringValue == "parameters":
                // Oh cool, parameters. Love it. Save it.
                item.parameters = params
                self = .item(item)

            case (.innerList(var list), .parameters(let params)) where key.stringValue == "parameters":
                list.parameters = params
                self = .innerList(list)

            case (.innerList(var list), .bareInnerList(let bare)) where key.stringValue == "items":
                list.bareInnerList = bare
                self = .innerList(list)

            case (.innerList(var list), .item(let item)) where key.intValue != nil:
                list.bareInnerList.append(Item(item))
                self = .innerList(list)

            case (.bareInnerList(var list), .item(let item)):
                precondition(key.intValue == list.count)
                list.append(Item(item))
                self = .bareInnerList(list)

            case (.itemOrInnerList, .parameters(let params)) where key.stringValue == "parameters":
                self = .itemOrInnerList(params)

            case (.itemOrInnerList, .item(let item)):
                self = .item(item)

            case (.itemOrInnerList, .innerList(let list)):
                self = .innerList(list)

            case (.dictionary(var map), .innerList(let innerList)):
                map[key.stringValue] = .innerList(innerList)
                self = .dictionary(map)

            case (.dictionary(var map), .item(let item)):
                map[key.stringValue] = .item(Item(item))
                self = .dictionary(map)

            case (.listHeader, .list(let list)) where key.stringValue == "items":
                self = .list(list)

            case (.listHeader, .innerList(let innerList)) where key.intValue != nil:
                self = .list([.innerList(innerList)])

            case (.listHeader, .item(let item)) where key.intValue != nil:
                self = .list([.item(Item(item))])

            case (.list(var list), .innerList(let innerList)) where key.intValue != nil:
                list.append(.innerList(innerList))
                self = .list(list)

            case (.list(var list), .item(let item)) where key.intValue != nil:
                list.append(.item(Item(item)))
                self = .list(list)

            default:
                throw StructuredHeaderError.invalidTypeForItem
            }
        }