Contents

Features

Usage

0. Codable:

struct TestAutoCodable: Codable, Equatable {
 private(set) var int: Int = 0
 private(set) var string: String?
 enum CodingKeys: String, CodingKey {
 case int = "i", string = "s"
 }
}

struct TestManualCodable: Equatable {
 private(set) var int: Int = 0
 private(set) var string: String?
}
extension TestManualCodable: Codable {
 
 enum Keys: CodingKey {
 case int, i
 case nested, string
 }
 
 init(from decoder: Decoder) throws {
 if let container = try? decoder.container(keyedBy: Keys.self) {
 if let int = (try? container.decodeIfPresent(Int.self, forKey: Keys.int))
 ?? (try? container.decodeIfPresent(Int.self, forKey: Keys.i)) {
 self.int = int
 }
 if let nestedContainer = try? container.nestedContainer(keyedBy: Keys.self, forKey: Keys.nested),
 let string = try? nestedContainer.decodeIfPresent(String.self, forKey: Keys.string) {
 self.string = string
 }
 }
 }
 
 func encode(to encoder: Encoder) throws {
 var container = encoder.container(keyedBy: Keys.self)
 try? container.encodeIfPresent(int, forKey: Keys.int)
 var nestedContainer = container.nestedContainer(keyedBy: Keys.self, forKey: Keys.nested)
 try? nestedContainer.encodeIfPresent(string, forKey: Keys.string)
 }
}

struct TestExCodable: Equatable {
 private(set) var int: Int = 0
 private(set) var string: String?
}
extension TestExCodable: ExCodable {
 static let keyMapping: [KeyMap<Self>] = [
 KeyMap(\.int, to: "int"),
 KeyMap(\.string, to: "string")
 ]
 init(from decoder: Decoder) throws {
 try decode(from: decoder, with: Self.keyMapping)
 }
}

1. Key-Mapping for struct:

struct TestStruct: Equatable {
 private(set) var int: Int = 0
 private(set) var string: String?
 var bool: Bool!
}

extension TestStruct: ExCodable {
 
 static let keyMapping: [KeyMap<Self>] = [
 KeyMap(\.int, to: "int"),
 KeyMap(\.string, to: "string"),
 ]
 
 init(from decoder: Decoder) throws {
 try decode(from: decoder, with: Self.keyMapping)
 }
 // `encode` with default implementation can be omitted
 // func encode(to encoder: Encoder) throws {
 // try encode(to: encoder, with: Self.keyMapping)
 // }
}

2. Alternative-Keys:

static let keyMapping: [KeyMap<Self>] = [
 KeyMap(\.int, to: "int", "i"),
 KeyMap(\.string, to: "string", "str", "s")
]

3. Nested-Keys:

static let keyMapping: [KeyMap<Self>] = [
 KeyMap(\.int, to: "int"),
 KeyMap(\.string, to: "nested.string")
]

4. Custom encode/decode:

struct TestCustomEncodeDecode: Equatable {
 var int: Int = 0
 var string: String?
}

extension TestCustomEncodeDecode: ExCodable {
 
 private enum Keys: CodingKey {
 case int, string
 }
 private static let dddd = "dddd"
 private func string(for int: Int) -> String {
 switch int {
 case 100: return "Continue"
 case 200: return "OK"
 case 304: return "Not Modified"
 case 403: return "Forbidden"
 case 404: return "Not Found"
 case 418: return "I'm a teapot"
 case 500: return "Internal Server Error"
 case 200..<400: return "success"
 default: return "failure"
 }
 }
 
 static let keyMapping: [KeyMap<Self>] = [
 KeyMap(\.int, to: Keys.int),
 ]
 
 init(from decoder: Decoder) throws {
 try decode(from: decoder, with: Self.keyMapping)
 string = decoder[Keys.string]
 if string == nil || string == Self.dddd {
 string = string(for: int)
 }
 }
 func encode(to encoder: Encoder) throws {
 try encode(to: encoder, with: Self.keyMapping)
 encoder[Keys.string] = Self.dddd
 }
}

5. Encode/decode constant properties with subscripts:

struct TestSubscript: Equatable {
 let int: Int
 let string: String
}

extension TestSubscript: Encodable, Decodable {
 
 enum Keys: CodingKey {
 case int, string
 }
 
 init(from decoder: Decoder) throws {
 // - seealso:
 // string = decoder.decode(<#T##codingKeys: CodingKey...##CodingKey#>)
 // string = try decoder.decodeThrows(<#T##codingKeys: CodingKey...##CodingKey#>)
 // string = try decoder.decodeNonnullThrows(<#T##codingKeys: CodingKey...##CodingKey#>)
 int = decoder[Keys.int] ?? 0
 string = decoder[Keys.string] ?? ""
 }
 func encode(to encoder: Encoder) throws {
 // - seealso:
 // encoder.encode(<#T##value: Encodable?##Encodable?#>, for: <#T##CodingKey#>)
 // try encoder.encodeThrows(<#T##value: Encodable?##Encodable?#>, for: <#T##CodingKey#>)
 // try encoder.encodeNonnullThrows(<#T##value: Encodable##Encodable#>, for: <#T##CodingKey#>)
 encoder[Keys.int] = int
 encoder[Keys.string] = string
 }
}

6. Custom Type-Conversions:

struct FloatToBoolDecodingTypeConverter: ExCodableDecodingTypeConverter {
 public func decode<T: Decodable, K: CodingKey>(_ container: KeyedDecodingContainer<K>, codingKey: K, as type: T.Type) -> T? {
 // Bool -> Double
 if type is Double.Type || type is Double?.Type {
 if let bool = try? container.decodeIfPresent(Bool.self, forKey: codingKey) {
 return (bool ? 1.0 : 0.0) as? T
 }
 }
 // Bool -> Float
 else if type is Float.Type || type is Float?.Type {
 if let bool = try? container.decodeIfPresent(Bool.self, forKey: codingKey) {
 return (bool ? 1.0 : 0.0) as? T
 }
 }
 // Double or Float NOT found
 return nil
 }
}

register(FloatToBoolDecodingTypeConverter())

7. Key-Mapping for class:

class TestClass: ExCodable, Equatable {
 
 var int: Int = 0
 var string: String? = nil
 init(int: Int, string: String?) {
 (self.int, self.string) = (int, string)
 }
 
 static let keyMapping: [KeyMap<TestClass>] = [
 KeyMap(ref: \.int, to: "int"),
 KeyMap(ref: \.string, to: "string")
 ]
 
 required init(from decoder: Decoder) throws {
 try decodeReference(from: decoder, with: Self.keyMapping)
 }
 
 static func == (lhs: TestClass, rhs: TestClass) -> Bool {
 return lhs.int == rhs.int && lhs.string == rhs.string
 }
}

8. Key-Mapping for subclass:

class TestSubclass: TestClass {
 var bool: Bool = false
 required init(int: Int, string: String, bool: Bool) {
 self.bool = bool
 super.init(int: int, string: string)
 }
 
 static let keyMappingForTestSubclass: [KeyMap<TestSubclass>] = [
 KeyMap(ref: \.bool, to: "bool")
 ]
 
 required init(from decoder: Decoder) throws {
 try super.init(from: decoder)
 try decodeReference(from: decoder, with: Self.keyMappingForTestSubclass)
 }
 override func encode(to encoder: Encoder) throws {
 try super.encode(to: encoder)
 try encode(to: encoder, with: Self.keyMappingForTestSubclass)
 }
 
 static func == (lhs: TestSubclass, rhs: TestSubclass) -> Bool {
 return lhs.int == rhs.int
 && lhs.string == rhs.string
 && lhs.bool == rhs.bool
 }
}

9. Encode/decode with Type-Inference:

let test = TestStruct(int: 304, string: "Not Modified")
let data = try? test.encoded() as Data?
let copy1 = try? data?.decoded() as TestStruct?
let copy2 = data.map { try? TestStruct.decoded(from: 0ドル) }
XCTAssertEqual(copy1, test)
XCTAssertEqual(copy2, test)

Requirements

Installation

.package(url: "https://github.com/iwill/ExCodable", from: "0.5.0")

pod 'ExCodable', '~> 0.5.0'

<#extension/struct/class#> <#Type#>: ExCodable {
 static let <#keyMapping#>: [KeyMap<<#SelfType#>>] = [
 KeyMap(\.<#property#>, to: <#"key"#>),
 <#...#>
 ]
 init(from decoder: Decoder) throws {
 try decode<#Reference#>(from: decoder, with: Self.<#keyMapping#>)
 }
 func encode(to encoder: Encoder) throws {
 try encode(to: encoder, with: Self.<#keyMapping#>)
 }
}

Credits

License