Add read InlineArray + tests

Author: MahdiBM

Sources/NIOCore/ByteBuffer-aux.swift

@@ -58,6 +58,48 @@ extension ByteBuffer {
         return result
     }
 
+    #if compiler(>=6.2) && !canImport(Darwin)
+    @inlinable
+    public mutating func readInlineArray<
+        let count: Int,
+        IntegerType: FixedWidthInteger
+    >(
+        endianness: Endianness = .big,
+        as: InlineArray<count, IntegerType>.Type = InlineArray<count, IntegerType>.self
+    ) -> InlineArray<count, IntegerType>? {
+        let length = MemoryLayout<IntegerType>.size
+        let bytesRequired = length &* count
+
+        guard self.readableBytes >= bytesRequired else {
+            return nil
+        }
+
+        return self.readWithUnsafeReadableBytes {
+            ptr -> (Int, InlineArray<count, IntegerType>) in
+            assert(ptr.count >= bytesRequired)
+            let values: InlineArray<count, IntegerType> = InlineArray { index in
+                switch endianness {
+                case .big:
+                    return IntegerType(
+                        bigEndian: ptr.load(
+                            fromByteOffset: index &* length,
+                            as: IntegerType.self
+                        )
+                    )
+                case .little:
+                    return IntegerType(
+                        littleEndian: ptr.load(
+                            fromByteOffset: index &* length,
+                            as: IntegerType.self
+                        )
+                    )
+                }
+            }
+            return (bytesRequired, values)
+        }
+    }
+    #endif
+
     /// Returns the Bytes at the current reader index without advancing it.
     ///
     /// This method is equivalent to calling `getBytes(at: readerIndex, ...)`

Tests/NIOCoreTests/ByteBufferTest.swift

@@ -3932,6 +3932,47 @@ extension ByteBufferTest {
         XCTAssertEqual(0, self.buf.readableBytes, "Buffer should be fully consumed after all reads.")
     }
 
+    #if compiler(>=6.2) && !canImport(Darwin)
+    func testReadInlineArrayOfUInt8() throws {
+        let bytes = (0..<10).map { _ in UInt8.random(in: .min ... .max) }
+
+        let startWriterIndex = self.buf.writerIndex
+        let written = self.buf.writeBytes(bytes)
+        XCTAssertEqual(startWriterIndex + written, self.buf.writerIndex)
+        XCTAssertEqual(written, self.buf.readableBytes)
+
+        let result = try XCTUnwrap(
+            self.buf.readInlineArray(as: InlineArray<10, UInt8>.self)
+        )
+        XCTAssertEqual(10, result.count)
+        for idx in result.indices {
+            XCTAssertEqual(bytes[idx], result[idx])
+        }
+        XCTAssertEqual(0, self.buf.readableBytes)
+    }
+
+    func testReadInlineArrayOfUInt64() throws {
+        let bytes = (0..<10).map { _ in UInt64.random(in: .min ... .max) }
+
+        let startWriterIndex = self.buf.writerIndex
+        var written = 0
+        for byte in bytes {
+            written += self.buf.writeInteger(byte)
+        }
+        XCTAssertEqual(startWriterIndex + written, self.buf.writerIndex)
+        XCTAssertEqual(written, self.buf.readableBytes)
+
+        let result = try XCTUnwrap(
+            self.buf.readInlineArray(as: InlineArray<10, UInt64>.self)
+        )
+        XCTAssertEqual(10, result.count)
+        for idx in result.indices {
+            XCTAssertEqual(bytes[idx], result[idx])
+        }
+        XCTAssertEqual(0, self.buf.readableBytes)
+    }
+    #endif
+
     func testByteBufferEncode() throws {
         let encoder = JSONEncoder()
         let hello = "Hello, world!"