Use UnsafeBufferPointer instead of Data in ByteReader (note: it currently breaks non-zero-start-index tests)

Also remove "4.2 compiler workaround" for ByteReader

Author: tsolomko

Sources/ByteReader.swift

@@ -17,6 +17,8 @@ public class ByteReader {
     /// Offset to the byte in `data` which will be read next.
     public var offset: Int
 
+    var ptr: UnsafeBufferPointer<UInt8>
+
     /**
      True, if `offset` points at any position after the last byte in `data`.
 
@@ -45,20 +47,17 @@ public class ByteReader {
 
     /// Amount of bytes that were already read.
     public var bytesRead: Int {
-        #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
-            return { (data: Data, offset: Int) -> Int in
-                return offset - data.startIndex
-            } (self.data, self.offset)
-        #else
-            return self.offset - self.data.startIndex
-        #endif
+        return self.offset
     }
 
     /// Creates an instance for reading bytes from `data`.
     public init(data: Data) {
         self.size = data.count
         self.data = data
-        self.offset = data.startIndex
+        self.offset = 0
+        self.ptr = data.withUnsafeBytes { (ptr: UnsafePointer<UInt8>) -> UnsafeBufferPointer<UInt8> in
+            return UnsafeBufferPointer<UInt8>(start: ptr, count: data.count)
+        }
     }
 
     /**
@@ -67,17 +66,9 @@ public class ByteReader {
      - Precondition: There MUST be enough data left.
      */
     public func byte() -> UInt8 {
-        #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
-            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
+        precondition(self.offset < self.data.endIndex)
+        defer { self.offset += 1 }
+        return self.ptr[self.offset]
     }
 
     /**
@@ -88,17 +79,14 @@ public class ByteReader {
      */
     public func bytes(count: Int) -> [UInt8] {
         precondition(count >= 0)
-        #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
-            return { (data: Data, offset: inout Int) -> [UInt8] in
-                precondition(data.endIndex - offset >= count)
-                defer { offset += count }
-                return data[offset..<offset + count].toArray(type: UInt8.self, count: count)
-            } (self.data, &self.offset)
-        #else
-            precondition(bytesLeft >= count)
-            defer { self.offset += count }
-            return self.data[self.offset..<self.offset + count].toArray(type: UInt8.self, count: count)
-        #endif
+        precondition(bytesLeft >= count)
+        var result = [UInt8]()
+        result.reserveCapacity(count)
+        for _ in 0..<count {
+            result.append(self.ptr[self.offset])
+            self.offset += 1
+        }
+        return result
     }
 
     /**
@@ -111,25 +99,12 @@ public class ByteReader {
         precondition(count >= 0)
         // 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.
-        #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
-            return { (data: Data, offset: inout Int) -> Int in
-                precondition(data.endIndex - offset >= count)
-                var result = 0
-                for i in 0..<count {
-                    result += Int(truncatingIfNeeded: data[offset]) << (8 * i)
-                    offset += 1
-                }
-                return result
-            } (self.data, &self.offset)
-        #else
-            precondition(bytesLeft >= count)
-            var result = 0
-            for i in 0..<count {
-                result += Int(truncatingIfNeeded: self.data[self.offset]) << (8 * i)
-                self.offset += 1
-            }
-            return result
-        #endif
+        var result = 0
+        for i in 0..<count {
+            result += Int(truncatingIfNeeded: self.ptr[self.offset]) << (8 * i)
+            self.offset += 1
+        }
+        return result
     }
 
     /**
@@ -138,17 +113,7 @@ public class ByteReader {
      - Precondition: There MUST be enough data left.
      */
     public func uint64() -> UInt64 {
-        #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
-            return { (data: Data, offset: inout Int) -> UInt64 in
-                precondition(data.endIndex - offset >= 8)
-                defer { offset += 8 }
-                return data[offset..<offset + 8].to(type: UInt64.self)
-            } (self.data, &self.offset)
-        #else
-            precondition(bytesLeft >= 8)
-            defer { self.offset += 8 }
-            return self.data[self.offset..<self.offset + 8].to(type: UInt64.self)
-        #endif
+        return self.uint64(fromBytes: 8)
     }
 
     /**
@@ -162,25 +127,13 @@ public class ByteReader {
      */
     public func uint64(fromBytes count: Int) -> UInt64 {
         precondition(0...8 ~= count)
-        #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
-            return { (data: Data, offset: inout Int) -> UInt64 in
-                precondition(data.endIndex - offset >= count)
-                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
-            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
-        #endif
+        precondition(bytesLeft >= count)
+        var result = 0 as UInt64
+        for i in 0..<count {
+            result += UInt64(truncatingIfNeeded: self.ptr[self.offset]) << (8 * i)
+            self.offset += 1
+        }
+        return result
     }
 
     /**
@@ -189,17 +142,7 @@ public class ByteReader {
      - Precondition: There MUST be enough data left.
      */
     public func uint32() -> UInt32 {
-        #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
-            return { (data: Data, offset: inout Int) -> UInt32 in
-                precondition(data.endIndex - offset >= 4)
-                defer { offset += 4 }
-                return data[offset..<offset + 4].to(type: UInt32.self)
-            } (self.data, &self.offset)
-        #else
-            precondition(bytesLeft >= 4)
-            defer { self.offset += 4 }
-            return self.data[self.offset..<self.offset + 4].to(type: UInt32.self)
-        #endif
+        return self.uint32(fromBytes: 4)
     }
 
     /**
@@ -213,25 +156,13 @@ public class ByteReader {
      */
     public func uint32(fromBytes count: Int) -> UInt32 {
         precondition(0...4 ~= count)
-        #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
-            return { (data: Data, offset: inout Int) -> UInt32 in
-                precondition(data.endIndex - offset >= count)
-                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
-            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
-        #endif
+        precondition(bytesLeft >= count)
+        var result = 0 as UInt32
+        for i in 0..<count {
+            result += UInt32(truncatingIfNeeded: self.ptr[self.offset]) << (8 * i)
+            self.offset += 1
+        }
+        return result
     }
 
     /**
@@ -240,17 +171,7 @@ public class ByteReader {
      - Precondition: There MUST be enough data left.
      */
     public func uint16() -> UInt16 {
-        #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
-            return { (data: Data, offset: inout Int) -> UInt16 in
-                precondition(data.endIndex - offset >= 2)
-                defer { offset += 2 }
-                return data[offset..<offset + 2].to(type: UInt16.self)
-            } (self.data, &self.offset)
-        #else
-            precondition(bytesLeft >= 2)
-            defer { self.offset += 2 }
-            return self.data[self.offset..<self.offset + 2].to(type: UInt16.self)
-        #endif
+        return self.uint16(fromBytes: 2)
     }
 
     /**
@@ -264,25 +185,13 @@ public class ByteReader {
      */
     public func uint16(fromBytes count: Int) -> UInt16 {
         precondition(0...2 ~= count)
-        #if swift(>=4.1.50) || (swift(>=3.4) && !swift(>=4.0))
-            return { (data: Data, offset: inout Int) -> UInt16 in
-                precondition(data.endIndex - offset >= count)
-                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
-            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
-        #endif
+        precondition(bytesLeft >= count)
+        var result = 0 as UInt16
+        for i in 0..<count {
+            result += UInt16(truncatingIfNeeded: self.ptr[self.offset]) << (8 * i)
+            self.offset += 1
+        }
+        return result
     }
 
 }