Merge branch 'develop' into release-1.0.0

Author: tsolomko

BitByteData.podspec

@@ -2,9 +2,9 @@ Pod::Spec.new do |s|
 
   s.name         = "BitByteData"
   s.version      = "1.0.0-test.1"
-  s.summary      = "Read bits and bytes from data consequently in Swift."
+  s.summary      = "Read and write bits and bytes from data consequently in Swift."
 
-  s.description  = "A Swift framework with functions for reading bytes and bits from Data consequently."
+  s.description  = "A Swift framework with functions for reading and writing bytes and bits."
 
   s.homepage     = "https://github.com/tsolomko/BitByteData"
   s.documentation_url = "http://tsolomko.github.io/BitByteData"
@@ -22,4 +22,8 @@ Pod::Spec.new do |s|
 
   s.source_files = "Sources/*.swift"
 
+  s.test_spec 'Tests' do |test_spec|
+    test_spec.source_files = 'Tests/BitByteDataTests/*.swift'
+  end
+
 end

README.md

@@ -4,11 +4,12 @@
 [![GitHub license](https://img.shields.io/badge/license-MIT-lightgrey.svg)](https://raw.githubusercontent.com/tsolomko/BitByteData/master/LICENSE)
 [![Build Status](https://travis-ci.org/tsolomko/BitByteData.svg?branch=develop)](https://travis-ci.org/tsolomko/BitByteData)
 
-A Swift framework with classes for reading bytes and bits consequently.
+A Swift framework with classes for reading and writing bytes and bits.
 
 ## Installation
 
 Right now only Swift Package manager is supported.
+(Carthage and CocoaPods will be available at the 1.0 release).
 To install using SPM, add BitByteData to you package dependencies
 and specify it as a dependency for your target, e.g.:
 
@@ -46,7 +47,4 @@ This documentation can be found at its own [website](http://tsolomko.github.io/B
 Whether you find a bug, have a suggestion, idea or something else,
 please [create an issue](https://github.com/tsolomko/BitByteData/issues) on GitHub.
 
-In case you have encoutered a bug, it would be especially helpful if you attach a file (archive, etc.)
-that caused the bug to happen.
-
 If you'd like to contribute code, please [create a pull request](https://github.com/tsolomko/BitByteData/pulls) on GitHub.

Sources/BitReader.swift

@@ -7,18 +7,29 @@ import Foundation
 
 public protocol BitReader: class {
 
-    var bitMask: UInt8 { get }
-
     var isAligned: Bool { get }
 
     init(data: Data)
 
     func bits(count: Int) -> [UInt8]
 
+    // TODO: Rename?
     func intFromBits(count: Int) -> Int
 
     func bit() -> Int
 
     func align()
 
+    // TODO: Describe preconditions.
+
+    func byte() -> UInt8
+
+    func bytes(count: Int) -> [UInt8]
+
+    func uint64() -> UInt64
+
+    func uint32() -> UInt32
+
+    func uint16() -> UInt16
+
 }

Sources/BitWriter.swift

@@ -0,0 +1,39 @@
+// Copyright (c) 2017 Timofey Solomko
+// Licensed under MIT License
+//
+// See LICENSE for license information
+
+import Foundation
+
+public protocol BitWriter {
+
+    var data: Data { get }
+
+    init()
+
+    var isAligned: Bool { get }
+
+    func write(bit: UInt8)
+
+    func write(bits: [UInt8])
+
+    // TODO: Describe, what will happen if `bitsCount` is smaller than actual amount of `number`'s bits.
+    // TODO: Describe, that `number` is processed in the same order as `BitWriter`'s.
+    func write(number: Int, bitsCount: Int)
+
+    func append(byte: UInt8)
+
+    // TODO: Describe, that it doesn't check if it actually needs to align.
+    func align()
+
+}
+
+extension BitWriter {
+
+    public func write(bits: [UInt8]) {
+        for bit in bits {
+            self.write(bit: bit)
+        }
+    }
+
+}

Sources/LsbBitReader.swift

@@ -7,17 +7,12 @@ import Foundation
 
 public final class LsbBitReader: ByteReader, BitReader {
 
-    public private(set) var bitMask: UInt8
+    private var bitMask: UInt8 = 1
 
     public var isAligned: Bool {
         return self.bitMask == 1
     }
 
-    public override init(data: Data) {
-        self.bitMask = 1
-        super.init(data: data)
-    }
-
     public func bits(count: Int) -> [UInt8] {
         guard count > 0 else {
             return []

Sources/LsbBitWriter.swift

@@ -0,0 +1,54 @@
+// Copyright (c) 2017 Timofey Solomko
+// Licensed under MIT License
+//
+// See LICENSE for license information
+
+import Foundation
+
+public final class LsbBitWriter: BitWriter {
+
+    public private(set) var data: Data = Data()
+
+    private var bitMask: UInt8 = 1
+    private var currentByte: UInt8 = 0
+
+    public var isAligned: Bool {
+        return self.bitMask == 1
+    }
+
+    public init() { }
+
+    public func write(bit: UInt8) {
+        precondition(bit <= 1, "A bit must be either 0 or 1.")
+
+        self.currentByte += self.bitMask * bit
+
+        if self.bitMask == 128 {
+            self.bitMask = 1
+            self.data.append(self.currentByte)
+            self.currentByte = 0
+        } else {
+            self.bitMask <<= 1
+        }
+    }
+
+    public func write(number: Int, bitsCount: Int) {
+        var mask = 1
+        for _ in 0..<bitsCount {
+            self.write(bit: number & mask > 0 ? 1 : 0)
+            mask <<= 1
+        }
+    }
+
+    public func append(byte: UInt8) {
+        precondition(isAligned, "BitWriter is not aligned.")
+        self.data.append(byte)
+    }
+
+    public func align() {
+        self.data.append(self.currentByte)
+        self.currentByte = 0
+        self.bitMask = 1
+    }
+
+}

Sources/MsbBitReader.swift

@@ -7,17 +7,12 @@ import Foundation
 
 public final class MsbBitReader: ByteReader, BitReader {
 
-    public private(set) var bitMask: UInt8
+    private var bitMask: UInt8 = 128
 
     public var isAligned: Bool {
         return self.bitMask == 128
     }
 
-    public override init(data: Data) {
-        self.bitMask = 128
-        super.init(data: data)
-    }
-
     public func bits(count: Int) -> [UInt8] {
         guard count > 0 else {
             return []

Sources/MsbBitWriter.swift

@@ -0,0 +1,54 @@
+// Copyright (c) 2017 Timofey Solomko
+// Licensed under MIT License
+//
+// See LICENSE for license information
+
+import Foundation
+
+public final class MsbBitWriter: BitWriter {
+
+    public private(set) var data: Data = Data()
+
+    private var bitMask: UInt8 = 128
+    private var currentByte: UInt8 = 0
+
+    public var isAligned: Bool {
+        return self.bitMask == 128
+    }
+
+    public init() { }
+
+    public func write(bit: UInt8) {
+        precondition(bit <= 1, "A bit must be either 0 or 1.")
+
+        self.currentByte += self.bitMask * bit
+
+        if self.bitMask == 1 {
+            self.bitMask = 128
+            self.data.append(self.currentByte)
+            self.currentByte = 0
+        } else {
+            self.bitMask >>= 1
+        }
+    }
+
+    public func write(number: Int, bitsCount: Int) {
+        var mask = 1 << (bitsCount - 1)
+        for _ in 0..<bitsCount {
+            self.write(bit: number & mask > 0 ? 1 : 0)
+            mask >>= 1
+        }
+    }
+
+    public func append(byte: UInt8) {
+        precondition(isAligned, "BitWriter is not aligned.")
+        self.data.append(byte)
+    }
+
+    public func align() {
+        self.data.append(self.currentByte)
+        self.currentByte = 0
+        self.bitMask = 128
+    }
+
+}

Tests/BitByteDataTests/LsbBitReaderTests.swift

@@ -76,4 +76,4 @@ class LsbBitReaderTests: XCTestCase {
         XCTAssertTrue(bitReader.isAtTheEnd)
     }
 
-}
+}

Tests/BitByteDataTests/LsbBitWriterTests.swift

@@ -0,0 +1,73 @@
+// Copyright (c) 2017 Timofey Solomko
+// Licensed under MIT License
+//
+// See LICENSE for license information
+
+import XCTest
+import BitByteData
+
+class LsbBitWriterTests: XCTestCase {
+
+    func testWriteBit() {
+        let bitWriter = LsbBitWriter()
+
+        bitWriter.write(bit: 0)
+        bitWriter.write(bit: 1)
+        bitWriter.write(bit: 0)
+        bitWriter.write(bit: 1)
+        bitWriter.write(bit: 1)
+        bitWriter.align()
+        XCTAssertEqual(bitWriter.data, Data(bytes: [26]))
+    }
+
+    func testWriteBitsArray() {
+        let bitWriter = LsbBitWriter()
+
+        bitWriter.write(bits: [1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1])
+        bitWriter.align()
+        XCTAssertEqual(bitWriter.data, Data(bytes: [83, 6]))
+    }
+
+    func testWriteNumber() {
+        let bitWriter = LsbBitWriter()
+
+        bitWriter.write(number: 255, bitsCount: 8)
+        XCTAssertEqual(bitWriter.data, Data(bytes: [255]))
+        bitWriter.write(number: 6, bitsCount: 3)
+        XCTAssertEqual(bitWriter.data, Data(bytes: [255]))
+        bitWriter.write(number: 103, bitsCount: 7)
+        XCTAssertEqual(bitWriter.data, Data(bytes: [255, 62]))
+        bitWriter.align()
+        XCTAssertEqual(bitWriter.data, Data(bytes: [255, 62, 3]))
+    }
+
+    func testAppendByte() {
+        let bitWriter = LsbBitWriter()
+
+        bitWriter.append(byte: 0xCA)
+        XCTAssertEqual(bitWriter.data, Data(bytes: [0xCA]))
+    }
+
+    func testFinish() {
+        let bitWriter = LsbBitWriter()
+
+        bitWriter.align()
+        XCTAssertEqual(bitWriter.data, Data(bytes: [0]))
+        XCTAssertTrue(bitWriter.isAligned)
+    }
+
+    func testIsAligned() {
+        let bitWriter = MsbBitWriter()
+
+        bitWriter.write(bits: [0, 1, 0])
+        XCTAssertFalse(bitWriter.isAligned)
+        bitWriter.write(bits: [0, 1, 0, 1, 0])
+        XCTAssertTrue(bitWriter.isAligned)
+
+        bitWriter.write(bit: 0)
+        XCTAssertFalse(bitWriter.isAligned)
+        bitWriter.align()
+        XCTAssertTrue(bitWriter.isAligned)
+    }
+
+}