Replace sequence init with inline byte array init

Author: CTMacUser

Sources/ClassicFourCharCode/ClassicFourCharCode.swift

@@ -139,79 +139,6 @@ extension ClassicFourCharCode {
   public var isPrintable: Bool { !haveOctetsUnder(0x20) && !hasOctet(of: 0x7F) }
 }
 
-// MARK: More Initializers
-
-extension ClassicFourCharCode {
-  /// Creates a new code repeating the given byte value.
-  ///
-  /// - Parameter value: The octet to repeat.
-  /// - Postcondition: `self.elementsEqual(repeatElement(value, count: 4))`
-  @inlinable
-  public init(repeating value: UInt8) {
-    self.init(rawValue: FourCharCode(value) &* 0x0101_0101)
-  }
-
-  /// Creates a code from the given byte values, in order.
-  ///
-  /// - Parameters
-  ///   - first: The most-significant byte stored in the code.
-  ///   - second: The second-most significant byte stored in the code.
-  ///   - third: The second-lowest significant byte stored in the code.
-  ///   - fourth: The least-significant byte stored in the code.
-  /// - Postcondition: `self.elementsEqual([first, second, third, fourth])`
-  @inlinable
-  public init(
-    rawOctets first: UInt8,
-    _ second: UInt8,
-    _ third: UInt8,
-    _ fourth: UInt8
-  ) {
-    self.init(
-      rawValue: FourCharCode(first) &* 0x0100_0000 | FourCharCode(second)
-        &* 0x0001_0000 | FourCharCode(third) &* 0x0000_0100
-        | FourCharCode(fourth)
-    )
-  }
-
-  /// Creates a code from combining bytes extracted from the given iterator.
-  ///
-  /// - Parameter iterator: The source of the bytes to extract.
-  /// - Postcondition: `self.elementsEqual([A, B, C, D])`,
-  ///   where `A`, `B`, `C`, and `D` are the first four bytes extracted from
-  ///   `iterator` (in that order).
-  ///   Any later elements are untouched.
-  ///   If `iterator` doesn't have at least four elements available,
-  ///   this initializer fails.
-  public init?(extractingFrom iterator: inout some IteratorProtocol<UInt8>) {
-    guard let first = iterator.next(), let second = iterator.next(),
-      let third = iterator.next(), let fourth = iterator.next()
-    else { return nil }
-    self.init(rawOctets: first, second, third, fourth)
-  }
-
-  /// Creates a code from combining bytes read from the given sequence.
-  ///
-  /// - Parameters:
-  ///   - sequence: The source of the bytes to read.
-  ///   - useAllBytes: Whether every element from `sequence` needs to be read
-  ///     from.
-  ///     If not given,
-  ///     defaults to `true`,
-  ///     meaning the entire `sequence` needs to be read in.
-  /// - Postcondition: `self.elementsEqual(sequence.prefix(4))`.
-  ///   If the `sequence` either has less than four elements,
-  ///   or it has more than four elements while `useAllBytes` is `true`,
-  ///   this initializer fails.
-  public init?(
-    reading sequence: some Sequence<UInt8>,
-    totally useAllBytes: Bool = true
-  ) {
-    var iterator = sequence.makeIterator()
-    self.init(extractingFrom: &iterator)
-    guard !useAllBytes || iterator.next() == nil else { return nil }
-  }
-}
-
 // MARK: Element Access
 
 extension ClassicFourCharCode: ContiguousBytes {
@@ -222,3 +149,39 @@ extension ClassicFourCharCode: ContiguousBytes {
     return try Swift.withUnsafeBytes(of: &bigRawValue, body)
   }
 }
+
+@available(macOS 26.0, *)
+extension ClassicFourCharCode {
+  /// The four character codes, separated.
+  ///
+  /// The first element is the string value's first character and
+  /// the numeric value's highest-order code.
+  /// Later elements correspond to later characters and lower-order codes.
+  public var octets: [4 of UInt8] {
+    .init({ index in
+      return .init(truncatingIfNeeded: rawValue >> (8 * (3 - index)))
+    })
+  }
+
+  /// Creates a code from the given quartet of byte values.
+  ///
+  /// - Parameter octets: The four separated character codes,
+  ///   starting from the string value's first character,
+  ///   which is also the numeric value's highest-order octet.
+  ///   Subsequent elements map to later characters in the string view and
+  ///   lower-order octets in the numeric value.
+  /// - Postcondition: `self.rawValue ==`
+  ///   `octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]`
+  public init(octets: [4 of UInt8]) {
+    self.init(
+      rawValue: octets.span.withUnsafeBufferPointer({ buffer in
+        return buffer.lazy.map(FourCharCode.init(truncatingIfNeeded:)).reduce(
+          into: 0
+        ) {
+          $0 <<= 8
+          $0 |= $1
+        }
+      })
+    )
+  }
+}

Tests/ClassicFourCharCodeTests/ClassicFourCharCodeTests.swift

@@ -149,26 +149,10 @@ func memoryRead(_ rawCode: FourCharCode, _ octets: [UInt8]) async throws {
   #expect(code.withUnsafeBytes { $0.elementsEqual(octets) })
 }
 
-/// Test repeating-value initializer.
-@Test("Repeating single octet initializer")
-func repeating() async throws {
-  for i in UInt8.min...UInt8.max {
-    let code = ClassicFourCharCode(repeating: i)
-    let expectedRawValue = stride(from: 24, through: 0, by: -8).map {
-      FourCharCode(i) << $0
-    }.reduce(0, |)
-    #expect(
-      code.withUnsafeBytes({ bufferPointer in
-        return bufferPointer.elementsEqual(repeatElement(i, count: 4))
-      })
-    )
-    #expect(code.rawValue == expectedRawValue)
-  }
-}
-
-/// Test seperate-bytes initializer.
+/// Test reading from inline arrays.
+@available(macOS 26.0, *)
 @Test(
-  "Individual byte initializer",
+  "Initialize from inline array",
   arguments: zip(
     [
       [0, 0, 0, 0],
@@ -180,58 +164,13 @@ func repeating() async throws {
     ]
   )
 )
-func seperateBytes(_ octets: [UInt8], `as` rawCode: FourCharCode) async throws {
-  #expect(
-    ClassicFourCharCode(rawOctets: octets[0], octets[1], octets[2], octets[3])
-      == ClassicFourCharCode(rawValue: rawCode)
-  )
-}
-
-/// Test reading from iterators and sequences.
-@Test("Initialize from iterator/sequence")
-func initializeFromSequence() async throws {
-  let source2 = [0x41 as UInt8, 0x42, 0x43, 0x44, 0x61, 0x62, 0x63, 0x64]
-  do {
-    var iterator = source2.makeIterator()
-    let code1 = ClassicFourCharCode(extractingFrom: &iterator)
-    let code2 = ClassicFourCharCode(extractingFrom: &iterator)
-    #expect(code1 == .some(.init(rawValue: 0x4142_4344)))
-    #expect(code2 == .some(.init(rawValue: 0x6162_6364)))
-    #expect(iterator.next() == nil)
-  }
-  do {
-    var iterator = source2.prefix(3).makeIterator()
-    let code1 = ClassicFourCharCode(extractingFrom: &iterator)
-    #expect(code1 == .none)
-  }
-  do {
-    let code1 = ClassicFourCharCode(reading: source2.prefix(4))
-    #expect(code1 == .some(.init(rawValue: 0x4142_4344)))
-
-    let code2 = ClassicFourCharCode(reading: source2.prefix(4), totally: true)
-    #expect(code2 == .some(.init(rawValue: 0x4142_4344)))
-
-    let code3 = ClassicFourCharCode(reading: source2.prefix(4), totally: false)
-    #expect(code3 == .some(.init(rawValue: 0x4142_4344)))
-  }
-  do {
-    let code1 = ClassicFourCharCode(reading: source2.suffix(4))
-    #expect(code1 == .some(.init(rawValue: 0x6162_6364)))
-
-    let code2 = ClassicFourCharCode(reading: source2.suffix(4), totally: true)
-    #expect(code2 == .some(.init(rawValue: 0x6162_6364)))
-
-    let code3 = ClassicFourCharCode(reading: source2.suffix(4), totally: false)
-    #expect(code3 == .some(.init(rawValue: 0x6162_6364)))
-  }
-  do {
-    let code1 = ClassicFourCharCode(reading: source2)
-    #expect(code1 == .none)
-
-    let code2 = ClassicFourCharCode(reading: source2, totally: true)
-    #expect(code2 == .none)
-
-    let code3 = ClassicFourCharCode(reading: source2, totally: false)
-    #expect(code3 == .some(.init(rawValue: 0x4142_4344)))
+func initializeFromArray(_ octets: [UInt8], `as` rawCode: FourCharCode)
+  async throws
+{
+  let array: InlineArray = [octets[0], octets[1], octets[2], octets[3]]
+  let code = ClassicFourCharCode(octets: array)
+  #expect(code.rawValue == rawCode)
+  code.octets.span.withUnsafeBufferPointer { buffer in
+    #expect(buffer.elementsEqual(octets))
   }
 }