Codable 和 CodingKeys

Question

I'm trying to implement a protocol with similar functionality to how Codable uses the CodingKeys enum.

With Codable and CodingKeys , if you don't implement a case in the CodingKeys enum for every property on the Codable object, it causes a compiler error stating that the object does not conform to the protocol.

I have looked through documentation, and the only thing I can find related to the Codable ( Encodable and Decodable ) protocol is the requirement to implement the func encode(to encoder: Encoder) and init(from decoder: Decoder) functions.

The closest I've gotten is defining a protocol as follows:

protocol TestProtocol {
    associatedType Keys: CodingKey
}

This requires the implementer to have a Keys property that conforms to CodingKey , but it does not enforce the requirement to have a case for all properties. Additionally, you cannot declare the Keys property as private like you can with Codable .

Are Codable and CodingKeys handled at a deeper level than what is exposed through the APIs?

If not, is there a way to implement the CodingKeys functionality outside of Codable ?

Answer 1

You ask two questions. I think it will be easier to explain them in reverse order.

Are Codable and CodingKeys are handled at a deeper level than what is exposed through the APIs?

Yes, the Swift compiler knows about the Encodable , Decodable , and CodingKey protocols and has special code for them.

The compiler can synthesize a CodingKey -compliant enum named CodingKeys , the init(from:) initializer, and the encode(to:) method, if some conditions are met. The conditions are spelled out in SE-0166 :

Encodable & Decodable requirements can be automatically synthesized for certain types as well:

1. Types conforming to Encodable whose properties are all Encodable get an automatically generated String -backed CodingKey enum mapping properties to case names. Similarly for Decodable types whose properties are all Decodable
2. Types falling into (1) — and types which manually provide a CodingKey enum (named CodingKeys , directly, or via a typealias ) whose cases map 1-to-1 to Encodable / Decodable properties by name — get automatic synthesis of init(from:) and encode(to:) as appropriate, using those properties and keys
3. Types which fall into neither (1) nor (2) will have to provide a custom key type if needed and provide their own init(from:) and encode(to:) , as appropriate

Note that the CodingKey -compliant type does not in general have to be named CodingKeys or even be an enum unless you are relying on compiler-synthesized conformance.

Furthermore, note that a CodingKeys type conforming to CodingKey only needs to have a case for every member of its enclosing type if you are relying on the compiler to synthesize init(from:) or encode(to:) .

If you're manually implementing init(from:) and encode(to:) , you can use any name for your CodingKey -compliant type, and it only has to have the cases you care about. You don't even need a CodingKey -compliant type if you're only using a single-value container or an unkeyed container for storage.

If not, is there a way to implement the CodingKeys functionality outside of Codable?

If, by “functionality”, you mean the way the compiler automatically synthesizes implementations, then the only way is by using a code generator (like Sourcery or gyb) to generate source code and feed it to the compiler.

If, by “functionality”, you mean the way the compiler requires a key member for each Encodable / Decodable member of the enclosing type, then the only way is by running a separate program that analyzes your source code and errors out if any case is missing. You can't make the standard Swift compiler do it for you.