Codable.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.
publicprotocolEncodable{
 /// 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.
publicprotocolDecodable{
 /// 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.
publictypealiasCodable=Encodable&Decodable

//===----------------------------------------------------------------------===//
// CodingKey
//===----------------------------------------------------------------------===//

/// A type that can be used as a key for encoding and decoding.
publicprotocolCodingKey:CustomStringConvertible,
CustomDebugStringConvertible{
 /// The string to use in a named collection (e.g. a string-keyed dictionary).
varstringValue: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).
varintValue: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)
}

extensionCodingKey{
 /// A textual representation of this key.
publicvardescription:String{
letintValue=self.intValue?.description ??"nil"
return"\(type(of:self))(stringValue: \"\(stringValue)\", intValue: \(intValue))"
}

 /// A textual representation of this key, suitable for debugging.
publicvardebugDescription:String{
return description
}
}

//===----------------------------------------------------------------------===//
// Encoder & Decoder
//===----------------------------------------------------------------------===//

/// A type that can encode values into a native format for external
/// representation.
publicprotocolEncoder{
 /// The path of coding keys taken to get to this point in encoding.
varcodingPath:[CodingKey]{get}

 /// Any contextual information set by the user for encoding.
varuserInfo:[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.
publicprotocolDecoder{
 /// The path of coding keys taken to get to this point in decoding.
varcodingPath:[CodingKey]{get}

 /// Any contextual information set by the user for decoding.
varuserInfo:[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.
publicprotocolKeyedEncodingContainerProtocol{
associatedtypeKey:CodingKey

 /// The path of coding keys taken to get to this point in encoding.
varcodingPath:[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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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.
mutatingfunc 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:)`.
mutatingfunc 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:)`.
mutatingfunc 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.
publicstructKeyedEncodingContainer<K:CodingKey>:
KeyedEncodingContainerProtocol
{
publictypealiasKey=K

 /// The container for the concrete encoder.
internalvar_box:_KeyedEncodingContainerBase

 /// Creates a new instance with the given container.
 ///
 /// - parameter container: The container to hold.
publicinit<Container:KeyedEncodingContainerProtocol>(
 _ container:Container
)where Container.Key ==Key{
 _box =_KeyedEncodingContainerBox(container)
}

 /// The path of coding keys taken to get to this point in encoding.
publicvarcodingPath:[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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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.
publicmutatingfunc 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:)`.
publicmutatingfunc 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:)`.
publicmutatingfunc 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.
publicprotocolKeyedDecodingContainerProtocol{
associatedtypeKey:CodingKey

 /// The path of coding keys taken to get to this point in decoding.
varcodingPath:[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.
varallKeys:[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.