add Collection overload and make RequestBodyLength a struct

Author: dnadoba

Sources/AsyncHTTPClient/AsyncAwait/HTTPClientRequest.swift

@@ -82,7 +82,25 @@ extension HTTPClientRequest.Body {
     ) -> Self where Bytes.Element == UInt8 {
         self.init(.sequence(
             length: length,
-            canBeConsumedMultipleTimes: bytes is Collection
+            canBeConsumedMultipleTimes: false
+        ) { allocator in
+            if let buffer = bytes.withContiguousStorageIfAvailable({ allocator.buffer(bytes: $0) }) {
+                // fastpath
+                return buffer
+            }
+            // potentially really slow path
+            return allocator.buffer(bytes: bytes)
+        })
+    }
+    
+    @inlinable
+    public static func bytes<Bytes: Collection>(
+        length: RequestBodyLength,
+        _ bytes: Bytes
+    ) -> Self where Bytes.Element == UInt8 {
+        self.init(.sequence(
+            length: length,
+            canBeConsumedMultipleTimes: true
         ) { allocator in
             if let buffer = bytes.withContiguousStorageIfAvailable({ allocator.buffer(bytes: $0) }) {
                 // fastpath

Sources/AsyncHTTPClient/ConnectionPool/RequestBodyLength.swift

@@ -12,9 +12,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-public enum RequestBodyLength: Hashable {
+public struct RequestBodyLength {
     /// size of the request body is not known before starting the request
-    case dynamic
+    public static let dynamic: Self = .init(storage: .dynamic)
     /// size of the request body is fixed and exactly `count` bytes
-    case fixed(_ count: Int)
+    public static func fixed(_ count: Int) -> Self {
+        .init(storage: .fixed(count))
+    }
+    internal enum Storage: Hashable {
+        case dynamic
+        case fixed(_ count: Int)
+    }
+    internal var storage: Storage
 }

Sources/AsyncHTTPClient/RequestValidation.swift

@@ -23,7 +23,7 @@ extension HTTPHeaders {
         try self.validateFieldNames()
 
         if case .TRACE = method {
-            switch bodyLength {
+            switch bodyLength.storage {
             case .fixed(0):
                 break
             case .dynamic, .fixed:
@@ -36,7 +36,7 @@ extension HTTPHeaders {
         self.setTransportFraming(method: method, bodyLength: bodyLength)
 
         let connectionClose = self[canonicalForm: "connection"].lazy.map { $0.lowercased() }.contains("close")
-        switch bodyLength {
+        switch bodyLength.storage {
         case .dynamic:
             return .init(connectionClose: connectionClose, body: .stream)
         case .fixed(let length):
@@ -87,7 +87,7 @@ extension HTTPHeaders {
         self.remove(name: "Content-Length")
         self.remove(name: "Transfer-Encoding")
 
-        switch bodyLength {
+        switch bodyLength.storage {
         case .fixed(0):
             // if we don't have a body we might not need to send the Content-Length field
             // https://tools.ietf.org/html/rfc7230#section-3.3.2

Tests/AsyncHTTPClientTests/HTTPClientRequestTests.swift

@@ -500,7 +500,7 @@ extension Optional where Wrapped == HTTPClientRequest.Body {
             return buffer
         case .sequence(let announcedLength, _, let generate):
             let buffer = generate(ByteBufferAllocator())
-            if case let .fixed(announcedLength) = announcedLength,
+            if case let .fixed(announcedLength) = announcedLength.storage,
                announcedLength != buffer.readableBytes {
                 throw LengthMismatch(announcedLength: announcedLength, actualLength: buffer.readableBytes)
             }
@@ -510,7 +510,7 @@ extension Optional where Wrapped == HTTPClientRequest.Body {
             while var buffer = try await generate(ByteBufferAllocator()) {
                 accumulatedBuffer.writeBuffer(&buffer)
             }
-            if case let .fixed(announcedLength) = announcedLength,
+            if case let .fixed(announcedLength) = announcedLength.storage,
                announcedLength != accumulatedBuffer.readableBytes {
                 throw LengthMismatch(announcedLength: announcedLength, actualLength: accumulatedBuffer.readableBytes)
             }