Add "closure" workarounds to all functions and properties of ByteReader to improve its performance with Swift 4.2

Author: tsolomko

Sources/ByteReader.swift

@@ -23,17 +23,36 @@ public class ByteReader {
      - Note: It generally means that all bytes have been read.
      */
     public var isFinished: Bool {
-        return self.data.endIndex <= self.offset
+        #if swift(>=4.2)
+            return { (data: Data, offset: Int) -> Bool in
+                data.endIndex <= offset
+            } (self.data, self.offset)
+        #else
+            return self.data.endIndex <= self.offset
+        #endif
+
     }
 
     /// Amount of bytes left to read.
     public var bytesLeft: Int {
-        return self.data.endIndex - self.offset
+        #if swift(>=4.2)
+            return { (data: Data, offset: Int) -> Int in
+                self.data.endIndex - self.offset
+            } (self.data, self.offset)
+        #else
+            return self.data.endIndex - self.offset
+        #endif
     }
 
     /// Amount of bytes that were already read.
     public var bytesRead: Int {
-        return self.offset - self.data.startIndex
+        #if swift(>=4.2)
+            return { (data: Data, offset: Int) -> Int in
+                return offset - data.startIndex
+            } (self.data, self.offset)
+        #else
+            return self.offset - self.data.startIndex
+        #endif
     }
 
     /// Creates an instance for reading bytes from `data`.
@@ -49,9 +68,17 @@ public class ByteReader {
      - Precondition: There MUST be enough data left.
      */
     public func byte() -> UInt8 {
-        precondition(self.offset < self.data.endIndex)
-        defer { self.offset += 1 }
-        return self.data[self.offset]
+        #if swift(>=4.2)
+            return { (data: Data, offset: inout Int) -> UInt8 in
+                precondition(offset < data.endIndex)
+                defer { offset += 1 }
+                return data[offset]
+            } (self.data, &self.offset)
+        #else
+            precondition(self.offset < self.data.endIndex)
+            defer { self.offset += 1 }
+            return self.data[self.offset]
+        #endif
     }
 
     /**
@@ -63,8 +90,15 @@ public class ByteReader {
     public func bytes(count: Int) -> [UInt8] {
         precondition(count >= 0)
         precondition(bytesLeft >= count)
-        defer { self.offset += count }
-        return self.data[self.offset..<self.offset + count].toArray(type: UInt8.self, count: count)
+        #if swift(>=4.2)
+            return { (data: Data, offset: inout Int) -> [UInt8] in
+                defer { offset += count }
+                return data[offset..<offset + count].toArray(type: UInt8.self, count: count)
+            } (self.data, &self.offset)
+        #else
+            defer { self.offset += count }
+            return self.data[self.offset..<self.offset + count].toArray(type: UInt8.self, count: count)
+        #endif
     }
 
     /**
@@ -78,12 +112,23 @@ public class ByteReader {
         precondition(bytesLeft >= count)
         // TODO: If uintX() could be force inlined or something in the future then probably it would make sense
         // to use them for `count` == 2, 4 or 8.
-        var result = 0
-        for i in 0..<count {
-            result += Int(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
-            self.offset += 1
-        }
-        return result
+        #if swift(>=4.2)
+            return { (data: Data, offset: inout Int) -> Int in
+                var result = 0
+                for i in 0..<count {
+                    result += Int(truncatingIfNeeded: data[offset]) << (8 * i)
+                    offset += 1
+                }
+                return result
+            } (self.data, &self.offset)
+        #else
+            var result = 0
+            for i in 0..<count {
+                result += Int(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
+                self.offset += 1
+            }
+            return result
+        #endif
     }
 
     /**
@@ -93,8 +138,15 @@ public class ByteReader {
      */
     public func uint64() -> UInt64 {
         precondition(bytesLeft >= 8)
-        defer { self.offset += 8 }
-        return self.data[self.offset..<self.offset + 8].to(type: UInt64.self)
+        #if swift(>=4.2)
+            return { (data: Data, offset: inout Int) -> UInt64 in
+                defer { offset += 8 }
+                return data[offset..<offset + 8].to(type: UInt64.self)
+            } (self.data, &self.offset)
+        #else
+            defer { self.offset += 8 }
+            return self.data[self.offset..<self.offset + 8].to(type: UInt64.self)
+        #endif
     }
 
     /**
@@ -109,12 +161,23 @@ public class ByteReader {
     public func uint64(fromBytes count: Int) -> UInt64 {
         precondition(0...8 ~= count)
         precondition(bytesLeft >= count)
-        var result = 0 as UInt64
-        for i in 0..<count {
-            result += UInt64(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
-            self.offset += 1
-        }
-        return result
+        #if swift(>=4.2)
+            return { (data: Data, offset: inout Int) -> UInt64 in
+                var result = 0 as UInt64
+                for i in 0..<count {
+                    result += UInt64(truncatingIfNeeded: data[offset]) << (8 * i)
+                    offset += 1
+                }
+                return result
+            } (self.data, &self.offset)
+        #else
+            var result = 0 as UInt64
+            for i in 0..<count {
+                result += UInt64(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
+                self.offset += 1
+            }
+            return result
+        #endif
     }
 
     /**
@@ -124,8 +187,15 @@ public class ByteReader {
      */
     public func uint32() -> UInt32 {
         precondition(bytesLeft >= 4)
-        defer { self.offset += 4 }
-        return self.data[self.offset..<self.offset + 4].to(type: UInt32.self)
+        #if swift(>=4.2)
+            return { (data: Data, offset: inout Int) -> UInt32 in
+                defer { offset += 4 }
+                return data[offset..<offset + 4].to(type: UInt32.self)
+            } (self.data, &self.offset)
+        #else
+            defer { self.offset += 4 }
+            return self.data[self.offset..<self.offset + 4].to(type: UInt32.self)
+        #endif
     }
 
     /**
@@ -140,12 +210,23 @@ public class ByteReader {
     public func uint32(fromBytes count: Int) -> UInt32 {
         precondition(0...4 ~= count)
         precondition(bytesLeft >= count)
-        var result = 0 as UInt32
-        for i in 0..<count {
-            result += UInt32(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
-            self.offset += 1
-        }
-        return result
+        #if swift(>=4.2)
+            return { (data: Data, offset: inout Int) -> UInt32 in
+                var result = 0 as UInt32
+                for i in 0..<count {
+                    result += UInt32(truncatingIfNeeded: data[offset]) << (8 * i)
+                    offset += 1
+                }
+                return result
+            } (self.data, &self.offset)
+        #else
+            var result = 0 as UInt32
+            for i in 0..<count {
+                result += UInt32(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
+                self.offset += 1
+            }
+            return result
+        #endif
     }
 
     /**
@@ -155,8 +236,15 @@ public class ByteReader {
      */
     public func uint16() -> UInt16 {
         precondition(bytesLeft >= 2)
-        defer { self.offset += 2 }
-        return self.data[self.offset..<self.offset + 2].to(type: UInt16.self)
+        #if swift(>=4.2)
+            return { (data: Data, offset: inout Int) -> UInt16 in
+                defer { offset += 2 }
+                return data[offset..<offset + 2].to(type: UInt16.self)
+            } (self.data, &self.offset)
+        #else
+            defer { self.offset += 2 }
+            return self.data[self.offset..<self.offset + 2].to(type: UInt16.self)
+        #endif
     }
 
     /**
@@ -171,12 +259,23 @@ public class ByteReader {
     public func uint16(fromBytes count: Int) -> UInt16 {
         precondition(0...2 ~= count)
         precondition(bytesLeft >= count)
-        var result = 0 as UInt16
-        for i in 0..<count {
-            result += UInt16(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
-            self.offset += 1
-        }
-        return result
+        #if swift(>=4.2)
+            return { (data: Data, offset: inout Int) -> UInt16 in
+                var result = 0 as UInt16
+                for i in 0..<count {
+                    result += UInt16(truncatingIfNeeded: data[offset]) << (8 * i)
+                    offset += 1
+                }
+                return result
+            } (self.data, &self.offset)
+        #else
+            var result = 0 as UInt16
+            for i in 0..<count {
+                result += UInt16(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
+                self.offset += 1
+            }
+            return result
+        #endif
     }
 
 }