Refactoring

yaslab · Dec 14, 2016 · eeb69ed · eeb69ed
1 parent d636de2
commit eeb69ed
Show file tree

Hide file tree

Showing 7 changed files with 81 additions and 115 deletions.
diff --git a/Sources/List.swift b/Sources/List.swift
@@ -10,85 +10,85 @@ import Foundation
 
 internal enum ListSerializer {
 
-    static func serialize<T: Serializable>(_ data: NSMutableData, _ values: List<T>?) -> Int {
+    static func serialize<T: Serializable>(_ bytes: NSMutableData, _ values: List<T>?) -> Int {
         if let values = values {
-            let offset = data.length
+            let offset = bytes.length
             var byteSize = 0
 
             if let _ = T.length {
-                byteSize += BinaryUtility.serialize(data, values.count) // length
+                byteSize += BinaryUtility.serialize(bytes, values.count) // length
             } else {
-                byteSize += BinaryUtility.serialize(data, 0) // byteSize
-                byteSize += BinaryUtility.serialize(data, values.count) // length
+                byteSize += BinaryUtility.serialize(bytes, 0) // byteSize
+                byteSize += BinaryUtility.serialize(bytes, values.count) // length
                 for _ in 0 ..< values.count {
-                    byteSize += BinaryUtility.serialize(data, 0) // elementOffset
+                    byteSize += BinaryUtility.serialize(bytes, 0) // elementOffset
                 }
             }
 
             for i in 0 ..< values.count {
                 if T.length == nil {
                     // elementOffse
-                    _ = BinaryUtility.serialize(data, offset + 4 + 4 + (4 * i), data.length)
+                    _ = BinaryUtility.serialize(bytes, offset + 4 + 4 + (4 * i), bytes.length)
                 }
-                byteSize += T.serialize(data, -1, values[i])
+                byteSize += T.serialize(bytes, -1, values[i])
             }
 
             if T.length == nil {
                 // byteSize
-                _ = BinaryUtility.serialize(data, offset, byteSize)
+                _ = BinaryUtility.serialize(bytes, offset, byteSize)
             }
 
             return byteSize
         } else {
-            return BinaryUtility.serialize(data, -1) // length
+            return BinaryUtility.serialize(bytes, -1) // length
         }
     }
 
-    static func serializeAsList<T: Serializable>(_ data: NSMutableData, _ values: Array<T>?) -> Int {
+    static func serializeAsList<T: Serializable>(_ bytes: NSMutableData, _ values: Array<T>?) -> Int {
         if let values = values {
-            let offset = data.length
+            let offset = bytes.length
             var byteSize = 0
 
             if T.length != nil {
-                byteSize += BinaryUtility.serialize(data, values.count) // length
+                byteSize += BinaryUtility.serialize(bytes, values.count) // length
             } else {
-                byteSize += BinaryUtility.serialize(data, 0) // byteSize
-                byteSize += BinaryUtility.serialize(data, values.count) // length
+                byteSize += BinaryUtility.serialize(bytes, 0) // byteSize
+                byteSize += BinaryUtility.serialize(bytes, values.count) // length
                 for _ in 0 ..< values.count {
-                    byteSize += BinaryUtility.serialize(data, 0) // elementOffset
+                    byteSize += BinaryUtility.serialize(bytes, 0) // elementOffset
                 }
             }
 
             for i in 0 ..< values.count {
                 if T.length == nil {
                     // elementOffset
-                    _ = BinaryUtility.serialize(data, offset + 4 + 4 + (4 * i), data.length)
+                    _ = BinaryUtility.serialize(bytes, offset + 4 + 4 + (4 * i), bytes.length)
                 }
-                byteSize += T.serialize(data, -1, values[i])
+                byteSize += T.serialize(bytes, -1, values[i])
             }
 
             if T.length == nil {
                 // byteSize
-                _ = BinaryUtility.serialize(data, offset, byteSize)
+                _ = BinaryUtility.serialize(bytes, offset, byteSize)
             }
 
             return byteSize
         } else {
-            return BinaryUtility.serialize(data, -1) // length
+            return BinaryUtility.serialize(bytes, -1) // length
         }
     }
 
 }
 
 public class List<T>: RandomAccessCollection {
 
-    let _originalData: NSData
+    let _originalBytes: NSData
     let _offset: Int
 
     let _count: Int
 
-    init?(data: NSData, offset: Int, count: Int) {
-        _originalData = data
+    init?(bytes: NSData, offset: Int, count: Int) {
+        _originalBytes = bytes
         _offset = offset
         _count = count
     }
@@ -121,21 +121,21 @@ public class FixedSizeList<T: Deserializable>: List<T> {
 
     let _itemSize: Int
 
-    init?(data: NSData, offset: Int, itemSize: Int) {
+    init?(bytes: NSData, offset: Int, itemSize: Int) {
         _itemSize = itemSize
         var tmp = 0
-        let length: Int = BinaryUtility.deserialize(data, offset, &tmp)
+        let length: Int = BinaryUtility.deserialize(bytes, offset, &tmp)
         if length < 0 {
             return nil
         }
-        super.init(data: data, offset: offset, count: length)
+        super.init(bytes: bytes, offset: offset, count: length)
     }
 
     // TODO: save to memory cache
     override public subscript(index: Int) -> T {
         let itemOffset = _offset + 4 + (_itemSize * index)
         var size = 0
-        return T.deserialize(_originalData, itemOffset, &size)
+        return T.deserialize(_originalBytes, itemOffset, &size)
     }
 
 }
@@ -144,22 +144,22 @@ public class VariableSizeList<T: Deserializable>: List<T> {
 
     let _byteSize: Int
 
-    init?(data: NSData, offset: Int) {
+    init?(bytes: NSData, offset: Int) {
         var currentOffset = offset
-        let byteSize: Int = BinaryUtility.deserialize(data, currentOffset, &currentOffset)
+        let byteSize: Int = BinaryUtility.deserialize(bytes, currentOffset, &currentOffset)
         if byteSize < 0 {
             return nil
         }
         _byteSize = byteSize
-        let length: Int = BinaryUtility.deserialize(data, currentOffset, &currentOffset)
-        super.init(data: data, offset: offset, count: length)
+        let length: Int = BinaryUtility.deserialize(bytes, currentOffset, &currentOffset)
+        super.init(bytes: bytes, offset: offset, count: length)
     }
 
     // TODO: save to memory cache
     override public subscript(index: Int) -> T {
         var tmp = 0
-        let itemOffset: Int = BinaryUtility.deserialize(_originalData, _offset + 4 + 4 + (4 * index), &tmp)
-        return T.deserialize(_originalData, itemOffset, &tmp)
+        let itemOffset: Int = BinaryUtility.deserialize(_originalBytes, _offset + 4 + 4 + (4 * index), &tmp)
+        return T.deserialize(_originalBytes, itemOffset, &tmp)
     }
 
 }
diff --git a/Sources/ObjectBuilder.swift b/Sources/ObjectBuilder.swift
@@ -10,75 +10,62 @@ import Foundation
 
 public class ObjectBuilder {
 
-    private let data: NSMutableData
+    private let bytes: NSMutableData
     private let offset: Int
 
-    private var appendFunctions = [(() -> Void)]()
+    private var functions = [(() -> Void)]()
 
-    internal init(_ data: NSMutableData) {
-        self.data = data
-        self.offset = data.length
+    internal init(_ bytes: NSMutableData) {
+        self.bytes = bytes
+        self.offset = bytes.length
+    }
+
+    var byteSize: Int {
+        return bytes.length - offset
     }
 
     private func begin() {
-        let lastIndex = appendFunctions.count - 1
-
         // byteSize
-        _ = BinaryUtility.serialize(data, 0)
+        _ = BinaryUtility.serialize(bytes, 0)
         // lastIndex
-        _ = BinaryUtility.serialize(data, lastIndex)
+        _ = BinaryUtility.serialize(bytes, functions.count - 1)
         // indexOffset
-        for _ in 0 ... lastIndex {
-            _ = BinaryUtility.serialize(data, 0)
+        for _ in 0 ..< functions.count {
+            _ = BinaryUtility.serialize(bytes, 0)
         }
     }
 
     private func updateIndexOffset(_ index: Int) {
-        let indexOffset = Int32(data.length)
-
-        let p = data.mutableBytes + offset + 4 + 4 + (4 * index)
-        p.assumingMemoryBound(to: Int32.self)[0] = indexOffset.littleEndian
+        let indexOffset = bytes.length
+        _ = BinaryUtility.serialize(bytes, offset + 4 + 4 + (4 * index), indexOffset)
     }
 
     private func end() {
-        let byteSize = Int32(data.length - offset)
-
-        let p = data.mutableBytes + offset
-        p.assumingMemoryBound(to: Int32.self)[0] = byteSize.littleEndian
+        _ = BinaryUtility.serialize(bytes, offset, byteSize)
     }
 
     internal func build() -> Int {
         begin()
-        for (i, appendFunction) in appendFunctions.enumerated() {
+        for (i, function) in functions.enumerated() {
             updateIndexOffset(i)
-            appendFunction()
+            function()
         }
         end()
-
-        return data.length - offset
+        return byteSize
     }
 
     // -----
 
     public func append<T: Serializable>(_ value: T) {
-        appendFunctions.append({ [unowned self] in _ = T.serialize(self.data, -1, value) })
+        functions.append({ [unowned self] in _ = T.serialize(self.bytes, -1, value) })
     }
 
     public func append<T: Serializable>(_ value: T?) {
-        appendFunctions.append({ [unowned self] in _ = T.serialize(self.data, -1, value) })
+        functions.append({ [unowned self] in _ = T.serialize(self.bytes, -1, value) })
     }
 
-    public func append<T: Serializable>(_ values: Array<T>?) {
-        appendFunctions.append({ [unowned self] in
-            if let values = values {
-                _ = BinaryUtility.serialize(self.data, values.count) // length
-                for value in values {
-                    _ = T.serialize(self.data, -1, value)
-                }
-            } else {
-                _ = BinaryUtility.serialize(self.data, -1) // length
-            }
-        })
+    public func append<T: Serializable>(_ value: Array<T>?) {
+        functions.append({ [unowned self] in _ = ArraySerializer.serialize(self.bytes, -1, value) })
     }
 
 }
diff --git a/Sources/ObjectExtractor.swift b/Sources/ObjectExtractor.swift
@@ -10,54 +10,48 @@ import Foundation
 
 public class ObjectExtractor {
 
-    private let data: NSData
+    private let bytes: NSData
     private let offset: Int
-    let isNil: Bool
-
-    private var functions = [(() -> Void)]()
 
-    var byteSize: Int {
-        let byteSize = (data.bytes + offset).assumingMemoryBound(to: Int32.self)[0].littleEndian
-        return Int(byteSize)
-    }
+    let byteSize: Int
+    let isNil: Bool
 
-    internal init(_ data: NSData, _ offset: Int) {
-        self.data = data
+    internal init(_ bytes: NSData, _ offset: Int) {
+        self.bytes = bytes
         self.offset = offset
-
-        let byteSize = (data.bytes + offset).assumingMemoryBound(to: Int32.self)[0].littleEndian
-        self.isNil = byteSize == -1
+        var tmp = 0
+        let byteSize: Int = BinaryUtility.deserialize(bytes, offset, &tmp)
+        self.byteSize = byteSize
+        self.isNil = (byteSize < 0)
     }
 
     // -----
 
     public func extract<T: Deserializable>(index: Int) -> T {
-        let p = (data.bytes + offset + 4 + 4 + (4 * index))
-        let indexOffset = p.assumingMemoryBound(to: Int32.self)[0].littleEndian
-        var size = 0
-        return T.deserialize(data, Int(indexOffset), &size)
+        var tmp = 0
+        let indexOffset: Int = BinaryUtility.deserialize(bytes, offset + 4 + 4 + (4 * index), &tmp)
+        return T.deserialize(bytes, Int(indexOffset), &tmp)
     }
 
     public func extract<T: Deserializable>(index: Int) -> T? {
-        let p = (data.bytes + offset + 4 + 4 + (4 * index))
-        let indexOffset = p.assumingMemoryBound(to: Int32.self)[0].littleEndian
-        var size = 0
-        return T.deserialize(data, Int(indexOffset), &size)
+        var tmp = 0
+        let indexOffset: Int = BinaryUtility.deserialize(bytes, offset + 4 + 4 + (4 * index), &tmp)
+        return T.deserialize(bytes, Int(indexOffset), &tmp)
     }
 
     public func extract<T: Deserializable>(index: Int) -> Array<T>? {
         var tmp = 0
-        let indexOffset: Int = BinaryUtility.deserialize(data, offset + 4 + 4 + (4 * index), &tmp)
+        let indexOffset: Int = BinaryUtility.deserialize(bytes, offset + 4 + 4 + (4 * index), &tmp)
 
         var byteSize = 0
-        let length: Int = BinaryUtility.deserialize(data, indexOffset, &byteSize)
+        let length: Int = BinaryUtility.deserialize(bytes, indexOffset, &byteSize)
         if length < 0 {
             return nil
         }
 
         var array = Array<T>()
         for _ in 0 ..< length {
-            array.append(T.deserialize(data, indexOffset + byteSize, &byteSize))
+            array.append(T.deserialize(bytes, indexOffset + byteSize, &byteSize))
         }
         return array
     }

diff --git a/Sources/StructBuilder.swift b/Sources/StructBuilder.swift
@@ -32,15 +32,8 @@ public class StructBuilder {
         _ = T.serialize(bytes, -1, value)
     }
 
-    public func append<T: Serializable>(_ values: Array<T>?) {
-        if let values = values {
-            _ = BinaryUtility.serialize(bytes, values.count)
-            for value in values {
-                _ = T.serialize(bytes, -1, value)
-            }
-        } else {
-            _ = BinaryUtility.serialize(bytes, -1)
-        }
+    public func append<T: Serializable>(_ value: Array<T>?) {
+        _ = ArraySerializer.serialize(bytes, -1, value)
     }
 
 }
diff --git a/Sources/StructExtractor.swift b/Sources/StructExtractor.swift
@@ -35,15 +35,7 @@ public class StructExtractor {
     }
 
     public func extract<T: Deserializable>(index: Int) -> Array<T>? {
-        let length: Int = BinaryUtility.deserialize(bytes, currentOffset, &currentOffset)
-        if length < 0 {
-            return nil
-        }
-        var array = Array<T>()
-        for _ in 0 ..< length {
-            array.append(T.deserialize(bytes, currentOffset, &currentOffset))
-        }
-        return array
+        return ArraySerializer.deserialize(bytes, currentOffset, &currentOffset)
     }
 
 }
diff --git a/Sources/deserialize().swift b/Sources/deserialize().swift
@@ -25,8 +25,8 @@ public func deserialize<T: Deserializable>(_ bytes: NSData) -> Array<T>? {
 
 public func deserialize<T: Deserializable>(_ bytes: NSData) -> List<T>? {
     if let itemSize = T.length {
-        return FixedSizeList<T>(data: bytes, offset: 0, itemSize: itemSize)
+        return FixedSizeList<T>(bytes: bytes, offset: 0, itemSize: itemSize)
     } else {
-        return VariableSizeList<T>(data: bytes, offset: 0)
+        return VariableSizeList<T>(bytes: bytes, offset: 0)
     }
 }
diff --git a/Tests/ZeroFormatterTests/ListTestCase.internal.swift b/Tests/ZeroFormatterTests/ListTestCase.internal.swift
@@ -44,7 +44,7 @@ class ListTestCase_internal: XCTestCase {
         ]
 
         let expected: [Int16] = [1, 2, 3, 4, 5]
-        let actual = FixedSizeList<Int16>(data: testData.toData(), offset: 0, itemSize: Int16.length!)
+        let actual = FixedSizeList<Int16>(bytes: testData.toData(), offset: 0, itemSize: Int16.length!)
 
         XCTAssertNotNil(actual)
         XCTAssertEqual(actual!.count, 5)
@@ -90,7 +90,7 @@ class ListTestCase_internal: XCTestCase {
             VariableSizeObject(a: 2, b: "01234", c: 3),
             VariableSizeObject(a: 4, b: "567890", c: 5)
         ]
-        let actual = VariableSizeList<VariableSizeObject>(data: testData.toData(), offset: 0)
+        let actual = VariableSizeList<VariableSizeObject>(bytes: testData.toData(), offset: 0)
 
         XCTAssertNotNil(actual)
         XCTAssertEqual(actual!.count, 2)