Better container types with custom encoders/decoders

Author: ypopovych

Sources/ScaleCodec/Array.swift

@@ -7,46 +7,77 @@
 
 import Foundation
 
-extension Array: ScaleEncodable where Element: ScaleEncodable {
-    public func encode(in encoder: ScaleEncoder) throws {
+extension Array: ScaleContainerEncodable {
+    public typealias EElement = Element
+    
+    public func encode(in encoder: ScaleEncoder, writer: @escaping (EElement, ScaleEncoder) throws -> Void) throws {
         try encoder.encode(compact: UInt32(count))
         for element in self {
-            try encoder.encode(element)
+            try writer(element, encoder)
         }
     }
 }
 
-extension Array: ScaleDecodable where Element: ScaleDecodable {
-    public init(from decoder: ScaleDecoder) throws {
+extension Array: ScaleContainerDecodable {
+    public typealias DElement = Element
+    
+    public init(from decoder: ScaleDecoder, reader: @escaping (ScaleDecoder) throws -> Element) throws {
         let size = try Int(decoder.decode(UInt32.self, .compact))
         var array = Array<Element>()
         array.reserveCapacity(size)
         for _ in 0..<size {
-            try array.append(decoder.decode())
+            try array.append(reader(decoder))
         }
         self = array
     }
 }
 
+extension Array: ScaleEncodable where Element: ScaleEncodable {}
+
+extension Array: ScaleDecodable where Element: ScaleDecodable {}
+
 extension ScaleDecoder {
     public func decode<T: ScaleDecodable>(_ type: [T].Type, _ fixed: ScaleFixedTypeMarker) throws -> [T] {
         return try self.decode(fixed)
     }
 
-    public func decode<T: ScaleDecodable>(_ fixed: ScaleFixedTypeMarker) throws -> [T] {
+    public func decode<T>(
+        _ type: [T].Type, _ fixed: ScaleFixedTypeMarker,
+        reader: @escaping (ScaleDecoder) throws -> T
+    ) throws -> [T] {
+        return try self.decode(fixed, reader: reader)
+    }
+    
+    public func decode<T>(
+        _ fixed: ScaleFixedTypeMarker,
+        reader: @escaping (ScaleDecoder) throws -> T
+    ) throws -> [T] {
         guard case .fixed(let size) = fixed else { fatalError() } // Compiler error silencing.
         var values = Array<T>()
         values.reserveCapacity(Int(size))
         for _ in 0..<size {
-            try values.append(self.decode())
+            try values.append(reader(self))
         }
         return values
     }
+    
+    public func decode<T: ScaleDecodable>(_ fixed: ScaleFixedTypeMarker) throws -> [T] {
+        try self.decode(fixed) { decoder in try decoder.decode() }
+    }
 }
 
 extension ScaleEncoder {
     @discardableResult
     public func encode<T: ScaleEncodable>(_ values: [T], fixed: UInt) throws -> ScaleEncoder {
+        try self.encode(values, fixed: fixed) { val, enc in try enc.encode(val) }
+        return self
+    }
+    
+    @discardableResult
+    public func encode<T>(
+        _ values: [T], fixed: UInt,
+        writer: @escaping (T, ScaleEncoder) throws -> Void
+    ) throws -> ScaleEncoder {
         guard values.count == fixed else {
             throw SEncodingError.invalidValue(
                 values, SEncodingError.Context(
@@ -56,22 +87,45 @@ extension ScaleEncoder {
             )
         }
         for val in values {
-            try self.encode(val)
+            try writer(val, self)
         }
         return self
     }
 }
 
 extension SCALE {
-    public func decode<T: ScaleDecodable>(_ type: [T].Type, _ fixed: ScaleFixedTypeMarker, from data: Data) throws -> [T] {
+    public func decode<T: ScaleDecodable>(
+        _ type: [T].Type, _ fixed: ScaleFixedTypeMarker, from data: Data
+    ) throws -> [T] {
         return try self.decode(fixed, from: data)
     }
 
+    public func decode<T>(
+        _ type: [T].Type, _ fixed: ScaleFixedTypeMarker, from data: Data,
+        reader: @escaping (ScaleDecoder) throws -> T
+    ) throws -> [T] {
+        return try self.decode(fixed, from: data, reader: reader)
+    }
+    
     public func decode<T: ScaleDecodable>(_ fixed: ScaleFixedTypeMarker, from data: Data) throws -> [T] {
         return try self.decoder(data: data).decode(fixed)
     }
 
+    public func decode<T>(
+        _ fixed: ScaleFixedTypeMarker, from data: Data,
+        reader: @escaping (ScaleDecoder) throws -> T
+    ) throws -> [T] {
+        return try self.decoder(data: data).decode(fixed, reader: reader)
+    }
+    
     public func encode<T: ScaleEncodable>(_ values: [T], fixed: UInt) throws -> Data {
         return try self.encoder().encode(values, fixed: fixed).output
     }
+    
+    public func encode<T>(
+        _ values: [T], fixed: UInt,
+        writer: @escaping (T, ScaleEncoder) throws -> Void
+    ) throws -> Data {
+        return try self.encoder().encode(values, fixed: fixed, writer: writer).output
+    }
 }

Sources/ScaleCodec/Containers.swift

@@ -0,0 +1,81 @@
+//
+//  Collections.swift
+//  
+//
+//  Created by Yehor Popovych on 10/10/20.
+//
+
+import Foundation
+
+public protocol ScaleContainerEncodable {
+    associatedtype EElement
+    
+    func encode(in encoder: ScaleEncoder, writer: @escaping (EElement, ScaleEncoder) throws -> Void) throws
+}
+
+public protocol ScaleContainerDecodable {
+    associatedtype DElement
+    
+    init(from decoder: ScaleDecoder, reader: @escaping (ScaleDecoder) throws -> DElement) throws
+}
+
+extension ScaleContainerEncodable where EElement: ScaleEncodable {
+    public func encode(in encoder: ScaleEncoder) throws {
+        try self.encode(in: encoder) { val, enc in
+            try enc.encode(val)
+        }
+    }
+}
+
+extension ScaleContainerDecodable where DElement: ScaleDecodable {
+    public init(from decoder: ScaleDecoder) throws {
+        try self.init(from: decoder) { try $0.decode() }
+    }
+}
+
+public protocol ScaleDoubleContainerEncodable {
+    associatedtype ELeft
+    associatedtype ERight
+    
+    func encode(
+        in encoder: ScaleEncoder,
+        lwriter: @escaping (ELeft, ScaleEncoder) throws -> Void,
+        rwriter: @escaping (ERight, ScaleEncoder) throws -> Void
+    ) throws
+}
+
+public protocol ScaleDoubleContainerDecodable {
+    associatedtype DLeft
+    associatedtype DRight
+    
+    init(
+        from decoder: ScaleDecoder,
+        lreader: @escaping (ScaleDecoder) throws -> DLeft,
+        rreader: @escaping (ScaleDecoder) throws -> DRight
+    ) throws
+}
+
+extension ScaleDoubleContainerEncodable where ELeft: ScaleEncodable {
+    public func encode(in encoder: ScaleEncoder, writer: @escaping (ERight, ScaleEncoder) throws -> Void) throws {
+        try encode(in: encoder, lwriter: { val, enc in try enc.encode(val) }, rwriter: writer)
+    }
+}
+
+extension ScaleDoubleContainerEncodable where ERight: ScaleEncodable {
+    public func encode(in encoder: ScaleEncoder, writer: @escaping (ELeft, ScaleEncoder) throws -> Void) throws {
+        try encode(in: encoder, lwriter: writer, rwriter: { val, enc in try enc.encode(val) })
+    }
+}
+
+extension ScaleDoubleContainerDecodable where DLeft: ScaleDecodable {
+    public init(from decoder: ScaleDecoder, reader: @escaping (ScaleDecoder) throws -> DRight) throws {
+        try self.init(from: decoder, lreader: { try $0.decode() }, rreader: reader)
+    }
+}
+
+extension ScaleDoubleContainerDecodable where DRight: ScaleDecodable {
+    public init(from decoder: ScaleDecoder, reader: @escaping (ScaleDecoder) throws -> DLeft) throws {
+        try self.init(from: decoder, lreader: reader, rreader: { try $0.decode() })
+    }
+}
+

Sources/ScaleCodec/Decoder.swift

@@ -11,7 +11,7 @@ public protocol ScaleDecodable {
     init(from decoder: ScaleDecoder) throws
 }
 
-public protocol ScaleDecoder {
+public protocol ScaleDecoder: class {
     var length: Int { get }
     var path: [String] { get }
 

Sources/ScaleCodec/Dictionary.swift

@@ -7,15 +7,44 @@
 
 import Foundation
 
-extension Dictionary: ScaleEncodable where Key: ScaleEncodable, Value: ScaleEncodable {
-    public func encode(in encoder: ScaleEncoder) throws {
-        try encoder.encode(self.map { STuple($0) })
+extension Dictionary: ScaleDoubleContainerEncodable {
+    public typealias ELeft = Key
+    public typealias ERight = Value
+    
+    public func encode(
+        in encoder: ScaleEncoder,
+        lwriter: @escaping (Key, ScaleEncoder) throws -> Void,
+        rwriter: @escaping (Value, ScaleEncoder) throws -> Void
+    ) throws {
+        let array = Array(self)
+        try array.encode(in: encoder) { (kv, enc) in
+            try lwriter(kv.key, enc); try rwriter(kv.value, enc)
+        }
     }
 }
 
-extension Dictionary: ScaleDecodable where Key: ScaleDecodable, Value: ScaleDecodable {
-    public init(from decoder: ScaleDecoder) throws {
-        let array = try decoder.decode(Array<STuple2<Key, Value>>.self).map { $0.tuple }
+extension Dictionary: ScaleDoubleContainerDecodable {
+    public typealias DLeft = Key
+    public typealias DRight = Value
+    
+    public init(
+        from decoder: ScaleDecoder,
+        lreader: @escaping (ScaleDecoder) throws -> Key,
+        rreader: @escaping (ScaleDecoder) throws -> Value
+    ) throws {
+        let array = try Array<(DLeft, DRight)>(from: decoder) { try (lreader($0), rreader($0)) }
         self = Dictionary(uniqueKeysWithValues: array)
     }
 }
+
+extension Dictionary: ScaleContainerEncodable where Key: ScaleEncodable {
+    public typealias EElement = Value
+}
+
+extension Dictionary: ScaleContainerDecodable where Key: ScaleDecodable {
+    public typealias DElement = Value
+}
+
+extension Dictionary: ScaleEncodable where Key: ScaleEncodable, Value: ScaleEncodable {}
+
+extension Dictionary: ScaleDecodable where Key: ScaleDecodable, Value: ScaleDecodable {}

Sources/ScaleCodec/Encoder.swift

@@ -11,7 +11,7 @@ public protocol ScaleEncodable {
     func encode(in encoder: ScaleEncoder) throws;
 }
 
-public protocol ScaleEncoder {
+public protocol ScaleEncoder: class {
     var path: [String] { get }
     var output: Data { get }
 

Sources/ScaleCodec/Error.swift

@@ -18,7 +18,7 @@ public enum SEncodingError : Error {
         }
     }
 
-    case invalidValue(ScaleEncodable, SEncodingError.Context)
+    case invalidValue(Any, SEncodingError.Context)
 }
 
 public enum SDecodingError : Error {

Sources/ScaleCodec/Optional.swift

@@ -7,28 +7,34 @@
 
 import Foundation
 
-extension Optional: ScaleEncodable where Wrapped: ScaleEncodable {
-    public func encode(in encoder: ScaleEncoder) throws {
-        if Wrapped.self == Bool.self {
+extension Optional: ScaleContainerEncodable {
+    public typealias EElement = Wrapped
+    
+    public func encode(in encoder: ScaleEncoder, writer: @escaping (EElement, ScaleEncoder) throws -> Void) throws {
+        if EElement.self == Bool.self {
             try encodeBool(encoder: encoder, self as! Bool?)
         } else {
             switch self {
             case .none: try encoder.encode(UInt8(0x00))
-            case .some(let val): try encoder.encode(UInt8(0x01)).encode(val)
+            case .some(let val): try writer(val, encoder.encode(UInt8(0x01)))
             }
         }
     }
 }
 
-extension Optional: ScaleDecodable where Wrapped: ScaleDecodable {
-    public init(from decoder: ScaleDecoder) throws {
-        if Wrapped.self == Bool.self {
-            self = try decodeBool(decoder: decoder) as! Wrapped?
+extension Optional: ScaleEncodable where Wrapped: ScaleEncodable {}
+
+extension Optional: ScaleContainerDecodable {
+    public typealias DElement = Wrapped
+    
+    public init(from decoder: ScaleDecoder, reader: @escaping (ScaleDecoder) throws -> DElement) throws {
+        if DElement.self == Bool.self {
+            self = try decodeBool(decoder: decoder) as! DElement?
         } else {
             let val = try decoder.decode(UInt8.self)
             switch val {
             case 0x00: self = .none
-            case 0x01: self = try .some(decoder.decode())
+            case 0x01: self = try .some(reader(decoder))
             default:
                 throw SDecodingError.dataCorrupted(
                     SDecodingError.Context(
@@ -41,6 +47,8 @@ extension Optional: ScaleDecodable where Wrapped: ScaleDecodable {
     }
 }
 
+extension Optional: ScaleDecodable where Wrapped: ScaleDecodable {}
+
 private func encodeBool(encoder: ScaleEncoder, _ value: Bool?) throws {
     switch value {
     case .none: try encoder.encode(UInt8(0x00))