mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
1a1f79c0de
Introduce checking of ConcurrentValue conformances: - For structs, check that each stored property conforms to ConcurrentValue - For enums, check that each associated value conforms to ConcurrentValue - For classes, check that each stored property is immutable and conforms to ConcurrentValue Because all of the stored properties / associated values need to be visible for this check to work, limit ConcurrentValue conformances to be in the same source file as the type definition. This checking can be disabled by conforming to a new marker protocol, UnsafeConcurrentValue, that refines ConcurrentValue. UnsafeConcurrentValue otherwise his no specific meaning. This allows both "I know what I'm doing" for types that manage concurrent access themselves as well as enabling retroactive conformance, both of which are fundamentally unsafe but also quite necessary. The bulk of this change ended up being to the standard library, because all conformances of standard library types to the ConcurrentValue protocol needed to be sunk down into the standard library so they would benefit from the checking above. There were numerous little mistakes in the initial pass through the stsandard library types that have now been corrected.
6155 lines
227 KiB
Swift
6155 lines
227 KiB
Swift
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Codable
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// A type that can encode itself to an external representation.
|
|
public protocol Encodable {
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// If the value fails to encode anything, `encoder` will encode an empty
|
|
/// keyed container in its place.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
func encode(to encoder: Encoder) throws
|
|
}
|
|
|
|
/// A type that can decode itself from an external representation.
|
|
public protocol Decodable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
init(from decoder: Decoder) throws
|
|
}
|
|
|
|
/// A type that can convert itself into and out of an external representation.
|
|
///
|
|
/// `Codable` is a type alias for the `Encodable` and `Decodable` protocols.
|
|
/// When you use `Codable` as a type or a generic constraint, it matches
|
|
/// any type that conforms to both protocols.
|
|
public typealias Codable = Encodable & Decodable
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// CodingKey
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// A type that can be used as a key for encoding and decoding.
|
|
public protocol CodingKey: CustomStringConvertible,
|
|
CustomDebugStringConvertible {
|
|
/// The string to use in a named collection (e.g. a string-keyed dictionary).
|
|
var stringValue: String { get }
|
|
|
|
/// Creates a new instance from the given string.
|
|
///
|
|
/// If the string passed as `stringValue` does not correspond to any instance
|
|
/// of this type, the result is `nil`.
|
|
///
|
|
/// - parameter stringValue: The string value of the desired key.
|
|
init?(stringValue: String)
|
|
|
|
/// The value to use in an integer-indexed collection (e.g. an int-keyed
|
|
/// dictionary).
|
|
var intValue: Int? { get }
|
|
|
|
/// Creates a new instance from the specified integer.
|
|
///
|
|
/// If the value passed as `intValue` does not correspond to any instance of
|
|
/// this type, the result is `nil`.
|
|
///
|
|
/// - parameter intValue: The integer value of the desired key.
|
|
init?(intValue: Int)
|
|
}
|
|
|
|
extension CodingKey {
|
|
/// A textual representation of this key.
|
|
public var description: String {
|
|
let intValue = self.intValue?.description ?? "nil"
|
|
return "\(type(of: self))(stringValue: \"\(stringValue)\", intValue: \(intValue))"
|
|
}
|
|
|
|
/// A textual representation of this key, suitable for debugging.
|
|
public var debugDescription: String {
|
|
return description
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Encoder & Decoder
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// A type that can encode values into a native format for external
|
|
/// representation.
|
|
public protocol Encoder {
|
|
/// The path of coding keys taken to get to this point in encoding.
|
|
var codingPath: [CodingKey] { get }
|
|
|
|
/// Any contextual information set by the user for encoding.
|
|
var userInfo: [CodingUserInfoKey: Any] { get }
|
|
|
|
/// Returns an encoding container appropriate for holding multiple values
|
|
/// keyed by the given key type.
|
|
///
|
|
/// You must use only one kind of top-level encoding container. This method
|
|
/// must not be called after a call to `unkeyedContainer()` or after
|
|
/// encoding a value through a call to `singleValueContainer()`
|
|
///
|
|
/// - parameter type: The key type to use for the container.
|
|
/// - returns: A new keyed encoding container.
|
|
func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key>
|
|
|
|
/// Returns an encoding container appropriate for holding multiple unkeyed
|
|
/// values.
|
|
///
|
|
/// You must use only one kind of top-level encoding container. This method
|
|
/// must not be called after a call to `container(keyedBy:)` or after
|
|
/// encoding a value through a call to `singleValueContainer()`
|
|
///
|
|
/// - returns: A new empty unkeyed container.
|
|
func unkeyedContainer() -> UnkeyedEncodingContainer
|
|
|
|
/// Returns an encoding container appropriate for holding a single primitive
|
|
/// value.
|
|
///
|
|
/// You must use only one kind of top-level encoding container. This method
|
|
/// must not be called after a call to `unkeyedContainer()` or
|
|
/// `container(keyedBy:)`, or after encoding a value through a call to
|
|
/// `singleValueContainer()`
|
|
///
|
|
/// - returns: A new empty single value container.
|
|
func singleValueContainer() -> SingleValueEncodingContainer
|
|
}
|
|
|
|
/// A type that can decode values from a native format into in-memory
|
|
/// representations.
|
|
public protocol Decoder {
|
|
/// The path of coding keys taken to get to this point in decoding.
|
|
var codingPath: [CodingKey] { get }
|
|
|
|
/// Any contextual information set by the user for decoding.
|
|
var userInfo: [CodingUserInfoKey: Any] { get }
|
|
|
|
/// Returns the data stored in this decoder as represented in a container
|
|
/// keyed by the given key type.
|
|
///
|
|
/// - parameter type: The key type to use for the container.
|
|
/// - returns: A keyed decoding container view into this decoder.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered stored value is
|
|
/// not a keyed container.
|
|
func container<Key>(
|
|
keyedBy type: Key.Type
|
|
) throws -> KeyedDecodingContainer<Key>
|
|
|
|
/// Returns the data stored in this decoder as represented in a container
|
|
/// appropriate for holding values with no keys.
|
|
///
|
|
/// - returns: An unkeyed container view into this decoder.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered stored value is
|
|
/// not an unkeyed container.
|
|
func unkeyedContainer() throws -> UnkeyedDecodingContainer
|
|
|
|
/// Returns the data stored in this decoder as represented in a container
|
|
/// appropriate for holding a single primitive value.
|
|
///
|
|
/// - returns: A single value container view into this decoder.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered stored value is
|
|
/// not a single value container.
|
|
func singleValueContainer() throws -> SingleValueDecodingContainer
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Keyed Encoding Containers
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// A type that provides a view into an encoder's storage and is used to hold
|
|
/// the encoded properties of an encodable type in a keyed manner.
|
|
///
|
|
/// Encoders should provide types conforming to
|
|
/// `KeyedEncodingContainerProtocol` for their format.
|
|
public protocol KeyedEncodingContainerProtocol {
|
|
associatedtype Key: CodingKey
|
|
|
|
/// The path of coding keys taken to get to this point in encoding.
|
|
var codingPath: [CodingKey] { get }
|
|
|
|
/// Encodes a null value for the given key.
|
|
///
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if a null value is invalid in the
|
|
/// current context for this format.
|
|
mutating func encodeNil(forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Bool, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: String, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Double, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Float, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Int, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Int8, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Int16, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Int32, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Int64, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: UInt, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: UInt8, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: UInt16, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: UInt32, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: UInt64, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode<T: Encodable>(_ value: T, forKey key: Key) throws
|
|
|
|
/// Encodes a reference to the given object only if it is encoded
|
|
/// unconditionally elsewhere in the payload (previously, or in the future).
|
|
///
|
|
/// For encoders which don't support this feature, the default implementation
|
|
/// encodes the given object unconditionally.
|
|
///
|
|
/// - parameter object: The object to encode.
|
|
/// - parameter key: The key to associate the object with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeConditional<T: AnyObject & Encodable>(
|
|
_ object: T,
|
|
forKey key: Key
|
|
) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: Bool?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: String?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: Double?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: Float?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: Int?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: Int8?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: Int16?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: Int32?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: Int64?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: UInt?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: UInt8?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: UInt16?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: UInt32?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent(_ value: UInt64?, forKey key: Key) throws
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeIfPresent<T: Encodable>(
|
|
_ value: T?,
|
|
forKey key: Key
|
|
) throws
|
|
|
|
/// Stores a keyed encoding container for the given key and returns it.
|
|
///
|
|
/// - parameter keyType: The key type to use for the container.
|
|
/// - parameter key: The key to encode the container for.
|
|
/// - returns: A new keyed encoding container.
|
|
mutating func nestedContainer<NestedKey>(
|
|
keyedBy keyType: NestedKey.Type,
|
|
forKey key: Key
|
|
) -> KeyedEncodingContainer<NestedKey>
|
|
|
|
/// Stores an unkeyed encoding container for the given key and returns it.
|
|
///
|
|
/// - parameter key: The key to encode the container for.
|
|
/// - returns: A new unkeyed encoding container.
|
|
mutating func nestedUnkeyedContainer(
|
|
forKey key: Key
|
|
) -> UnkeyedEncodingContainer
|
|
|
|
/// Stores a new nested container for the default `super` key and returns a
|
|
/// new encoder instance for encoding `super` into that container.
|
|
///
|
|
/// Equivalent to calling `superEncoder(forKey:)` with
|
|
/// `Key(stringValue: "super", intValue: 0)`.
|
|
///
|
|
/// - returns: A new encoder to pass to `super.encode(to:)`.
|
|
mutating func superEncoder() -> Encoder
|
|
|
|
/// Stores a new nested container for the given key and returns a new encoder
|
|
/// instance for encoding `super` into that container.
|
|
///
|
|
/// - parameter key: The key to encode `super` for.
|
|
/// - returns: A new encoder to pass to `super.encode(to:)`.
|
|
mutating func superEncoder(forKey key: Key) -> Encoder
|
|
}
|
|
|
|
// An implementation of _KeyedEncodingContainerBase and
|
|
// _KeyedEncodingContainerBox are given at the bottom of this file.
|
|
|
|
/// A concrete container that provides a view into an encoder's storage, making
|
|
/// the encoded properties of an encodable type accessible by keys.
|
|
public struct KeyedEncodingContainer<K: CodingKey> :
|
|
KeyedEncodingContainerProtocol
|
|
{
|
|
public typealias Key = K
|
|
|
|
/// The container for the concrete encoder.
|
|
internal var _box: _KeyedEncodingContainerBase
|
|
|
|
/// Creates a new instance with the given container.
|
|
///
|
|
/// - parameter container: The container to hold.
|
|
public init<Container: KeyedEncodingContainerProtocol>(
|
|
_ container: Container
|
|
) where Container.Key == Key {
|
|
_box = _KeyedEncodingContainerBox(container)
|
|
}
|
|
|
|
/// The path of coding keys taken to get to this point in encoding.
|
|
public var codingPath: [CodingKey] {
|
|
return _box.codingPath
|
|
}
|
|
|
|
/// Encodes a null value for the given key.
|
|
///
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if a null value is invalid in the
|
|
/// current context for this format.
|
|
public mutating func encodeNil(forKey key: Key) throws {
|
|
try _box.encodeNil(forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: Bool, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: String, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: Double, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: Float, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: Int, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: Int8, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: Int16, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: Int32, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: Int64, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: UInt, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: UInt8, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: UInt16, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: UInt32, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode(_ value: UInt64, forKey key: Key) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encode<T: Encodable>(
|
|
_ value: T,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encode(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes a reference to the given object only if it is encoded
|
|
/// unconditionally elsewhere in the payload (previously, or in the future).
|
|
///
|
|
/// For encoders which don't support this feature, the default implementation
|
|
/// encodes the given object unconditionally.
|
|
///
|
|
/// - parameter object: The object to encode.
|
|
/// - parameter key: The key to associate the object with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeConditional<T: AnyObject & Encodable>(
|
|
_ object: T,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeConditional(object, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: Bool?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: String?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: Double?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: Float?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: Int?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: Int8?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: Int16?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: Int32?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: Int64?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: UInt?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: UInt8?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: UInt16?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: UInt32?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent(
|
|
_ value: UInt64?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Encodes the given value for the given key if it is not `nil`.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - parameter key: The key to associate the value with.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
public mutating func encodeIfPresent<T: Encodable>(
|
|
_ value: T?,
|
|
forKey key: Key
|
|
) throws {
|
|
try _box.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
/// Stores a keyed encoding container for the given key and returns it.
|
|
///
|
|
/// - parameter keyType: The key type to use for the container.
|
|
/// - parameter key: The key to encode the container for.
|
|
/// - returns: A new keyed encoding container.
|
|
public mutating func nestedContainer<NestedKey>(
|
|
keyedBy keyType: NestedKey.Type,
|
|
forKey key: Key
|
|
) -> KeyedEncodingContainer<NestedKey> {
|
|
return _box.nestedContainer(keyedBy: NestedKey.self, forKey: key)
|
|
}
|
|
|
|
/// Stores an unkeyed encoding container for the given key and returns it.
|
|
///
|
|
/// - parameter key: The key to encode the container for.
|
|
/// - returns: A new unkeyed encoding container.
|
|
public mutating func nestedUnkeyedContainer(
|
|
forKey key: Key
|
|
) -> UnkeyedEncodingContainer {
|
|
return _box.nestedUnkeyedContainer(forKey: key)
|
|
}
|
|
|
|
/// Stores a new nested container for the default `super` key and returns a
|
|
/// new encoder instance for encoding `super` into that container.
|
|
///
|
|
/// Equivalent to calling `superEncoder(forKey:)` with
|
|
/// `Key(stringValue: "super", intValue: 0)`.
|
|
///
|
|
/// - returns: A new encoder to pass to `super.encode(to:)`.
|
|
public mutating func superEncoder() -> Encoder {
|
|
return _box.superEncoder()
|
|
}
|
|
|
|
/// Stores a new nested container for the given key and returns a new encoder
|
|
/// instance for encoding `super` into that container.
|
|
///
|
|
/// - parameter key: The key to encode `super` for.
|
|
/// - returns: A new encoder to pass to `super.encode(to:)`.
|
|
public mutating func superEncoder(forKey key: Key) -> Encoder {
|
|
return _box.superEncoder(forKey: key)
|
|
}
|
|
}
|
|
|
|
/// A type that provides a view into a decoder's storage and is used to hold
|
|
/// the encoded properties of a decodable type in a keyed manner.
|
|
///
|
|
/// Decoders should provide types conforming to `UnkeyedDecodingContainer` for
|
|
/// their format.
|
|
public protocol KeyedDecodingContainerProtocol {
|
|
associatedtype Key: CodingKey
|
|
|
|
/// The path of coding keys taken to get to this point in decoding.
|
|
var codingPath: [CodingKey] { get }
|
|
|
|
/// All the keys the `Decoder` has for this container.
|
|
///
|
|
/// Different keyed containers from the same `Decoder` may return different
|
|
/// keys here; it is possible to encode with multiple key types which are
|
|
/// not convertible to one another. This should report all keys present
|
|
/// which are convertible to the requested type.
|
|
var allKeys: [Key] { get }
|
|
|
|
/// Returns a Boolean value indicating whether the decoder contains a value
|
|
/// associated with the given key.
|
|
///
|
|
/// The value associated with `key` may be a null value as appropriate for
|
|
/// the data format.
|
|
///
|
|
/// - parameter key: The key to search for.
|
|
/// - returns: Whether the `Decoder` has an entry for the given key.
|
|
func contains(_ key: Key) -> Bool
|
|
|
|
/// Decodes a null value for the given key.
|
|
///
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: Whether the encountered value was null.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
func decodeNil(forKey key: Key) throws -> Bool
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: Bool.Type, forKey key: Key) throws -> Bool
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: String.Type, forKey key: Key) throws -> String
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: Double.Type, forKey key: Key) throws -> Double
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: Float.Type, forKey key: Key) throws -> Float
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: Int.Type, forKey key: Key) throws -> Int
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: Int8.Type, forKey key: Key) throws -> Int8
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: Int16.Type, forKey key: Key) throws -> Int16
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: Int32.Type, forKey key: Key) throws -> Int32
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: Int64.Type, forKey key: Key) throws -> Int64
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: UInt.Type, forKey key: Key) throws -> UInt
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: UInt8.Type, forKey key: Key) throws -> UInt8
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: UInt16.Type, forKey key: Key) throws -> UInt16
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: UInt32.Type, forKey key: Key) throws -> UInt32
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode(_ type: UInt64.Type, forKey key: Key) throws -> UInt64
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func decode<T: Decodable>(_ type: T.Type, forKey key: Key) throws -> T
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: Bool.Type, forKey key: Key) throws -> Bool?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: String.Type, forKey key: Key) throws -> String?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: Double.Type, forKey key: Key) throws -> Double?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: Float.Type, forKey key: Key) throws -> Float?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: Int.Type, forKey key: Key) throws -> Int?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: Int8.Type, forKey key: Key) throws -> Int8?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: Int16.Type, forKey key: Key) throws -> Int16?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: Int32.Type, forKey key: Key) throws -> Int32?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: Int64.Type, forKey key: Key) throws -> Int64?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: UInt.Type, forKey key: Key) throws -> UInt?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: UInt8.Type, forKey key: Key) throws -> UInt8?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: UInt16.Type, forKey key: Key) throws -> UInt16?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: UInt32.Type, forKey key: Key) throws -> UInt32?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent(_ type: UInt64.Type, forKey key: Key) throws -> UInt64?
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
func decodeIfPresent<T: Decodable>(
|
|
_ type: T.Type,
|
|
forKey key: Key
|
|
) throws -> T?
|
|
|
|
/// Returns the data stored for the given key as represented in a container
|
|
/// keyed by the given key type.
|
|
///
|
|
/// - parameter type: The key type to use for the container.
|
|
/// - parameter key: The key that the nested container is associated with.
|
|
/// - returns: A keyed decoding container view into `self`.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered stored value is
|
|
/// not a keyed container.
|
|
func nestedContainer<NestedKey>(
|
|
keyedBy type: NestedKey.Type,
|
|
forKey key: Key
|
|
) throws -> KeyedDecodingContainer<NestedKey>
|
|
|
|
/// Returns the data stored for the given key as represented in an unkeyed
|
|
/// container.
|
|
///
|
|
/// - parameter key: The key that the nested container is associated with.
|
|
/// - returns: An unkeyed decoding container view into `self`.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered stored value is
|
|
/// not an unkeyed container.
|
|
func nestedUnkeyedContainer(
|
|
forKey key: Key
|
|
) throws -> UnkeyedDecodingContainer
|
|
|
|
/// Returns a `Decoder` instance for decoding `super` from the container
|
|
/// associated with the default `super` key.
|
|
///
|
|
/// Equivalent to calling `superDecoder(forKey:)` with
|
|
/// `Key(stringValue: "super", intValue: 0)`.
|
|
///
|
|
/// - returns: A new `Decoder` to pass to `super.init(from:)`.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the default `super` key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the default `super` key.
|
|
func superDecoder() throws -> Decoder
|
|
|
|
/// Returns a `Decoder` instance for decoding `super` from the container
|
|
/// associated with the given key.
|
|
///
|
|
/// - parameter key: The key to decode `super` for.
|
|
/// - returns: A new `Decoder` to pass to `super.init(from:)`.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
func superDecoder(forKey key: Key) throws -> Decoder
|
|
}
|
|
|
|
// An implementation of _KeyedDecodingContainerBase and
|
|
// _KeyedDecodingContainerBox are given at the bottom of this file.
|
|
|
|
/// A concrete container that provides a view into a decoder's storage, making
|
|
/// the encoded properties of a decodable type accessible by keys.
|
|
public struct KeyedDecodingContainer<K: CodingKey> :
|
|
KeyedDecodingContainerProtocol
|
|
{
|
|
public typealias Key = K
|
|
|
|
/// The container for the concrete decoder.
|
|
internal var _box: _KeyedDecodingContainerBase
|
|
|
|
/// Creates a new instance with the given container.
|
|
///
|
|
/// - parameter container: The container to hold.
|
|
public init<Container: KeyedDecodingContainerProtocol>(
|
|
_ container: Container
|
|
) where Container.Key == Key {
|
|
_box = _KeyedDecodingContainerBox(container)
|
|
}
|
|
|
|
/// The path of coding keys taken to get to this point in decoding.
|
|
public var codingPath: [CodingKey] {
|
|
return _box.codingPath
|
|
}
|
|
|
|
/// All the keys the decoder has for this container.
|
|
///
|
|
/// Different keyed containers from the same decoder may return different
|
|
/// keys here, because it is possible to encode with multiple key types
|
|
/// which are not convertible to one another. This should report all keys
|
|
/// present which are convertible to the requested type.
|
|
public var allKeys: [Key] {
|
|
return _box.allKeys as! [Key]
|
|
}
|
|
|
|
/// Returns a Boolean value indicating whether the decoder contains a value
|
|
/// associated with the given key.
|
|
///
|
|
/// The value associated with the given key may be a null value as
|
|
/// appropriate for the data format.
|
|
///
|
|
/// - parameter key: The key to search for.
|
|
/// - returns: Whether the `Decoder` has an entry for the given key.
|
|
public func contains(_ key: Key) -> Bool {
|
|
return _box.contains(key)
|
|
}
|
|
|
|
/// Decodes a null value for the given key.
|
|
///
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: Whether the encountered value was null.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
public func decodeNil(forKey key: Key) throws -> Bool {
|
|
return try _box.decodeNil(forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: Bool.Type, forKey key: Key) throws -> Bool {
|
|
return try _box.decode(Bool.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: String.Type, forKey key: Key) throws -> String {
|
|
return try _box.decode(String.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: Double.Type, forKey key: Key) throws -> Double {
|
|
return try _box.decode(Double.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: Float.Type, forKey key: Key) throws -> Float {
|
|
return try _box.decode(Float.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: Int.Type, forKey key: Key) throws -> Int {
|
|
return try _box.decode(Int.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: Int8.Type, forKey key: Key) throws -> Int8 {
|
|
return try _box.decode(Int8.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: Int16.Type, forKey key: Key) throws -> Int16 {
|
|
return try _box.decode(Int16.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: Int32.Type, forKey key: Key) throws -> Int32 {
|
|
return try _box.decode(Int32.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: Int64.Type, forKey key: Key) throws -> Int64 {
|
|
return try _box.decode(Int64.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: UInt.Type, forKey key: Key) throws -> UInt {
|
|
return try _box.decode(UInt.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: UInt8.Type, forKey key: Key) throws -> UInt8 {
|
|
return try _box.decode(UInt8.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: UInt16.Type, forKey key: Key) throws -> UInt16 {
|
|
return try _box.decode(UInt16.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: UInt32.Type, forKey key: Key) throws -> UInt32 {
|
|
return try _box.decode(UInt32.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode(_ type: UInt64.Type, forKey key: Key) throws -> UInt64 {
|
|
return try _box.decode(UInt64.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func decode<T: Decodable>(
|
|
_ type: T.Type,
|
|
forKey key: Key
|
|
) throws -> T {
|
|
return try _box.decode(T.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: Bool.Type,
|
|
forKey key: Key
|
|
) throws -> Bool? {
|
|
return try _box.decodeIfPresent(Bool.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: String.Type,
|
|
forKey key: Key
|
|
) throws -> String? {
|
|
return try _box.decodeIfPresent(String.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: Double.Type,
|
|
forKey key: Key
|
|
) throws -> Double? {
|
|
return try _box.decodeIfPresent(Double.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: Float.Type,
|
|
forKey key: Key
|
|
) throws -> Float? {
|
|
return try _box.decodeIfPresent(Float.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: Int.Type,
|
|
forKey key: Key
|
|
) throws -> Int? {
|
|
return try _box.decodeIfPresent(Int.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: Int8.Type,
|
|
forKey key: Key
|
|
) throws -> Int8? {
|
|
return try _box.decodeIfPresent(Int8.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: Int16.Type,
|
|
forKey key: Key
|
|
) throws -> Int16? {
|
|
return try _box.decodeIfPresent(Int16.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: Int32.Type,
|
|
forKey key: Key
|
|
) throws -> Int32? {
|
|
return try _box.decodeIfPresent(Int32.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: Int64.Type,
|
|
forKey key: Key
|
|
) throws -> Int64? {
|
|
return try _box.decodeIfPresent(Int64.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: UInt.Type,
|
|
forKey key: Key
|
|
) throws -> UInt? {
|
|
return try _box.decodeIfPresent(UInt.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: UInt8.Type,
|
|
forKey key: Key
|
|
) throws -> UInt8? {
|
|
return try _box.decodeIfPresent(UInt8.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: UInt16.Type,
|
|
forKey key: Key
|
|
) throws -> UInt16? {
|
|
return try _box.decodeIfPresent(UInt16.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: UInt32.Type,
|
|
forKey key: Key
|
|
) throws -> UInt32? {
|
|
return try _box.decodeIfPresent(UInt32.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent(
|
|
_ type: UInt64.Type,
|
|
forKey key: Key
|
|
) throws -> UInt64? {
|
|
return try _box.decodeIfPresent(UInt64.self, forKey: key)
|
|
}
|
|
|
|
/// Decodes a value of the given type for the given key, if present.
|
|
///
|
|
/// This method returns `nil` if the container does not have a value
|
|
/// associated with `key`, or if the value is null. The difference between
|
|
/// these states can be distinguished with a `contains(_:)` call.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - parameter key: The key that the decoded value is associated with.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the
|
|
/// `Decoder` does not have an entry associated with the given key, or if
|
|
/// the value is a null value.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
public func decodeIfPresent<T: Decodable>(
|
|
_ type: T.Type,
|
|
forKey key: Key
|
|
) throws -> T? {
|
|
return try _box.decodeIfPresent(T.self, forKey: key)
|
|
}
|
|
|
|
/// Returns the data stored for the given key as represented in a container
|
|
/// keyed by the given key type.
|
|
///
|
|
/// - parameter type: The key type to use for the container.
|
|
/// - parameter key: The key that the nested container is associated with.
|
|
/// - returns: A keyed decoding container view into `self`.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered stored value is
|
|
/// not a keyed container.
|
|
public func nestedContainer<NestedKey>(
|
|
keyedBy type: NestedKey.Type,
|
|
forKey key: Key
|
|
) throws -> KeyedDecodingContainer<NestedKey> {
|
|
return try _box.nestedContainer(keyedBy: NestedKey.self, forKey: key)
|
|
}
|
|
|
|
/// Returns the data stored for the given key as represented in an unkeyed
|
|
/// container.
|
|
///
|
|
/// - parameter key: The key that the nested container is associated with.
|
|
/// - returns: An unkeyed decoding container view into `self`.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered stored value is
|
|
/// not an unkeyed container.
|
|
public func nestedUnkeyedContainer(
|
|
forKey key: Key
|
|
) throws -> UnkeyedDecodingContainer {
|
|
return try _box.nestedUnkeyedContainer(forKey: key)
|
|
}
|
|
|
|
/// Returns a `Decoder` instance for decoding `super` from the container
|
|
/// associated with the default `super` key.
|
|
///
|
|
/// Equivalent to calling `superDecoder(forKey:)` with
|
|
/// `Key(stringValue: "super", intValue: 0)`.
|
|
///
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the default `super` key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the default `super` key.
|
|
public func superDecoder() throws -> Decoder {
|
|
return try _box.superDecoder()
|
|
}
|
|
|
|
/// Returns a `Decoder` instance for decoding `super` from the container
|
|
/// associated with the given key.
|
|
///
|
|
/// - parameter key: The key to decode `super` for.
|
|
/// - returns: A new `Decoder` to pass to `super.init(from:)`.
|
|
/// - throws: `DecodingError.keyNotFound` if `self` does not have an entry
|
|
/// for the given key.
|
|
/// - throws: `DecodingError.valueNotFound` if `self` has a null entry for
|
|
/// the given key.
|
|
public func superDecoder(forKey key: Key) throws -> Decoder {
|
|
return try _box.superDecoder(forKey: key)
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Unkeyed Encoding Containers
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// A type that provides a view into an encoder's storage and is used to hold
|
|
/// the encoded properties of an encodable type sequentially, without keys.
|
|
///
|
|
/// Encoders should provide types conforming to `UnkeyedEncodingContainer` for
|
|
/// their format.
|
|
public protocol UnkeyedEncodingContainer {
|
|
/// The path of coding keys taken to get to this point in encoding.
|
|
var codingPath: [CodingKey] { get }
|
|
|
|
/// The number of elements encoded into the container.
|
|
var count: Int { get }
|
|
|
|
/// Encodes a null value.
|
|
///
|
|
/// - throws: `EncodingError.invalidValue` if a null value is invalid in the
|
|
/// current context for this format.
|
|
mutating func encodeNil() throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Bool) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: String) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Double) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Float) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Int) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Int8) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Int16) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Int32) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: Int64) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: UInt) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: UInt8) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: UInt16) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: UInt32) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode(_ value: UInt64) throws
|
|
|
|
/// Encodes the given value.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encode<T: Encodable>(_ value: T) throws
|
|
|
|
/// Encodes a reference to the given object only if it is encoded
|
|
/// unconditionally elsewhere in the payload (previously, or in the future).
|
|
///
|
|
/// For encoders which don't support this feature, the default implementation
|
|
/// encodes the given object unconditionally.
|
|
///
|
|
/// For formats which don't support this feature, the default implementation
|
|
/// encodes the given object unconditionally.
|
|
///
|
|
/// - parameter object: The object to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
mutating func encodeConditional<T: AnyObject & Encodable>(_ object: T) throws
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Bool
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == String
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Double
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Float
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Int
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Int8
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Int16
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Int32
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Int64
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == UInt
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == UInt8
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == UInt16
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == UInt32
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == UInt64
|
|
|
|
/// Encodes the elements of the given sequence.
|
|
///
|
|
/// - parameter sequence: The sequences whose contents to encode.
|
|
/// - throws: An error if any of the contained values throws an error.
|
|
mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element: Encodable
|
|
|
|
/// Encodes a nested container keyed by the given type and returns it.
|
|
///
|
|
/// - parameter keyType: The key type to use for the container.
|
|
/// - returns: A new keyed encoding container.
|
|
mutating func nestedContainer<NestedKey>(
|
|
keyedBy keyType: NestedKey.Type
|
|
) -> KeyedEncodingContainer<NestedKey>
|
|
|
|
/// Encodes an unkeyed encoding container and returns it.
|
|
///
|
|
/// - returns: A new unkeyed encoding container.
|
|
mutating func nestedUnkeyedContainer() -> UnkeyedEncodingContainer
|
|
|
|
/// Encodes a nested container and returns an `Encoder` instance for encoding
|
|
/// `super` into that container.
|
|
///
|
|
/// - returns: A new encoder to pass to `super.encode(to:)`.
|
|
mutating func superEncoder() -> Encoder
|
|
}
|
|
|
|
/// A type that provides a view into a decoder's storage and is used to hold
|
|
/// the encoded properties of a decodable type sequentially, without keys.
|
|
///
|
|
/// Decoders should provide types conforming to `UnkeyedDecodingContainer` for
|
|
/// their format.
|
|
public protocol UnkeyedDecodingContainer {
|
|
/// The path of coding keys taken to get to this point in decoding.
|
|
var codingPath: [CodingKey] { get }
|
|
|
|
/// The number of elements contained within this container.
|
|
///
|
|
/// If the number of elements is unknown, the value is `nil`.
|
|
var count: Int? { get }
|
|
|
|
/// A Boolean value indicating whether there are no more elements left to be
|
|
/// decoded in the container.
|
|
var isAtEnd: Bool { get }
|
|
|
|
/// The current decoding index of the container (i.e. the index of the next
|
|
/// element to be decoded.) Incremented after every successful decode call.
|
|
var currentIndex: Int { get }
|
|
|
|
/// Decodes a null value.
|
|
///
|
|
/// If the value is not null, does not increment currentIndex.
|
|
///
|
|
/// - returns: Whether the encountered value was null.
|
|
/// - throws: `DecodingError.valueNotFound` if there are no more values to
|
|
/// decode.
|
|
mutating func decodeNil() throws -> Bool
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: Bool.Type) throws -> Bool
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: String.Type) throws -> String
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: Double.Type) throws -> Double
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: Float.Type) throws -> Float
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: Int.Type) throws -> Int
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: Int8.Type) throws -> Int8
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: Int16.Type) throws -> Int16
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: Int32.Type) throws -> Int32
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: Int64.Type) throws -> Int64
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: UInt.Type) throws -> UInt
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: UInt8.Type) throws -> UInt8
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: UInt16.Type) throws -> UInt16
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: UInt32.Type) throws -> UInt32
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode(_ type: UInt64.Type) throws -> UInt64
|
|
|
|
/// Decodes a value of the given type.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A value of the requested type, if present for the given key
|
|
/// and convertible to the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func decode<T: Decodable>(_ type: T.Type) throws -> T
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: Bool.Type) throws -> Bool?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: String.Type) throws -> String?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: Double.Type) throws -> Double?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: Float.Type) throws -> Float?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: Int.Type) throws -> Int?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: Int8.Type) throws -> Int8?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: Int16.Type) throws -> Int16?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: Int32.Type) throws -> Int32?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: Int64.Type) throws -> Int64?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: UInt.Type) throws -> UInt?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: UInt8.Type) throws -> UInt8?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: UInt16.Type) throws -> UInt16?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: UInt32.Type) throws -> UInt32?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent(_ type: UInt64.Type) throws -> UInt64?
|
|
|
|
/// Decodes a value of the given type, if present.
|
|
///
|
|
/// This method returns `nil` if the container has no elements left to
|
|
/// decode, or if the value is null. The difference between these states can
|
|
/// be distinguished by checking `isAtEnd`.
|
|
///
|
|
/// - parameter type: The type of value to decode.
|
|
/// - returns: A decoded value of the requested type, or `nil` if the value
|
|
/// is a null value, or if there are no more elements to decode.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// is not convertible to the requested type.
|
|
mutating func decodeIfPresent<T: Decodable>(_ type: T.Type) throws -> T?
|
|
|
|
/// Decodes a nested container keyed by the given type.
|
|
///
|
|
/// - parameter type: The key type to use for the container.
|
|
/// - returns: A keyed decoding container view into `self`.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered stored value is
|
|
/// not a keyed container.
|
|
mutating func nestedContainer<NestedKey>(
|
|
keyedBy type: NestedKey.Type
|
|
) throws -> KeyedDecodingContainer<NestedKey>
|
|
|
|
/// Decodes an unkeyed nested container.
|
|
///
|
|
/// - returns: An unkeyed decoding container view into `self`.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered stored value is
|
|
/// not an unkeyed container.
|
|
mutating func nestedUnkeyedContainer() throws -> UnkeyedDecodingContainer
|
|
|
|
/// Decodes a nested container and returns a `Decoder` instance for decoding
|
|
/// `super` from that container.
|
|
///
|
|
/// - returns: A new `Decoder` to pass to `super.init(from:)`.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null, or of there are no more values to decode.
|
|
mutating func superDecoder() throws -> Decoder
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Single Value Encoding Containers
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// A container that can support the storage and direct encoding of a single
|
|
/// non-keyed value.
|
|
public protocol SingleValueEncodingContainer {
|
|
/// The path of coding keys taken to get to this point in encoding.
|
|
var codingPath: [CodingKey] { get }
|
|
|
|
/// Encodes a null value.
|
|
///
|
|
/// - throws: `EncodingError.invalidValue` if a null value is invalid in the
|
|
/// current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encodeNil() throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: Bool) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: String) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: Double) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: Float) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: Int) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: Int8) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: Int16) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: Int32) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: Int64) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: UInt) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: UInt8) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: UInt16) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: UInt32) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode(_ value: UInt64) throws
|
|
|
|
/// Encodes a single value of the given type.
|
|
///
|
|
/// - parameter value: The value to encode.
|
|
/// - throws: `EncodingError.invalidValue` if the given value is invalid in
|
|
/// the current context for this format.
|
|
/// - precondition: May not be called after a previous `self.encode(_:)`
|
|
/// call.
|
|
mutating func encode<T: Encodable>(_ value: T) throws
|
|
}
|
|
|
|
/// A container that can support the storage and direct decoding of a single
|
|
/// nonkeyed value.
|
|
public protocol SingleValueDecodingContainer {
|
|
/// The path of coding keys taken to get to this point in encoding.
|
|
var codingPath: [CodingKey] { get }
|
|
|
|
/// Decodes a null value.
|
|
///
|
|
/// - returns: Whether the encountered value was null.
|
|
func decodeNil() -> Bool
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: Bool.Type) throws -> Bool
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: String.Type) throws -> String
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: Double.Type) throws -> Double
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: Float.Type) throws -> Float
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: Int.Type) throws -> Int
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: Int8.Type) throws -> Int8
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: Int16.Type) throws -> Int16
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: Int32.Type) throws -> Int32
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: Int64.Type) throws -> Int64
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: UInt.Type) throws -> UInt
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: UInt8.Type) throws -> UInt8
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: UInt16.Type) throws -> UInt16
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: UInt32.Type) throws -> UInt32
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode(_ type: UInt64.Type) throws -> UInt64
|
|
|
|
/// Decodes a single value of the given type.
|
|
///
|
|
/// - parameter type: The type to decode as.
|
|
/// - returns: A value of the requested type.
|
|
/// - throws: `DecodingError.typeMismatch` if the encountered encoded value
|
|
/// cannot be converted to the requested type.
|
|
/// - throws: `DecodingError.valueNotFound` if the encountered encoded value
|
|
/// is null.
|
|
func decode<T: Decodable>(_ type: T.Type) throws -> T
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// User Info
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// A user-defined key for providing context during encoding and decoding.
|
|
public struct CodingUserInfoKey: RawRepresentable, Equatable, Hashable, ConcurrentValue {
|
|
public typealias RawValue = String
|
|
|
|
/// The key's string value.
|
|
public let rawValue: String
|
|
|
|
/// Creates a new instance with the given raw value.
|
|
///
|
|
/// - parameter rawValue: The value of the key.
|
|
public init?(rawValue: String) {
|
|
self.rawValue = rawValue
|
|
}
|
|
|
|
/// Returns a Boolean value indicating whether the given keys are equal.
|
|
///
|
|
/// - parameter lhs: The key to compare against.
|
|
/// - parameter rhs: The key to compare with.
|
|
public static func ==(
|
|
lhs: CodingUserInfoKey,
|
|
rhs: CodingUserInfoKey
|
|
) -> Bool {
|
|
return lhs.rawValue == rhs.rawValue
|
|
}
|
|
|
|
/// The key's hash value.
|
|
public var hashValue: Int {
|
|
return self.rawValue.hashValue
|
|
}
|
|
|
|
/// Hashes the essential components of this value by feeding them into the
|
|
/// given hasher.
|
|
///
|
|
/// - Parameter hasher: The hasher to use when combining the components
|
|
/// of this instance.
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(self.rawValue)
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Errors
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// An error that occurs during the encoding of a value.
|
|
public enum EncodingError: Error {
|
|
/// The context in which the error occurred.
|
|
public struct Context {
|
|
/// The path of coding keys taken to get to the point of the failing encode
|
|
/// call.
|
|
public let codingPath: [CodingKey]
|
|
|
|
/// A description of what went wrong, for debugging purposes.
|
|
public let debugDescription: String
|
|
|
|
/// The underlying error which caused this error, if any.
|
|
public let underlyingError: Error?
|
|
|
|
/// Creates a new context with the given path of coding keys and a
|
|
/// description of what went wrong.
|
|
///
|
|
/// - parameter codingPath: The path of coding keys taken to get to the
|
|
/// point of the failing encode call.
|
|
/// - parameter debugDescription: A description of what went wrong, for
|
|
/// debugging purposes.
|
|
/// - parameter underlyingError: The underlying error which caused this
|
|
/// error, if any.
|
|
public init(
|
|
codingPath: [CodingKey],
|
|
debugDescription: String,
|
|
underlyingError: Error? = nil
|
|
) {
|
|
self.codingPath = codingPath
|
|
self.debugDescription = debugDescription
|
|
self.underlyingError = underlyingError
|
|
}
|
|
}
|
|
|
|
/// An indication that an encoder or its containers could not encode the
|
|
/// given value.
|
|
///
|
|
/// As associated values, this case contains the attempted value and context
|
|
/// for debugging.
|
|
case invalidValue(Any, Context)
|
|
|
|
// MARK: - NSError Bridging
|
|
|
|
// CustomNSError bridging applies only when the CustomNSError conformance is
|
|
// applied in the same module as the declared error type. Since we cannot
|
|
// access CustomNSError (which is defined in Foundation) from here, we can
|
|
// use the "hidden" entry points.
|
|
|
|
public var _domain: String {
|
|
return "NSCocoaErrorDomain"
|
|
}
|
|
|
|
public var _code: Int {
|
|
switch self {
|
|
case .invalidValue: return 4866
|
|
}
|
|
}
|
|
|
|
public var _userInfo: AnyObject? {
|
|
// The error dictionary must be returned as an AnyObject. We can do this
|
|
// only on platforms with bridging, unfortunately.
|
|
#if _runtime(_ObjC)
|
|
let context: Context
|
|
switch self {
|
|
case .invalidValue(_, let c): context = c
|
|
}
|
|
|
|
var userInfo: [String: Any] = [
|
|
"NSCodingPath": context.codingPath,
|
|
"NSDebugDescription": context.debugDescription
|
|
]
|
|
|
|
if let underlyingError = context.underlyingError {
|
|
userInfo["NSUnderlyingError"] = underlyingError
|
|
}
|
|
|
|
return userInfo as AnyObject
|
|
#else
|
|
return nil
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// An error that occurs during the decoding of a value.
|
|
public enum DecodingError: Error {
|
|
/// The context in which the error occurred.
|
|
public struct Context {
|
|
/// The path of coding keys taken to get to the point of the failing decode
|
|
/// call.
|
|
public let codingPath: [CodingKey]
|
|
|
|
/// A description of what went wrong, for debugging purposes.
|
|
public let debugDescription: String
|
|
|
|
/// The underlying error which caused this error, if any.
|
|
public let underlyingError: Error?
|
|
|
|
/// Creates a new context with the given path of coding keys and a
|
|
/// description of what went wrong.
|
|
///
|
|
/// - parameter codingPath: The path of coding keys taken to get to the
|
|
/// point of the failing decode call.
|
|
/// - parameter debugDescription: A description of what went wrong, for
|
|
/// debugging purposes.
|
|
/// - parameter underlyingError: The underlying error which caused this
|
|
/// error, if any.
|
|
public init(
|
|
codingPath: [CodingKey],
|
|
debugDescription: String,
|
|
underlyingError: Error? = nil
|
|
) {
|
|
self.codingPath = codingPath
|
|
self.debugDescription = debugDescription
|
|
self.underlyingError = underlyingError
|
|
}
|
|
}
|
|
|
|
/// An indication that a value of the given type could not be decoded because
|
|
/// it did not match the type of what was found in the encoded payload.
|
|
///
|
|
/// As associated values, this case contains the attempted type and context
|
|
/// for debugging.
|
|
case typeMismatch(Any.Type, Context)
|
|
|
|
/// An indication that a non-optional value of the given type was expected,
|
|
/// but a null value was found.
|
|
///
|
|
/// As associated values, this case contains the attempted type and context
|
|
/// for debugging.
|
|
case valueNotFound(Any.Type, Context)
|
|
|
|
/// An indication that a keyed decoding container was asked for an entry for
|
|
/// the given key, but did not contain one.
|
|
///
|
|
/// As associated values, this case contains the attempted key and context
|
|
/// for debugging.
|
|
case keyNotFound(CodingKey, Context)
|
|
|
|
/// An indication that the data is corrupted or otherwise invalid.
|
|
///
|
|
/// As an associated value, this case contains the context for debugging.
|
|
case dataCorrupted(Context)
|
|
|
|
// MARK: - NSError Bridging
|
|
|
|
// CustomNSError bridging applies only when the CustomNSError conformance is
|
|
// applied in the same module as the declared error type. Since we cannot
|
|
// access CustomNSError (which is defined in Foundation) from here, we can
|
|
// use the "hidden" entry points.
|
|
|
|
public var _domain: String {
|
|
return "NSCocoaErrorDomain"
|
|
}
|
|
|
|
public var _code: Int {
|
|
switch self {
|
|
case .keyNotFound, .valueNotFound: return 4865
|
|
case .typeMismatch, .dataCorrupted: return 4864
|
|
}
|
|
}
|
|
|
|
public var _userInfo: AnyObject? {
|
|
// The error dictionary must be returned as an AnyObject. We can do this
|
|
// only on platforms with bridging, unfortunately.
|
|
#if _runtime(_ObjC)
|
|
let context: Context
|
|
switch self {
|
|
case .keyNotFound(_, let c): context = c
|
|
case .valueNotFound(_, let c): context = c
|
|
case .typeMismatch(_, let c): context = c
|
|
case .dataCorrupted( let c): context = c
|
|
}
|
|
|
|
var userInfo: [String: Any] = [
|
|
"NSCodingPath": context.codingPath,
|
|
"NSDebugDescription": context.debugDescription
|
|
]
|
|
|
|
if let underlyingError = context.underlyingError {
|
|
userInfo["NSUnderlyingError"] = underlyingError
|
|
}
|
|
|
|
return userInfo as AnyObject
|
|
#else
|
|
return nil
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// The following extensions allow for easier error construction.
|
|
|
|
internal struct _GenericIndexKey: CodingKey, ConcurrentValue {
|
|
internal var stringValue: String
|
|
internal var intValue: Int?
|
|
|
|
internal init?(stringValue: String) {
|
|
return nil
|
|
}
|
|
|
|
internal init?(intValue: Int) {
|
|
self.stringValue = "Index \(intValue)"
|
|
self.intValue = intValue
|
|
}
|
|
}
|
|
|
|
extension DecodingError {
|
|
/// Returns a new `.dataCorrupted` error using a constructed coding path and
|
|
/// the given debug description.
|
|
///
|
|
/// The coding path for the returned error is constructed by appending the
|
|
/// given key to the given container's coding path.
|
|
///
|
|
/// - param key: The key which caused the failure.
|
|
/// - param container: The container in which the corrupted data was
|
|
/// accessed.
|
|
/// - param debugDescription: A description of the error to aid in debugging.
|
|
///
|
|
/// - Returns: A new `.dataCorrupted` error with the given information.
|
|
public static func dataCorruptedError<C: KeyedDecodingContainerProtocol>(
|
|
forKey key: C.Key,
|
|
in container: C,
|
|
debugDescription: String
|
|
) -> DecodingError {
|
|
let context = DecodingError.Context(
|
|
codingPath: container.codingPath + [key],
|
|
debugDescription: debugDescription)
|
|
return .dataCorrupted(context)
|
|
}
|
|
|
|
/// Returns a new `.dataCorrupted` error using a constructed coding path and
|
|
/// the given debug description.
|
|
///
|
|
/// The coding path for the returned error is constructed by appending the
|
|
/// given container's current index to its coding path.
|
|
///
|
|
/// - param container: The container in which the corrupted data was
|
|
/// accessed.
|
|
/// - param debugDescription: A description of the error to aid in debugging.
|
|
///
|
|
/// - Returns: A new `.dataCorrupted` error with the given information.
|
|
public static func dataCorruptedError(
|
|
in container: UnkeyedDecodingContainer,
|
|
debugDescription: String
|
|
) -> DecodingError {
|
|
let context = DecodingError.Context(
|
|
codingPath: container.codingPath +
|
|
[_GenericIndexKey(intValue: container.currentIndex)!],
|
|
debugDescription: debugDescription)
|
|
return .dataCorrupted(context)
|
|
}
|
|
|
|
/// Returns a new `.dataCorrupted` error using a constructed coding path and
|
|
/// the given debug description.
|
|
///
|
|
/// The coding path for the returned error is the given container's coding
|
|
/// path.
|
|
///
|
|
/// - param container: The container in which the corrupted data was
|
|
/// accessed.
|
|
/// - param debugDescription: A description of the error to aid in debugging.
|
|
///
|
|
/// - Returns: A new `.dataCorrupted` error with the given information.
|
|
public static func dataCorruptedError(
|
|
in container: SingleValueDecodingContainer,
|
|
debugDescription: String
|
|
) -> DecodingError {
|
|
let context = DecodingError.Context(codingPath: container.codingPath,
|
|
debugDescription: debugDescription)
|
|
return .dataCorrupted(context)
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Keyed Encoding Container Implementations
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
internal class _KeyedEncodingContainerBase {
|
|
internal init(){}
|
|
|
|
deinit {}
|
|
|
|
// These must all be given a concrete implementation in _*Box.
|
|
internal var codingPath: [CodingKey] {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeNil<K: CodingKey>(forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: Bool, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: String, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: Double, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: Float, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: Int, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: Int8, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: Int16, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: Int32, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: Int64, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: UInt, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: UInt8, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: UInt16, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: UInt32, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<K: CodingKey>(_ value: UInt64, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encode<T: Encodable, K: CodingKey>(_ value: T, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeConditional<T: AnyObject & Encodable, K: CodingKey>(
|
|
_ object: T,
|
|
forKey key: K
|
|
) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: Bool?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: String?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: Double?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: Float?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: Int?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: Int8?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: Int16?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: Int32?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: Int64?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: UInt?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: UInt8?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: UInt16?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: UInt32?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<K: CodingKey>(_ value: UInt64?, forKey key: K) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func encodeIfPresent<T: Encodable, K: CodingKey>(
|
|
_ value: T?,
|
|
forKey key: K
|
|
) throws {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func nestedContainer<NestedKey, K: CodingKey>(
|
|
keyedBy keyType: NestedKey.Type,
|
|
forKey key: K
|
|
) -> KeyedEncodingContainer<NestedKey> {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func nestedUnkeyedContainer<K: CodingKey>(
|
|
forKey key: K
|
|
) -> UnkeyedEncodingContainer {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func superEncoder() -> Encoder {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func superEncoder<K: CodingKey>(forKey key: K) -> Encoder {
|
|
fatalError("_KeyedEncodingContainerBase cannot be used directly.")
|
|
}
|
|
}
|
|
|
|
internal final class _KeyedEncodingContainerBox<
|
|
Concrete: KeyedEncodingContainerProtocol
|
|
>: _KeyedEncodingContainerBase {
|
|
typealias Key = Concrete.Key
|
|
|
|
internal var concrete: Concrete
|
|
|
|
internal init(_ container: Concrete) {
|
|
concrete = container
|
|
}
|
|
|
|
override internal var codingPath: [CodingKey] {
|
|
return concrete.codingPath
|
|
}
|
|
|
|
override internal func encodeNil<K: CodingKey>(forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeNil(forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: Bool, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: String, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: Double, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: Float, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: Int, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: Int8, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: Int16, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: Int32, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: Int64, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: UInt, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: UInt8, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: UInt16, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: UInt32, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<K: CodingKey>(_ value: UInt64, forKey key: K) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encode<T: Encodable, K: CodingKey>(
|
|
_ value: T,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encode(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeConditional<T: AnyObject & Encodable, K: CodingKey>(
|
|
_ object: T,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeConditional(object, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: Bool?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: String?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: Double?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: Float?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: Int?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: Int8?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: Int16?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: Int32?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: Int64?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: UInt?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: UInt8?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: UInt16?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: UInt32?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<K: CodingKey>(
|
|
_ value: UInt64?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func encodeIfPresent<T: Encodable, K: CodingKey>(
|
|
_ value: T?,
|
|
forKey key: K
|
|
) throws {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
try concrete.encodeIfPresent(value, forKey: key)
|
|
}
|
|
|
|
override internal func nestedContainer<NestedKey, K: CodingKey>(
|
|
keyedBy keyType: NestedKey.Type,
|
|
forKey key: K
|
|
) -> KeyedEncodingContainer<NestedKey> {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return concrete.nestedContainer(keyedBy: NestedKey.self, forKey: key)
|
|
}
|
|
|
|
override internal func nestedUnkeyedContainer<K: CodingKey>(
|
|
forKey key: K
|
|
) -> UnkeyedEncodingContainer {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return concrete.nestedUnkeyedContainer(forKey: key)
|
|
}
|
|
|
|
override internal func superEncoder() -> Encoder {
|
|
return concrete.superEncoder()
|
|
}
|
|
|
|
override internal func superEncoder<K: CodingKey>(forKey key: K) -> Encoder {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return concrete.superEncoder(forKey: key)
|
|
}
|
|
}
|
|
|
|
internal class _KeyedDecodingContainerBase {
|
|
internal init(){}
|
|
|
|
deinit {}
|
|
|
|
internal var codingPath: [CodingKey] {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal var allKeys: [CodingKey] {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func contains<K: CodingKey>(_ key: K) -> Bool {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeNil<K: CodingKey>(forKey key: K) throws -> Bool {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: Bool.Type,
|
|
forKey key: K
|
|
) throws -> Bool {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: String.Type,
|
|
forKey key: K
|
|
) throws -> String {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: Double.Type,
|
|
forKey key: K
|
|
) throws -> Double {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: Float.Type,
|
|
forKey key: K
|
|
) throws -> Float {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: Int.Type,
|
|
forKey key: K
|
|
) throws -> Int {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: Int8.Type,
|
|
forKey key: K
|
|
) throws -> Int8 {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: Int16.Type,
|
|
forKey key: K
|
|
) throws -> Int16 {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: Int32.Type,
|
|
forKey key: K
|
|
) throws -> Int32 {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: Int64.Type,
|
|
forKey key: K
|
|
) throws -> Int64 {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: UInt.Type,
|
|
forKey key: K
|
|
) throws -> UInt {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: UInt8.Type,
|
|
forKey key: K
|
|
) throws -> UInt8 {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: UInt16.Type,
|
|
forKey key: K
|
|
) throws -> UInt16 {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: UInt32.Type,
|
|
forKey key: K
|
|
) throws -> UInt32 {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<K: CodingKey>(
|
|
_ type: UInt64.Type,
|
|
forKey key: K
|
|
) throws -> UInt64 {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decode<T: Decodable, K: CodingKey>(
|
|
_ type: T.Type,
|
|
forKey key: K
|
|
) throws -> T {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Bool.Type,
|
|
forKey key: K
|
|
) throws -> Bool? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: String.Type,
|
|
forKey key: K
|
|
) throws -> String? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Double.Type,
|
|
forKey key: K
|
|
) throws -> Double? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Float.Type,
|
|
forKey key: K
|
|
) throws -> Float? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Int.Type,
|
|
forKey key: K
|
|
) throws -> Int? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Int8.Type,
|
|
forKey key: K
|
|
) throws -> Int8? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Int16.Type,
|
|
forKey key: K
|
|
) throws -> Int16? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Int32.Type,
|
|
forKey key: K
|
|
) throws -> Int32? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Int64.Type,
|
|
forKey key: K
|
|
) throws -> Int64? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: UInt.Type,
|
|
forKey key: K
|
|
) throws -> UInt? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: UInt8.Type,
|
|
forKey key: K
|
|
) throws -> UInt8? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: UInt16.Type,
|
|
forKey key: K
|
|
) throws -> UInt16? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: UInt32.Type,
|
|
forKey key: K
|
|
) throws -> UInt32? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: UInt64.Type,
|
|
forKey key: K
|
|
) throws -> UInt64? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func decodeIfPresent<T: Decodable, K: CodingKey>(
|
|
_ type: T.Type,
|
|
forKey key: K
|
|
) throws -> T? {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func nestedContainer<NestedKey, K: CodingKey>(
|
|
keyedBy type: NestedKey.Type,
|
|
forKey key: K
|
|
) throws -> KeyedDecodingContainer<NestedKey> {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func nestedUnkeyedContainer<K: CodingKey>(
|
|
forKey key: K
|
|
) throws -> UnkeyedDecodingContainer {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func superDecoder() throws -> Decoder {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
|
|
internal func superDecoder<K: CodingKey>(forKey key: K) throws -> Decoder {
|
|
fatalError("_KeyedDecodingContainerBase cannot be used directly.")
|
|
}
|
|
}
|
|
|
|
internal final class _KeyedDecodingContainerBox<
|
|
Concrete: KeyedDecodingContainerProtocol
|
|
>: _KeyedDecodingContainerBase {
|
|
typealias Key = Concrete.Key
|
|
|
|
internal var concrete: Concrete
|
|
|
|
internal init(_ container: Concrete) {
|
|
concrete = container
|
|
}
|
|
|
|
override var codingPath: [CodingKey] {
|
|
return concrete.codingPath
|
|
}
|
|
|
|
override var allKeys: [CodingKey] {
|
|
return concrete.allKeys
|
|
}
|
|
|
|
override internal func contains<K: CodingKey>(_ key: K) -> Bool {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return concrete.contains(key)
|
|
}
|
|
|
|
override internal func decodeNil<K: CodingKey>(forKey key: K) throws -> Bool {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeNil(forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: Bool.Type,
|
|
forKey key: K
|
|
) throws -> Bool {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(Bool.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: String.Type,
|
|
forKey key: K
|
|
) throws -> String {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(String.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: Double.Type,
|
|
forKey key: K
|
|
) throws -> Double {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(Double.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: Float.Type,
|
|
forKey key: K
|
|
) throws -> Float {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(Float.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: Int.Type,
|
|
forKey key: K
|
|
) throws -> Int {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(Int.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: Int8.Type,
|
|
forKey key: K
|
|
) throws -> Int8 {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(Int8.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: Int16.Type,
|
|
forKey key: K
|
|
) throws -> Int16 {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(Int16.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: Int32.Type,
|
|
forKey key: K
|
|
) throws -> Int32 {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(Int32.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: Int64.Type,
|
|
forKey key: K
|
|
) throws -> Int64 {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(Int64.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: UInt.Type,
|
|
forKey key: K
|
|
) throws -> UInt {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(UInt.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: UInt8.Type,
|
|
forKey key: K
|
|
) throws -> UInt8 {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(UInt8.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: UInt16.Type,
|
|
forKey key: K
|
|
) throws -> UInt16 {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(UInt16.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: UInt32.Type,
|
|
forKey key: K
|
|
) throws -> UInt32 {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(UInt32.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<K: CodingKey>(
|
|
_ type: UInt64.Type,
|
|
forKey key: K
|
|
) throws -> UInt64 {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(UInt64.self, forKey: key)
|
|
}
|
|
|
|
override internal func decode<T: Decodable, K: CodingKey>(
|
|
_ type: T.Type,
|
|
forKey key: K
|
|
) throws -> T {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decode(T.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Bool.Type,
|
|
forKey key: K
|
|
) throws -> Bool? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(Bool.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: String.Type,
|
|
forKey key: K
|
|
) throws -> String? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(String.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Double.Type,
|
|
forKey key: K
|
|
) throws -> Double? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(Double.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Float.Type,
|
|
forKey key: K
|
|
) throws -> Float? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(Float.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Int.Type,
|
|
forKey key: K
|
|
) throws -> Int? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(Int.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Int8.Type,
|
|
forKey key: K
|
|
) throws -> Int8? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(Int8.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Int16.Type,
|
|
forKey key: K
|
|
) throws -> Int16? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(Int16.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Int32.Type,
|
|
forKey key: K
|
|
) throws -> Int32? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(Int32.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: Int64.Type,
|
|
forKey key: K
|
|
) throws -> Int64? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(Int64.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: UInt.Type,
|
|
forKey key: K
|
|
) throws -> UInt? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(UInt.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: UInt8.Type,
|
|
forKey key: K
|
|
) throws -> UInt8? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(UInt8.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: UInt16.Type,
|
|
forKey key: K
|
|
) throws -> UInt16? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(UInt16.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: UInt32.Type,
|
|
forKey key: K
|
|
) throws -> UInt32? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(UInt32.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<K: CodingKey>(
|
|
_ type: UInt64.Type,
|
|
forKey key: K
|
|
) throws -> UInt64? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(UInt64.self, forKey: key)
|
|
}
|
|
|
|
override internal func decodeIfPresent<T: Decodable, K: CodingKey>(
|
|
_ type: T.Type,
|
|
forKey key: K
|
|
) throws -> T? {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.decodeIfPresent(T.self, forKey: key)
|
|
}
|
|
|
|
override internal func nestedContainer<NestedKey, K: CodingKey>(
|
|
keyedBy type: NestedKey.Type,
|
|
forKey key: K
|
|
) throws -> KeyedDecodingContainer<NestedKey> {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.nestedContainer(keyedBy: NestedKey.self, forKey: key)
|
|
}
|
|
|
|
override internal func nestedUnkeyedContainer<K: CodingKey>(
|
|
forKey key: K
|
|
) throws -> UnkeyedDecodingContainer {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.nestedUnkeyedContainer(forKey: key)
|
|
}
|
|
|
|
override internal func superDecoder() throws -> Decoder {
|
|
return try concrete.superDecoder()
|
|
}
|
|
|
|
override internal func superDecoder<K: CodingKey>(forKey key: K) throws -> Decoder {
|
|
assert(K.self == Key.self)
|
|
let key = unsafeBitCast(key, to: Key.self)
|
|
return try concrete.superDecoder(forKey: key)
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Primitive and RawRepresentable Extensions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
extension Bool: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(Bool.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Bool, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `Bool`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Bool, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `Bool`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension String: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(String.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == String, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `String`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == String, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `String`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension Double: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(Double.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Double, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `Double`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Double, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `Double`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension Float: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(Float.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Float, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `Float`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Float, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `Float`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
#if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
|
|
@available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
|
|
extension Float16: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let floatValue = try Float(from: decoder)
|
|
self = Float16(floatValue)
|
|
if isInfinite && floatValue.isFinite {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Parsed JSON number \(floatValue) does not fit in Float16."
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
try Float(self).encode(to: encoder)
|
|
}
|
|
}
|
|
#endif
|
|
|
|
extension Int: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(Int.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Int, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `Int`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Int, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `Int`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension Int8: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(Int8.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Int8, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `Int8`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Int8, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `Int8`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension Int16: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(Int16.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Int16, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `Int16`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Int16, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `Int16`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension Int32: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(Int32.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Int32, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `Int32`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Int32, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `Int32`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension Int64: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(Int64.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Int64, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `Int64`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == Int64, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `Int64`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension UInt: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(UInt.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == UInt, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `UInt`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == UInt, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `UInt`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension UInt8: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(UInt8.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == UInt8, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `UInt8`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == UInt8, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `UInt8`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension UInt16: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(UInt16.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == UInt16, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `UInt16`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == UInt16, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `UInt16`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension UInt32: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(UInt32.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == UInt32, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `UInt32`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == UInt32, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `UInt32`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
extension UInt64: Codable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self = try decoder.singleValueContainer().decode(UInt64.self)
|
|
}
|
|
|
|
/// Encodes this value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == UInt64, Self: Encodable {
|
|
/// Encodes this value into the given encoder, when the type's `RawValue`
|
|
/// is `UInt64`.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(self.rawValue)
|
|
}
|
|
}
|
|
|
|
extension RawRepresentable where RawValue == UInt64, Self: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder, when the
|
|
/// type's `RawValue` is `UInt64`.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let decoded = try decoder.singleValueContainer().decode(RawValue.self)
|
|
guard let value = Self(rawValue: decoded) else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Cannot initialize \(Self.self) from invalid \(RawValue.self) value \(decoded)"
|
|
)
|
|
)
|
|
}
|
|
|
|
self = value
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Optional/Collection Type Conformances
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
extension Optional: Encodable where Wrapped: Encodable {
|
|
/// Encodes this optional value into the given encoder.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
switch self {
|
|
case .none: try container.encodeNil()
|
|
case .some(let wrapped): try container.encode(wrapped)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension Optional: Decodable where Wrapped: Decodable {
|
|
/// Creates a new instance by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
let container = try decoder.singleValueContainer()
|
|
if container.decodeNil() {
|
|
self = .none
|
|
} else {
|
|
let element = try container.decode(Wrapped.self)
|
|
self = .some(element)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension Array: Encodable where Element: Encodable {
|
|
/// Encodes the elements of this array into the given encoder in an unkeyed
|
|
/// container.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.unkeyedContainer()
|
|
for element in self {
|
|
try container.encode(element)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension Array: Decodable where Element: Decodable {
|
|
/// Creates a new array by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self.init()
|
|
|
|
var container = try decoder.unkeyedContainer()
|
|
while !container.isAtEnd {
|
|
let element = try container.decode(Element.self)
|
|
self.append(element)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension ContiguousArray: Encodable where Element: Encodable {
|
|
/// Encodes the elements of this contiguous array into the given encoder
|
|
/// in an unkeyed container.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.unkeyedContainer()
|
|
for element in self {
|
|
try container.encode(element)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension ContiguousArray: Decodable where Element: Decodable {
|
|
/// Creates a new contiguous array by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self.init()
|
|
|
|
var container = try decoder.unkeyedContainer()
|
|
while !container.isAtEnd {
|
|
let element = try container.decode(Element.self)
|
|
self.append(element)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension Set: Encodable where Element: Encodable {
|
|
/// Encodes the elements of this set into the given encoder in an unkeyed
|
|
/// container.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.unkeyedContainer()
|
|
for element in self {
|
|
try container.encode(element)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension Set: Decodable where Element: Decodable {
|
|
/// Creates a new set by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self.init()
|
|
|
|
var container = try decoder.unkeyedContainer()
|
|
while !container.isAtEnd {
|
|
let element = try container.decode(Element.self)
|
|
self.insert(element)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A wrapper for dictionary keys which are Strings or Ints.
|
|
internal struct _DictionaryCodingKey: CodingKey {
|
|
internal let stringValue: String
|
|
internal let intValue: Int?
|
|
|
|
internal init?(stringValue: String) {
|
|
self.stringValue = stringValue
|
|
self.intValue = Int(stringValue)
|
|
}
|
|
|
|
internal init?(intValue: Int) {
|
|
self.stringValue = "\(intValue)"
|
|
self.intValue = intValue
|
|
}
|
|
}
|
|
|
|
extension Dictionary: Encodable where Key: Encodable, Value: Encodable {
|
|
/// Encodes the contents of this dictionary into the given encoder.
|
|
///
|
|
/// If the dictionary uses `String` or `Int` keys, the contents are encoded
|
|
/// in a keyed container. Otherwise, the contents are encoded as alternating
|
|
/// key-value pairs in an unkeyed container.
|
|
///
|
|
/// This function throws an error if any values are invalid for the given
|
|
/// encoder's format.
|
|
///
|
|
/// - Parameter encoder: The encoder to write data to.
|
|
public func encode(to encoder: Encoder) throws {
|
|
if Key.self == String.self {
|
|
// Since the keys are already Strings, we can use them as keys directly.
|
|
var container = encoder.container(keyedBy: _DictionaryCodingKey.self)
|
|
for (key, value) in self {
|
|
let codingKey = _DictionaryCodingKey(stringValue: key as! String)!
|
|
try container.encode(value, forKey: codingKey)
|
|
}
|
|
} else if Key.self == Int.self {
|
|
// Since the keys are already Ints, we can use them as keys directly.
|
|
var container = encoder.container(keyedBy: _DictionaryCodingKey.self)
|
|
for (key, value) in self {
|
|
let codingKey = _DictionaryCodingKey(intValue: key as! Int)!
|
|
try container.encode(value, forKey: codingKey)
|
|
}
|
|
} else {
|
|
// Keys are Encodable but not Strings or Ints, so we cannot arbitrarily
|
|
// convert to keys. We can encode as an array of alternating key-value
|
|
// pairs, though.
|
|
var container = encoder.unkeyedContainer()
|
|
for (key, value) in self {
|
|
try container.encode(key)
|
|
try container.encode(value)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extension Dictionary: Decodable where Key: Decodable, Value: Decodable {
|
|
/// Creates a new dictionary by decoding from the given decoder.
|
|
///
|
|
/// This initializer throws an error if reading from the decoder fails, or
|
|
/// if the data read is corrupted or otherwise invalid.
|
|
///
|
|
/// - Parameter decoder: The decoder to read data from.
|
|
public init(from decoder: Decoder) throws {
|
|
self.init()
|
|
|
|
if Key.self == String.self {
|
|
// The keys are Strings, so we should be able to expect a keyed container.
|
|
let container = try decoder.container(keyedBy: _DictionaryCodingKey.self)
|
|
for key in container.allKeys {
|
|
let value = try container.decode(Value.self, forKey: key)
|
|
self[key.stringValue as! Key] = value
|
|
}
|
|
} else if Key.self == Int.self {
|
|
// The keys are Ints, so we should be able to expect a keyed container.
|
|
let container = try decoder.container(keyedBy: _DictionaryCodingKey.self)
|
|
for key in container.allKeys {
|
|
guard key.intValue != nil else {
|
|
// We provide stringValues for Int keys; if an encoder chooses not to
|
|
// use the actual intValues, we've encoded string keys.
|
|
// So on init, _DictionaryCodingKey tries to parse string keys as
|
|
// Ints. If that succeeds, then we would have had an intValue here.
|
|
// We don't, so this isn't a valid Int key.
|
|
var codingPath = decoder.codingPath
|
|
codingPath.append(key)
|
|
throw DecodingError.typeMismatch(
|
|
Int.self,
|
|
DecodingError.Context(
|
|
codingPath: codingPath,
|
|
debugDescription: "Expected Int key but found String key instead."
|
|
)
|
|
)
|
|
}
|
|
|
|
let value = try container.decode(Value.self, forKey: key)
|
|
self[key.intValue! as! Key] = value
|
|
}
|
|
} else {
|
|
// We should have encoded as an array of alternating key-value pairs.
|
|
var container = try decoder.unkeyedContainer()
|
|
|
|
// We're expecting to get pairs. If the container has a known count, it
|
|
// had better be even; no point in doing work if not.
|
|
if let count = container.count {
|
|
guard count % 2 == 0 else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Expected collection of key-value pairs; encountered odd-length array instead."
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
while !container.isAtEnd {
|
|
let key = try container.decode(Key.self)
|
|
|
|
guard !container.isAtEnd else {
|
|
throw DecodingError.dataCorrupted(
|
|
DecodingError.Context(
|
|
codingPath: decoder.codingPath,
|
|
debugDescription: "Unkeyed container reached end before value in key-value pair."
|
|
)
|
|
)
|
|
}
|
|
|
|
let value = try container.decode(Value.self)
|
|
self[key] = value
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Convenience Default Implementations
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Default implementation of encodeConditional(_:forKey:) in terms of
|
|
// encode(_:forKey:)
|
|
extension KeyedEncodingContainerProtocol {
|
|
public mutating func encodeConditional<T: AnyObject & Encodable>(
|
|
_ object: T,
|
|
forKey key: Key
|
|
) throws {
|
|
try encode(object, forKey: key)
|
|
}
|
|
}
|
|
|
|
// Default implementation of encodeIfPresent(_:forKey:) in terms of
|
|
// encode(_:forKey:)
|
|
extension KeyedEncodingContainerProtocol {
|
|
public mutating func encodeIfPresent(
|
|
_ value: Bool?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: String?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: Double?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: Float?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: Int?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: Int8?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: Int16?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: Int32?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: Int64?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: UInt?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: UInt8?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: UInt16?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: UInt32?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent(
|
|
_ value: UInt64?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
|
|
public mutating func encodeIfPresent<T: Encodable>(
|
|
_ value: T?,
|
|
forKey key: Key
|
|
) throws {
|
|
guard let value = value else { return }
|
|
try encode(value, forKey: key)
|
|
}
|
|
}
|
|
|
|
// Default implementation of decodeIfPresent(_:forKey:) in terms of
|
|
// decode(_:forKey:) and decodeNil(forKey:)
|
|
extension KeyedDecodingContainerProtocol {
|
|
public func decodeIfPresent(
|
|
_ type: Bool.Type,
|
|
forKey key: Key
|
|
) throws -> Bool? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(Bool.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: String.Type,
|
|
forKey key: Key
|
|
) throws -> String? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(String.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: Double.Type,
|
|
forKey key: Key
|
|
) throws -> Double? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(Double.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: Float.Type,
|
|
forKey key: Key
|
|
) throws -> Float? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(Float.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: Int.Type,
|
|
forKey key: Key
|
|
) throws -> Int? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(Int.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: Int8.Type,
|
|
forKey key: Key
|
|
) throws -> Int8? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(Int8.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: Int16.Type,
|
|
forKey key: Key
|
|
) throws -> Int16? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(Int16.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: Int32.Type,
|
|
forKey key: Key
|
|
) throws -> Int32? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(Int32.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: Int64.Type,
|
|
forKey key: Key
|
|
) throws -> Int64? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(Int64.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: UInt.Type,
|
|
forKey key: Key
|
|
) throws -> UInt? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(UInt.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: UInt8.Type,
|
|
forKey key: Key
|
|
) throws -> UInt8? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(UInt8.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: UInt16.Type,
|
|
forKey key: Key
|
|
) throws -> UInt16? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(UInt16.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: UInt32.Type,
|
|
forKey key: Key
|
|
) throws -> UInt32? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(UInt32.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent(
|
|
_ type: UInt64.Type,
|
|
forKey key: Key
|
|
) throws -> UInt64? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(UInt64.self, forKey: key)
|
|
}
|
|
|
|
public func decodeIfPresent<T: Decodable>(
|
|
_ type: T.Type,
|
|
forKey key: Key
|
|
) throws -> T? {
|
|
guard try self.contains(key) && !self.decodeNil(forKey: key)
|
|
else { return nil }
|
|
return try self.decode(T.self, forKey: key)
|
|
}
|
|
}
|
|
|
|
// Default implementation of encodeConditional(_:) in terms of encode(_:),
|
|
// and encode(contentsOf:) in terms of encode(_:) loop.
|
|
extension UnkeyedEncodingContainer {
|
|
public mutating func encodeConditional<T: AnyObject & Encodable>(
|
|
_ object: T
|
|
) throws {
|
|
try self.encode(object)
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Bool {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == String {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Double {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Float {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Int {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Int8 {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Int16 {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Int32 {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == Int64 {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == UInt {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == UInt8 {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == UInt16 {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == UInt32 {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element == UInt64 {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
|
|
public mutating func encode<T: Sequence>(
|
|
contentsOf sequence: T
|
|
) throws where T.Element: Encodable {
|
|
for element in sequence {
|
|
try self.encode(element)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Default implementation of decodeIfPresent(_:) in terms of decode(_:) and
|
|
// decodeNil()
|
|
extension UnkeyedDecodingContainer {
|
|
public mutating func decodeIfPresent(
|
|
_ type: Bool.Type
|
|
) throws -> Bool? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(Bool.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: String.Type
|
|
) throws -> String? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(String.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: Double.Type
|
|
) throws -> Double? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(Double.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: Float.Type
|
|
) throws -> Float? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(Float.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: Int.Type
|
|
) throws -> Int? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(Int.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: Int8.Type
|
|
) throws -> Int8? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(Int8.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: Int16.Type
|
|
) throws -> Int16? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(Int16.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: Int32.Type
|
|
) throws -> Int32? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(Int32.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: Int64.Type
|
|
) throws -> Int64? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(Int64.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: UInt.Type
|
|
) throws -> UInt? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(UInt.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: UInt8.Type
|
|
) throws -> UInt8? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(UInt8.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: UInt16.Type
|
|
) throws -> UInt16? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(UInt16.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: UInt32.Type
|
|
) throws -> UInt32? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(UInt32.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent(
|
|
_ type: UInt64.Type
|
|
) throws -> UInt64? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(UInt64.self)
|
|
}
|
|
|
|
public mutating func decodeIfPresent<T: Decodable>(
|
|
_ type: T.Type
|
|
) throws -> T? {
|
|
guard try !self.isAtEnd && !self.decodeNil() else { return nil }
|
|
return try self.decode(T.self)
|
|
}
|
|
}
|