SingleValueEncodingContainer & field decoding optimization added

dehesa · dehesa · commit f9355b209187 · 2020-03-27T18:49:22.000+01:00
diff --git a/sources/Codable/Decodable/Containers/DecodingValue.swift b/sources/Codable/Decodable/Containers/DecodingValue.swift
@@ -156,11 +156,11 @@ extension ShadowDecoder.SingleValueContainer {
     }
 }
 
-extension ShadowDecoder.SingleValueContainer {
+internal extension ShadowDecoder.SingleValueContainer {
     /// Decodes a single value of the given type.
     /// - parameter type: The type to decode as.
     /// - returns: A value of the requested type.
-    internal func decode(_ type: Date.Type) throws -> Date {
+    func decode(_ type: Date.Type) throws -> Date {
         switch self.decoder.source.configuration.dateStrategy {
         case .deferredToDate:
             return try Date(from: self.decoder)
@@ -169,7 +169,7 @@ extension ShadowDecoder.SingleValueContainer {
             return Foundation.Date(timeIntervalSince1970: number)
         case .millisecondsSince1970:
             let number = try self.decode(Double.self)
-            return Foundation.Date(timeIntervalSince1970: number / 1000.0)
+            return Foundation.Date(timeIntervalSince1970: number / 1_000)
         case .iso8601:
             let string = try self.decode(String.self)
             return try DateFormatter.iso8601.date(from: string) ?! DecodingError.invalidDateISO(string: string, codingPath: self.codingPath)
@@ -184,7 +184,7 @@ extension ShadowDecoder.SingleValueContainer {
     /// Decodes a single value of the given type.
     /// - parameter type: The type to decode as.
     /// - returns: A value of the requested type.
-    internal func decode(_ type: Data.Type) throws -> Data {
+    func decode(_ type: Data.Type) throws -> Data {
         switch self.decoder.source.configuration.dataStrategy {
         case .deferredToData:
             return try Data(from: self.decoder)
@@ -199,7 +199,7 @@ extension ShadowDecoder.SingleValueContainer {
     /// Decodes a single value of the given type.
     /// - parameter type: The type to decode as.
     /// - returns: A value of the requested type.
-    internal func decode(_ type: Decimal.Type) throws -> Decimal {
+    func decode(_ type: Decimal.Type) throws -> Decimal {
         switch self.decoder.source.configuration.decimalStrategy {
         case .locale(let locale):
             let string = try self.decode(String.self)
@@ -212,16 +212,16 @@ extension ShadowDecoder.SingleValueContainer {
     /// Decodes a single value of the given type.
     /// - parameter type: The type to decode as.
     /// - returns: A value of the requested type.
-    internal func decode(_ type: URL.Type) throws -> URL {
+    func decode(_ type: URL.Type) throws -> URL {
         try self.lowlevelDecode { URL(string: $0) }
     }
 }
 
 // MARK: -
 
-extension ShadowDecoder.SingleValueContainer {
+private extension ShadowDecoder.SingleValueContainer {
     /// CSV keyed container focus (i.e. where the container is able to operate on).
-    private enum Focus {
+    enum Focus {
         /// The container represents the whole CSV file and each decoding operation outputs a row/record.
         case file
         /// The container represents a CSV row and each decoding operation outputs a field.
@@ -232,18 +232,19 @@ extension ShadowDecoder.SingleValueContainer {
     
     /// Decodes the `String` value under the receiving single value container's `focus` and then tries to transform it in the requested type.
     /// - parameter transform: Closure transforming the decoded `String` value into the required type. If it fails, the closure returns `nil`.
-    private func lowlevelDecode<T>(transform: (String) -> T?) throws -> T {
+    func lowlevelDecode<T>(transform: (String) -> T?) throws -> T {
+        let source = self.decoder.source
+        
         switch self.focus {
         case .field(let rowIndex, let fieldIndex):
-            let string = try self.decoder.source.field(at: rowIndex, fieldIndex)
+            let string = try source.field(at: rowIndex, fieldIndex)
             return try transform(string) ?! DecodingError.invalid(type: T.self, string: string, codingPath: self.codingPath)
         case .row(let rowIndex):
-            // Values are only allowed to be decoded directly from a single value container in "row level" if the CSV rows have a single column.
-            guard self.decoder.source.numFields == 1 else { throw DecodingError.invalidNestedRequired(codingPath: self.codingPath) }
-            let string = try self.decoder.source.field(at: rowIndex, 0)
+            // Values are only allowed to be decoded directly from a single value container in "row level" if the CSV has single column rows.
+            guard source.numFields == 1 else { throw DecodingError.invalidNestedRequired(codingPath: self.codingPath) }
+            let string = try source.field(at: rowIndex, 0)
             return try transform(string) ?! DecodingError.invalid(type: T.self, string: string, codingPath: self.codingPath + [DecodingKey(0)])
         case .file:
-            let source = self.decoder.source
             // Values are only allowed to be decoded directly from a single value container in "file level" if the CSV file has a single row with a single column.
             if source.isRowAtEnd(index: 1), source.numFields == 1 {
                 let string = try self.decoder.source.field(at: 0, 0)
diff --git a/sources/Codable/Decodable/Shadow/DecodingSource.swift b/sources/Codable/Decodable/Shadow/DecodingSource.swift
@@ -110,33 +110,26 @@ extension ShadowDecoder.Source {
     /// Returns the field value in the given `rowIndex` row at the given `fieldIndex` position.
     func field(at rowIndex: Int, _ fieldIndex: Int) throws -> String {
         var nextIndex = self.reader.rowIndex
-        /// If the row has been parsed previously, retrieve it from the buffer.
+        // 1. If the row has been parsed previously, retrieve it from the buffer.
         guard rowIndex >= nextIndex else {
             guard let row = self.buffer.retrieve(at: rowIndex) else {
                 throw DecodingError.expiredCache(rowIndex: rowIndex, fieldIndex: fieldIndex)
             }
             return row[fieldIndex]
         }
-        
-        var result: [String]? = nil
-        var counter = rowIndex - (nextIndex - 1)
-        
-        while counter > 0 {
-            guard let row = try self.reader.parseRow() else {
-                throw DecodingError.rowOutOfBounds(rowIndex: rowIndex, rowCount: nextIndex)
-            }
-            self.buffer.store(row, at: nextIndex)
+        // 2. If the row hasn't been parsed yet, parse rows and store them in the row buffer, till the targeted row is reached.
+        var result: [String]
+        repeat {
+            result = try self.reader.parseRow() ?! DecodingError.rowOutOfBounds(rowIndex: rowIndex, rowCount: nextIndex)
+            self.buffer.store(result, at: nextIndex)
             nextIndex += 1
-            counter -= 1
-            result = row
-        }
-        
-        guard let row = result else { fatalError() }
-        let numFields = row.count
+        } while rowIndex > nextIndex
+        // 3. Check that the requested fields is not out of bounds.
+        let numFields = result.count
         guard numFields > fieldIndex else {
             throw DecodingError.fieldOutOfBounds(rowIndex: rowIndex, fieldIndex: fieldIndex, fieldCount: numFields)
         }
-        return row[fieldIndex]
+        return result[fieldIndex]
     }
 }
 
diff --git a/sources/Codable/Encodable/Containers/EncodingKeyed.swift b/sources/Codable/Encodable/Containers/EncodingKeyed.swift
@@ -5,8 +5,19 @@ extension ShadowEncoder {
     struct KeyedContainer<Key>: KeyedEncodingContainerProtocol where Key:CodingKey {
         /// The representation of the encoding process point-in-time.
         private let encoder: ShadowEncoder
+        /// The focus for this container.
+        private let focus: Focus
         
-        ///
+        /// Fast initializer that doesn't perform any checks on the coding path (assuming it is valid).
+        /// - parameter encoder: The `Encoder` instance in charge of encoding CSV data.
+        /// - parameter rowIndex: The CSV row targeted for encoding.
+        init(unsafeEncoder encoder: ShadowEncoder, rowIndex: Int) {
+            self.encoder = encoder
+            self.focus = .row(rowIndex)
+        }
+        
+        /// Creates a unkeyed container only if the passed encoder's coding path is valid.
+        /// - parameter encoder: The `Encoder` instance in charge of encoding CSV data.
         init(encoder: ShadowEncoder) {
             fatalError()
         }
@@ -166,3 +177,15 @@ extension ShadowEncoder.KeyedContainer {
         fatalError()
     }
 }
+
+// MARK: -
+
+extension ShadowEncoder.KeyedContainer {
+    /// CSV unkeyed container focus (i.e. where the container is able to operate on).
+    private enum Focus {
+        /// The container represents the whole CSV file and each encoding operation writes a row/record.
+        case file
+        /// The container represents a CSV row and each encoding operation outputs a field.
+        case row(Int)
+    }
+}
diff --git a/sources/Codable/Encodable/Containers/EncodingUnkeyed.swift b/sources/Codable/Encodable/Containers/EncodingUnkeyed.swift
@@ -1,9 +1,23 @@
 extension ShadowEncoder {
+    /// Unkeyed container for the CSV shadow encoder.
     ///
+    /// This contaienr lets you sequentially write CSV rows or specific fields within a single rows.
     struct UnkeyedContainer: UnkeyedEncodingContainer {
         /// The representation of the encoding process point-in-time.
         private let encoder: ShadowEncoder
+        /// The focus for this container.
+        private let focus: Focus
         
+        /// Fast initializer that doesn't perform any checks on the coding path (assuming it is valid).
+        /// - parameter encoder: The `Encoder` instance in charge of encoding CSV data.
+        /// - parameter rowIndex: The CSV row targeted for encoding.
+        init(unsafeEncoder encoder: ShadowEncoder, rowIndex: Int) {
+            self.encoder = encoder
+            self.focus = .row(rowIndex)
+        }
+        
+        /// Creates a unkeyed container only if the passed encoder's coding path is valid.
+        /// - parameter encoder: The `Encoder` instance in charge of encoding CSV data.
         init(encoder: ShadowEncoder) {
             fatalError()
         }
@@ -163,3 +177,15 @@ extension ShadowEncoder.UnkeyedContainer {
         fatalError()
     }
 }
+
+// MARK: -
+
+extension ShadowEncoder.UnkeyedContainer {
+    /// CSV unkeyed container focus (i.e. where the container is able to operate on).
+    private enum Focus {
+        /// The container represents the whole CSV file and each encoding operation writes a row/record.
+        case file
+        /// The container represents a CSV row and each encoding operation outputs a field.
+        case row(Int)
+    }
+}
diff --git a/sources/Codable/Encodable/Containers/EncodingValue.swift b/sources/Codable/Encodable/Containers/EncodingValue.swift
@@ -1,5 +1,7 @@
+import Foundation
+
 extension ShadowEncoder {
-    ///
+    /// Single value container for the CSV shadow encoder.
     struct SingleValueContainer {
         /// The representation of the encoding process point-in-time.
         private let encoder: ShadowEncoder
@@ -18,6 +20,7 @@ extension ShadowEncoder {
         /// Creates a single value container only if the passed encoder's coding path is valid.
         /// - parameter encoder: The `Encoder` instance in charge of encoding CSV data.
         init(encoder: ShadowEncoder) {
+            #warning("TODO")
             fatalError()
         }
         
@@ -29,7 +32,7 @@ extension ShadowEncoder {
 
 extension ShadowEncoder.SingleValueContainer: SingleValueEncodingContainer {
     mutating func encode(_ value: String) throws {
-        try self.lowlevelEncoding { $0 }
+        try self.lowlevelEncoding { value }
     }
     
     mutating func encodeNil() throws {
@@ -84,8 +87,7 @@ extension ShadowEncoder.SingleValueContainer: SingleValueEncodingContainer {
         let strategy = self.encoder.sink.configuration.floatStrategy
         try self.lowlevelEncoding {
             switch strategy {
-            case .throw:
-                throw DecodingError.invalidFloatingPoint(value, codingPath: self.codingPath)
+            case .throw: throw DecodingError.invalidFloatingPoint(value, codingPath: self.codingPath)
             case .convert(let positiveInfinity, let negativeInfinity, let nan):
                 if value.isNaN {
                     return nan
@@ -100,8 +102,7 @@ extension ShadowEncoder.SingleValueContainer: SingleValueEncodingContainer {
         let strategy = self.encoder.sink.configuration.floatStrategy
         try self.lowlevelEncoding {
             switch strategy {
-            case .throw:
-                throw DecodingError.invalidFloatingPoint(value, codingPath: self.codingPath)
+            case .throw: throw DecodingError.invalidFloatingPoint(value, codingPath: self.codingPath)
             case .convert(let positiveInfinity, let negativeInfinity, let nan):
                 if value.isNaN {
                     return nan
@@ -112,11 +113,74 @@ extension ShadowEncoder.SingleValueContainer: SingleValueEncodingContainer {
         }
     }
     
-    mutating func encode<T>(_ value: T) throws where T : Encodable {
-        fatalError()
+    mutating func encode<T>(_ value: T) throws where T:Encodable {
+        switch value {
+        case let date as Date: try self.encode(date)
+        case let data as Data: try self.encode(data)
+        case let num as Decimal: try self.encode(num)
+        case let url as URL: try self.encode(url)
+        default: try value.encode(to: self.encoder)
+        }
     }
 }
 
+internal extension ShadowEncoder.SingleValueContainer {
+    /// Encodes a single value of the given type.
+    /// - parameter value: The value to encode.
+    mutating func encode(_ value: Date) throws {
+        switch self.encoder.sink.configuration.dateStrategy {
+        case .deferredToDate:
+            try value.encode(to: self.encoder)
+        case .secondsSince1970:
+            try self.encode(value.timeIntervalSince1970)
+        case .millisecondsSince1970:
+            try self.encode(value.timeIntervalSince1970 * 1_000)
+        case .iso8601:
+            let string = DateFormatter.iso8601.string(from: value)
+            try self.encode(string)
+        case .formatted(let formatter):
+            let string = formatter.string(from: value)
+            try self.encode(string)
+        case .custom(let closure):
+            try closure(value, self.encoder)
+        }
+    }
+
+    /// Encodes a single value of the given type.
+    /// - parameter value: The value to encode.
+    mutating func encode(_ value: Data) throws {
+        switch self.encoder.sink.configuration.dataStrategy {
+        case .deferredToData:
+            try value.encode(to: self.encoder)
+        case .base64:
+            try self.encode(value.base64EncodedString())
+        case .custom(let closure):
+            try closure(value, self.encoder)
+        }
+    }
+
+    /// Encodes a single value of the given type.
+    /// - parameter value: The value to encode.
+    mutating func encode(_ value: Decimal) throws {
+        switch self.encoder.sink.configuration.decimalStrategy {
+        case .locale(let locale):
+            var number = value
+            let string = NSDecimalString(&number, locale)
+            try self.encode(string)
+        case .custom(let closure):
+            try closure(value, self.encoder)
+        }
+    }
+
+    /// Encodes a single value of the given type.
+    /// - parameter value: The value to encode.
+    func encode(_ value: URL) throws {
+        try self.lowlevelEncoding { value.path }
+    }
+}
+
+// MARK: -
+
 extension ShadowEncoder.SingleValueContainer {
     /// CSV keyed container focus (i.e. where the container is able to operate on).
     private enum Focus {
@@ -129,14 +193,26 @@ extension ShadowEncoder.SingleValueContainer {
     }
     
     /// Encodes a value by transforming it into a `String` through the closure and then passing it to the sink.
-    private func lowlevelEncoding<T>(transform: (T) throws -> String) throws {
-        fatalError()
+    private func lowlevelEncoding(transform: () throws -> String) throws {
+        let sink = self.encoder.sink
+        
+        switch self.focus {
+        case .field(let rowIndex, let fieldIndex):
+            let string = try transform()
+            try sink.field(value: string, at: rowIndex, fieldIndex)
+        case .row(let rowIndex):
+            // Values are only allowed to be encoded directly from a single value container in "row level" if the CSV has single column rows.
+            fatalError()
+        case .file:
+            // Values are only allowed to be decoded directly from a single value container in "file level" if the CSV file has a single row with a single column.
+            fatalError()
+        }
     }
 }
 
 fileprivate extension DecodingError {
     /// Error raised when a non-conformant floating-point is being encoded and there is no support.
-    static func invalidFloatingPoint<T>(_ value: T, codingPath: [CodingKey]) -> DecodingError where T:BinaryFloatingPoint {
+    static func invalidFloatingPoint<T:BinaryFloatingPoint>(_ value: T, codingPath: [CodingKey]) -> DecodingError {
         DecodingError.dataCorrupted(
             Context(codingPath: codingPath,
                     debugDescription: "The value '\(value)' is a non-conformant floating-point.")
diff --git a/sources/Codable/Encodable/EncoderConfiguration.swift b/sources/Codable/Encodable/EncoderConfiguration.swift
@@ -5,6 +5,8 @@ extension CSVEncoder {
         @usableFromInline private(set) internal var writerConfiguration: CSVWriter.Configuration
         /// The strategy to use when dealing with non-conforming numbers.
         public var floatStrategy: Strategy.NonConformingFloat
+        /// The strategy to use when encoding decimal values.
+        public var decimalStrategy: Strategy.DecimalEncoding
         /// The strategy to use when encoding dates.
         public var dateStrategy: Strategy.DateEncoding
         /// The strategy to use when encoding binary data.
@@ -14,6 +16,7 @@ extension CSVEncoder {
         public init() {
             self.writerConfiguration = .init()
             self.floatStrategy = .throw
+            self.decimalStrategy = .locale(nil)
             self.dateStrategy = .deferredToDate
             self.dataStrategy = .base64
         }
diff --git a/sources/Codable/Encodable/EncodingStrategy.swift b/sources/Codable/Encodable/EncodingStrategy.swift
diff --git a/sources/Codable/Encodable/Shadow/EncodingSink.swift b/sources/Codable/Encodable/Shadow/EncodingSink.swift
