bit array

Author: ay42

Package.resolved

@@ -8,11 +8,8 @@ let package = Package(
     products: [
         .library(name: "Binary", targets: ["Binary"]),
     ],
-    dependencies: [
-        .package(name: "List", url: "[email protected]:spacenation/swift-list.git", .upToNextMajor(from: "1.0.0")),
-    ],
     targets: [
-        .target(name: "Binary", dependencies: ["List"]),
+        .target(name: "Binary"),
         .testTarget(name: "BinaryTests", dependencies: ["Binary"])
     ]
 )

Package.swift

@@ -0,0 +1,46 @@
+import Foundation
+
+public extension BitArray {
+    static func +(lhs: BitArray, rhs: BitArray) -> BitArray {
+        lhs.append(rhs)
+    }
+    
+    static func +(lhs: Bool, rhs: BitArray) -> BitArray {
+        BitArray(bool: lhs).append(rhs)
+    }
+    
+    static func +(lhs: BitArray, rhs: Bool) -> BitArray {
+        lhs.append(BitArray(bool: rhs))
+    }
+    
+    func append(byte: UInt8) -> BitArray {
+        self.append(BitArray(byte: byte))
+    }
+    
+    func append(_ other: BitArray) -> BitArray {
+        guard let lastByte = self.bytes.last else { return other }
+        guard let nextByte = other.bytes.first else { return self }
+        
+        let bitsInLastByte = length % 8
+        let lengthRemainingInNextByte = Swift.min(8, other.length)
+    
+        switch bitsInLastByte {
+        /// Aligned append
+        case 0:
+            return BitArray(bytes: self.bytes + other.bytes, length: self.length + other.length)
+        /// New length fits into existing byte
+        case _ where bitsInLastByte + lengthRemainingInNextByte <= 8:
+            let modifiedLastByte: UInt8 = lastByte | (nextByte >> UInt8(bitsInLastByte))
+            let newBytes: [UInt8] = self.bytes.dropLast() + [modifiedLastByte]
+            return BitArray(bytes: newBytes, length: self.length + other.length)
+        /// New byte size required
+        default:
+            let modifiedLastByte: UInt8 = lastByte | (nextByte >> UInt8(bitsInLastByte))
+            let newByte: UInt8 = nextByte << (8 - UInt8(bitsInLastByte))
+            let newBytes: [UInt8] = self.bytes.dropLast() + [modifiedLastByte, newByte]
+            
+            return BitArray(bytes: newBytes, length: self.length + lengthRemainingInNextByte)
+                .append(BitArray(bytes: Array(other.bytes.dropFirst()), length: other.length - lengthRemainingInNextByte))
+        }
+    }
+}

Sources/Binary/Binary.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+extension BitArray: Collection {
+    public typealias Index = Int
+    
+    public var startIndex: Int {
+        0
+    }
+    
+    public var endIndex: Int {
+        length - 1
+    }
+    
+    public subscript(position: Int) -> Bool {
+        self[safe: position]!
+    }
+    
+    public func index(after i: Int) -> Int {
+        i + 1
+    }
+}

Sources/Binary/Bit.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+extension BitArray: Sequence {
+    public func makeIterator() -> BitArrayIterator {
+        BitArrayIterator(offset: 0, bitArray: self)
+    }
+}
+
+public struct BitArrayIterator: IteratorProtocol {
+    public internal(set) var offset: Int
+    public let bitArray: BitArray
+    
+    public init(offset: Int, bitArray: BitArray) {
+        self.offset = offset
+        self.bitArray = bitArray
+    }
+    
+    public mutating func next() -> Bool? {
+        defer {
+            offset += 1
+        }
+        return bitArray[safe: offset]
+    }
+}

Sources/Binary/BitArray/BitArray+Append.swift

@@ -0,0 +1,122 @@
+
+public struct BitArray {
+    
+    public static let empty = BitArray()
+    
+    public internal(set) var length: Int
+    public internal(set) var bytes: [UInt8]
+   
+
+    public init() {
+        length = 0
+        bytes = []
+    }
+    
+    public init(bytes: [UInt8], length: Int) {
+        self.length = length
+        self.bytes = bytes
+    }
+
+    public init(bytes: [UInt8]) {
+        length = bytes.count * 8
+        self.bytes = bytes
+    }
+    
+    public init(byte: UInt8) {
+        length = 8
+        self.bytes = [byte]
+    }
+    
+    public init(byte: UInt8, length: Int) {
+        self.length = length
+        self.bytes = [byte]
+    }
+    
+    public init(bool: Bool) {
+        length = 1
+        switch bool {
+        case true:
+            self.bytes = [0b10000000]
+        case false:
+            self.bytes = [0]
+        }
+    }
+    
+    public init(bools: [Bool]) {
+        self = bools.reduce(.empty, +)
+    }
+    
+    public var asUInt8: UInt8 {
+        bytes.first!
+    }
+    
+    public subscript(safe index: Int) -> Bool? {
+        guard index >= 0, index < length else { return nil }
+        let bitIndex = index % 8
+        let byteIndex = index / 8
+        let byte = bytes[byteIndex]
+        let int = byte >> (8 - (bitIndex + 1)) & 0x0001
+        return int == 0 ? false : true
+    }
+}
+
+extension BitArray : Hashable {}
+extension BitArray : Equatable {}
+
+extension BitArray: ExpressibleByArrayLiteral {
+    public init(arrayLiteral elements: Bool...) {
+        self.init(bools: elements)
+    }
+}
+
+
+extension BitArray: ExpressibleByIntegerLiteral {
+    public init(integerLiteral value: UInt8) {
+        self.init(byte: value)
+    }
+}
+
+func boolsToBytes(bools: [Bool]) -> [UInt8] {
+    let paddedBools = Array(repeating: false, count: max(8 - bools.count, 0)) + bools
+    let numBits = paddedBools.count
+    let numBytes = (numBits + 7)/8
+    var bytes = Array<UInt8>.init(repeating: 0, count: numBytes)
+
+    for (index, bit) in paddedBools.enumerated() {
+        if bit {
+            bytes[index / 8] += 1 << (7 - index % 8)
+        }
+    }
+
+    return bytes
+}
+
+public extension BitArray {
+    init(uInt8: UInt8, length: Int = 8) {
+        self.init(byte: uInt8, length: length)
+    }
+    
+    init(uInt16: UInt16, length: Int = 16) {
+        self.init(bytes: [UInt8(uInt16 & 0xff), UInt8(uInt16 >> 8)], length: length)
+    }
+    
+    init(uInt32: UInt32, length: Int = 32) {
+        self.init(bytes: [UInt8(uInt32 & 0x000000FF), UInt8((uInt32 & 0x0000FF00) >> 8), UInt8((uInt32 & 0x00FF0000) >> 16), UInt8((uInt32 & 0xFF000000) >> 24)], length: length)
+    }
+    
+    init(uInt64: UInt64, length: Int = 64) {
+        self.init(
+            bytes: [
+                UInt8(uInt64 & 0x00000000000000FF),
+                UInt8((uInt64 & 0x000000000000FF00) >> 8),
+                UInt8((uInt64 & 0x0000000000FF0000) >> 16),
+                UInt8((uInt64 & 0x00000000FF000000) >> 24),
+                UInt8((uInt64 & 0x000000FF00000000) >> 32),
+                UInt8((uInt64 & 0x0000FF0000000000) >> 40),
+                UInt8((uInt64 & 0x00FF000000000000) >> 48),
+                UInt8((uInt64 & 0xFF00000000000000) >> 56),
+            ],
+            length: length
+        )
+    }
+}