Files
Clinton NkwochaandCory Benfield be84570e9f Add support for Display String type to StructuredFieldValues (#51)
Motivation:

The parser and serializer for the Display String type have been
implemented. The high-level encoder and decoder should follow.

Modifications:

Implement the encoder and decoder for Display String.

Result:

The StructuredFieldValues module will support the Display String type.

---------

Co-authored-by: Cory Benfield <lukasa@apple.com>
2024-12-10 07:56:51 +00:00

104 lines
3.5 KiB
Swift

//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftNIO open source project
//
// Copyright (c) 2020-2021 Apple Inc. and the SwiftNIO project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftNIO project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import Foundation
import RawStructuredFieldValues
private let keyedItemDecoderSupportedKeys = ["item", "parameters"]
/// Used when someone has requested a keyed decoder for a property of item type.
///
/// There are only two valid keys for this: "item" and "parameters".
struct KeyedItemDecoder<Key: CodingKey, BaseData: RandomAccessCollection> where BaseData.Element == UInt8 {
private var item: Item
private var decoder: _StructuredFieldDecoder<BaseData>
init(_ item: Item, decoder: _StructuredFieldDecoder<BaseData>) {
self.item = item
self.decoder = decoder
}
}
extension KeyedItemDecoder: KeyedDecodingContainerProtocol {
var codingPath: [CodingKey] {
self.decoder.codingPath
}
var allKeys: [Key] {
keyedItemDecoderSupportedKeys.compactMap { Key(stringValue: $0) }
}
func contains(_ key: Key) -> Bool {
keyedItemDecoderSupportedKeys.contains(key.stringValue)
}
func decodeNil(forKey key: Key) throws -> Bool {
// Keys are never nil for this type.
false
}
func decode<T>(_ type: T.Type, forKey key: Key) throws -> T where T: Decodable {
try self.decoder.push(_StructuredHeaderCodingKey(key, keyDecodingStrategy: self.decoder.keyDecodingStrategy))
defer {
self.decoder.pop()
}
switch type {
case is Data.Type:
let container = try self.decoder.singleValueContainer()
return try container.decode(Data.self) as! T
case is Decimal.Type:
let container = try self.decoder.singleValueContainer()
return try container.decode(Decimal.self) as! T
case is Date.Type:
let container = try self.decoder.singleValueContainer()
return try container.decode(Date.self) as! T
case is DisplayString.Type:
let container = try self.decoder.singleValueContainer()
return try container.decode(DisplayString.self) as! T
default:
return try type.init(from: self.decoder)
}
}
func nestedContainer<NestedKey: CodingKey>(
keyedBy type: NestedKey.Type,
forKey key: Key
) throws -> KeyedDecodingContainer<NestedKey> {
try self.decoder.push(_StructuredHeaderCodingKey(key, keyDecodingStrategy: self.decoder.keyDecodingStrategy))
defer {
self.decoder.pop()
}
return try self.decoder.container(keyedBy: type)
}
func nestedUnkeyedContainer(forKey key: Key) throws -> UnkeyedDecodingContainer {
try self.decoder.push(_StructuredHeaderCodingKey(key, keyDecodingStrategy: self.decoder.keyDecodingStrategy))
defer {
self.decoder.pop()
}
return try self.decoder.unkeyedContainer()
}
func superDecoder() throws -> Decoder {
// Items never support inherited types.
throw StructuredHeaderError.invalidTypeForItem
}
func superDecoder(forKey key: Key) throws -> Decoder {
// Items never support inherited types.
throw StructuredHeaderError.invalidTypeForItem
}
}