More PR changes

Author: gjcairo

NOTICES.txt

@@ -31,10 +31,28 @@ It also uses derivations of SwiftNIO's lock 'NIOLock.swift' and locked value box
 
 ---
 
+This product uses derivations of SwiftNIO's HTTP2 implementation 'HPACKHeader.swift'.
+    
+    * LICENSE (Apache License 2.0):
+      * https://github.com/apple/swift-nio-http2/blob/main/LICENSE.txt
+    * HOMEPAGE:
+      * https://github.com/apple/swift-nio-http2
+
+---
+
 This product contains a derivation of the backpressure aware async stream from
 the Swift project.
 
   * LICENSE (Apache License 2.0):
     * https://github.com/apple/swift/blob/main/LICENSE.txt
   * HOMEPAGE:
     * https://github.com/apple/swift
+
+---
+
+This product uses derivations of swift-extras/swift-extras-base64 'Base64.swift'.
+
+  * LICENSE (Apache License 2.0):
+    * https://github.com/swift-extras/swift-extras-base64/blob/main/LICENSE
+  * HOMEPAGE:
+    * https://github.com/swift-extras/swift-extras-base64

Sources/GRPCCore/Internal/Base64.swift

@@ -70,25 +70,25 @@
  SOFTWARE.
  */
 
-public enum Base64 {}
+internal enum Base64 {}
 
 extension Base64 {
-  public struct DecodingOptions: OptionSet {
-    public let rawValue: UInt
-    public init(rawValue: UInt) { self.rawValue = rawValue }
+  internal struct DecodingOptions: OptionSet {
+    internal let rawValue: UInt
+    internal init(rawValue: UInt) { self.rawValue = rawValue }
 
-    public static let base64UrlAlphabet = DecodingOptions(rawValue: UInt(1 << 0))
-    public static let omitPaddingCharacter = DecodingOptions(rawValue: UInt(1 << 1))
+    internal static let base64UrlAlphabet = DecodingOptions(rawValue: UInt(1 << 0))
+    internal static let omitPaddingCharacter = DecodingOptions(rawValue: UInt(1 << 1))
   }
 
-  public enum DecodingError: Error, Equatable {
+  internal enum DecodingError: Error, Equatable {
     case invalidLength
     case invalidCharacter(UInt8)
     case unexpectedPaddingCharacter
     case unexpectedEnd
   }
 
-  public static func decode(string encoded: String, options: DecodingOptions = []) throws -> [UInt8]
+  internal static func decode(string encoded: String, options: DecodingOptions = []) throws -> [UInt8]
   {
     let decoded = try encoded.utf8.withContiguousStorageIfAvailable {
       (characterPointer) -> [UInt8] in

Sources/GRPCCore/Internal/String+Extensions.swift

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2023, gRPC Authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftNIO open source project
+//
+// Copyright (c) 2017-2023 Apple Inc. and the SwiftNIO project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftNIO project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+internal extension UInt8 {
+    @inlinable
+    var isASCII: Bool {
+        return self <= 127
+    }
+}
+
+internal extension String.UTF8View {
+    /// Compares two UTF8 strings as case insensitive ASCII bytes.
+    ///
+    /// - Parameter bytes: The string constant in the form of a collection of `UInt8`
+    /// - Returns: Whether the collection contains **EXACTLY** this array or no, but by ignoring case.
+    @inlinable
+    func compareCaseInsensitiveASCIIBytes(to other: String.UTF8View) -> Bool {
+            // fast path: we can get the underlying bytes of both
+            let maybeMaybeResult = self.withContiguousStorageIfAvailable { lhsBuffer -> Bool? in
+                other.withContiguousStorageIfAvailable { rhsBuffer in
+                    if lhsBuffer.count != rhsBuffer.count {
+                        return false
+                    }
+
+                    for idx in 0 ..< lhsBuffer.count {
+                        // let's hope this gets vectorised ;)
+                        if lhsBuffer[idx] & 0xdf != rhsBuffer[idx] & 0xdf && lhsBuffer[idx].isASCII {
+                            return false
+                        }
+                    }
+                    return true
+                }
+            }
+
+            if let maybeResult = maybeMaybeResult, let result = maybeResult {
+                return result
+            } else {
+                return self._compareCaseInsensitiveASCIIBytesSlowPath(to: other)
+            }
+    }
+
+    @inlinable
+    @inline(never)
+    func _compareCaseInsensitiveASCIIBytesSlowPath(to other: String.UTF8View) -> Bool {
+        return self.elementsEqual(other, by: { return (($0 & 0xdf) == ($1 & 0xdf) && $0.isASCII) })
+    }
+}
+
+
+internal extension String {
+    @inlinable
+    func isEqualCaseInsensitiveASCIIBytes(to: String) -> Bool {
+        return self.utf8.compareCaseInsensitiveASCIIBytes(to: to.utf8)
+    }
+}
+