Adding methods for writing unsigned Int so that writing a UInt64 is possible

Author: cowgp

Sources/BitWriter.swift

@@ -25,6 +25,10 @@ public protocol BitWriter {
 
     /// Writes `number`, using and advancing by `bitsCount` BIT positions.
     func write(number: Int, bitsCount: Int)
+    
+    /// because you cant convert a UInt64 into an Int without potential for overflowing it, we need an unsingned variant of `write`
+    /// Writes unsigned `number`, using and advancing by `bitsCount` BIT positions.
+    func write(unsignedNumber: UInt, bitsCount: Int)
 
     /// Writes `byte`, advancing by one BYTE position.
     func append(byte: UInt8)

Sources/LsbBitWriter.swift

@@ -54,7 +54,22 @@ public final class LsbBitWriter: BitWriter {
             mask <<= 1
         }
     }
+    
+    /**
+     Writes `number`, using and advancing by `bitsCount` BIT positions.
 
+     - Note: If `bitsCount` is smaller than the actual amount of `number`'s bits than the `number` will be truncated to
+     fit into `bitsCount` amount of bits.
+     - Note: Bits of `number` are processed using the same bit-numbering scheme as of the writer (i.e. "LSB 0").
+     - Note: this method is specifically useful when needing to write a UInt64 which can overflow and crash if converting to an Int when using the regular `write` method
+     */
+    public func write(unsignedNumber: UInt, bitsCount: Int) {
+        var mask: UInt = 1
+        for _ in 0..<bitsCount {
+            self.write(bit: unsignedNumber & mask > 0 ? 1 : 0)
+            mask <<= 1
+        }
+    }
     /**
      Writes `byte`, advancing by one BYTE position.
 

Sources/MsbBitWriter.swift

@@ -54,6 +54,22 @@ public final class MsbBitWriter: BitWriter {
             mask >>= 1
         }
     }
+    
+    /**
+     Writes `number`, using and advancing by `bitsCount` BIT positions.
+
+     - Note: If `bitsCount` is smaller than the actual amount of `number`'s bits than the `number` will be truncated to
+     fit into `bitsCount` amount of bits.
+     - Note: Bits of `number` are processed using the same bit-numbering scheme as of the writer (i.e. "MSB 0").
+     - Note: this method is specifically useful when needing to write a UInt64 which can overflow and crash if converting to an Int when using the regular `write` method
+     */
+    public func write(unsignedNumber: UInt, bitsCount: Int) {
+        var mask: UInt = 1 << (UInt(bitsCount) - 1)
+        for _ in 0..<bitsCount {
+            self.write(bit: unsignedNumber & mask > 0 ? 1 : 0)
+            mask >>= 1
+        }
+    }
 
     /**
      Writes `byte`, advancing by one BYTE position.