API Break: Use Data type from Foundation for binary data

This changes the current API and will break existing clients.
The protobuf binary serialization methods have changed to use Data:
    ProtobufMessage.init(protobuf:) now takes Data instead of [UInt8]
    ProtobufMessage.serializeProtobuf() now returns Data instead of [UInt8]

The [UInt8] support is still available under a different name:
    ProtobufMessage.init(protobufBytes: [UInt8])
    ProtobufMessage.serializeProtobufBytes() throws -> [UInt8]

Similarly, proto `bytes` fields that were previously rendered
as [UInt8] properties in Swift are now rendered to Data properties.

This change was made to better align Swift Protobuf conventions
with Swift 3 Foundation.

Author: tbkka

CollectTests.awk

@@ -32,7 +32,7 @@ BEGIN {
     TESTCASES=""
     TESTCASE_separator=""
     printf("import XCTest\n")
-    printf("@testable import ProtobufTestSuite\n")
+    printf("@testable import ProtobufTests\n")
     printf("\n")
     printf("private func run_test(test:() -> ()) throws {\n")
     printf("    test()\n")

Sources/Protobuf/Google_Protobuf_Any.swift

@@ -17,6 +17,7 @@
 ///
 // -----------------------------------------------------------------------------
 
+import Foundation
 import Swift
 
 fileprivate func typeName(fromURL s: String) -> String {
@@ -140,13 +141,13 @@ public struct Google_Protobuf_Any: ProtobufAbstractMessage, Hashable, Equatable,
     public var typeURL: String?
 
     ///   Must be valid serialized data of the above specified type.
-    public var value: [UInt8]? {
+    public var value: Data? {
         get {
             if let value = _value {
                 return value
             } else if let message = _message {
                 do {
-                    return try message.serializeProtobufBytes()
+                    return try message.serializeProtobuf()
                 } catch {
                     return nil
                 }
@@ -157,7 +158,7 @@ public struct Google_Protobuf_Any: ProtobufAbstractMessage, Hashable, Equatable,
                 if let messageType = Google_Protobuf_Any.wellKnownTypes[encodedTypeName] {
                     do {
                         let m = try messageType.init(any: self)
-                        return try m.serializeProtobufBytes()
+                        return try m.serializeProtobuf()
                     } catch {
                         return nil
                     }
@@ -166,15 +167,15 @@ public struct Google_Protobuf_Any: ProtobufAbstractMessage, Hashable, Equatable,
                 if let messageType = Google_Protobuf_Any.knownTypes[encodedTypeName] {
                     do {
                         let m = try messageType.init(any: self)
-                        return try m.serializeProtobufBytes()
+                        return try m.serializeProtobuf()
                     } catch {
                         return nil
                     }
                 }
                 // TODO: Google spec requires a lot more work in the general case:
                 // let encodedType = ... fetch google.protobuf.Type based on typeURL ...
                 // let type = Google_Protobuf_Type(protobuf: encodedType)
-                // return ProtobufDynamic(type: type, any: self)?.serializeProtobufBytes()
+                // return ProtobufDynamic(type: type, any: self)?.serializeProtobuf()
 
                 // See the comments in serializeJSON() above for more discussion of what would be needed to fully implement this.
                 return nil
@@ -188,7 +189,7 @@ public struct Google_Protobuf_Any: ProtobufAbstractMessage, Hashable, Equatable,
             _jsonFields = nil
         }
     }
-    private var _value: [UInt8]?
+    private var _value: Data?
 
     private var _message: ProtobufMessage?
     private var _jsonFields: [String:[ProtobufJSONToken]]?
@@ -218,7 +219,7 @@ public struct Google_Protobuf_Any: ProtobufAbstractMessage, Hashable, Equatable,
         let messageTypeName = typeName(fromMessage: m)
         knownTypes[messageTypeName] = messageType
     }
-    
+
     public init() {}
 
     public init(message: ProtobufMessage) {
@@ -233,7 +234,7 @@ public struct Google_Protobuf_Any: ProtobufAbstractMessage, Hashable, Equatable,
         default: return false
         }
     }
-    
+
     public mutating func decodeFromJSONObject(jsonDecoder: inout ProtobufJSONDecoder) throws {
         var key = ""
         var state = ProtobufJSONDecoder.ObjectParseState.expectFirstKey
@@ -292,15 +293,16 @@ public struct Google_Protobuf_Any: ProtobufAbstractMessage, Hashable, Equatable,
         if encodedType != messageType {
             throw ProtobufDecodingError.malformedAnyField
         }
-        var protobuf: [UInt8]?
+        var protobuf: Data?
         if let message = _message {
-            protobuf = try message.serializeProtobufBytes()
+            protobuf = try message.serializeProtobuf()
         } else if let value = _value {
             protobuf = value
         }
         if let protobuf = protobuf {
             // Decode protobuf from the stored bytes
-            try protobuf.withUnsafeBufferPointer { (bp) in
+            try protobuf.withUnsafeBytes { (p: UnsafePointer<UInt8>) in
+                let bp = UnsafeBufferPointer(start: p, count: protobuf.count)
                 var protobufDecoder = ProtobufBinaryDecoder(protobufPointer: bp)
                 try protobufDecoder.decodeFullObject(message: &target)
             }
@@ -368,7 +370,7 @@ public struct Google_Protobuf_Any: ProtobufAbstractMessage, Hashable, Equatable,
                 hash = (hash &* 16777619) ^ t.hashValue
             }
             if let v = _value {
-                hash = (hash &* 16777619) ^ ProtobufHash(bytes: v)
+                hash = (hash &* 16777619) ^ v.hashValue
             }
             if let m = _message {
                 hash = (hash &* 16777619) ^ m.hashValue

Sources/Protobuf/ProtobufBinaryTypes.swift

@@ -613,21 +613,18 @@ public extension ProtobufString {
 ///
 public extension ProtobufBytes {
     public static func protobufWireType() -> Int { return 2 }
-    public static func serializeProtobufValue(encoder: inout ProtobufBinaryEncoder, value: [UInt8]) {
-        encoder.putBytesValue(value: value)
-    }
 
     public static func serializeProtobufValue(encoder: inout ProtobufBinaryEncoder, value: Data) {
         encoder.putBytesValue(value: [UInt8](value))
     }
 
-    public static func setFromProtobufBuffer(buffer: UnsafeBufferPointer<UInt8>, value: inout [UInt8]?) throws -> Bool {
-        value = [UInt8](buffer)
+    public static func setFromProtobufBuffer(buffer: UnsafeBufferPointer<UInt8>, value: inout Data?) throws -> Bool {
+        value = Data(bytes: [UInt8](buffer))
         return true
     }
 
-    public static func setFromProtobufBuffer(buffer: UnsafeBufferPointer<UInt8>, value: inout [[UInt8]]) throws -> Bool {
-        value.append([UInt8](buffer))
+    public static func setFromProtobufBuffer(buffer: UnsafeBufferPointer<UInt8>, value: inout [Data]) throws -> Bool {
+        value.append(Data(bytes: [UInt8](buffer)))
         return true
     }
 }

Sources/Protobuf/ProtobufDebugDescription.swift

@@ -59,7 +59,7 @@ public struct ProtobufDebugDescriptionVisitor: ProtobufVisitor {
         separator = ","
         description.append(swiftFieldName + ":" + String(reflecting: value))
     }
-    
+
     mutating public func visitRepeatedField<S: ProtobufTypeProperties>(fieldType: S.Type, value: [S.BaseType], protoFieldNumber: Int, protoFieldName: String, jsonFieldName: String, swiftFieldName: String) throws {
         description.append(separator)
         description.append(swiftFieldName)

Sources/Protobuf/ProtobufJSONDecoding.swift

@@ -26,6 +26,7 @@
 ///
 // -----------------------------------------------------------------------------
 
+import Foundation
 import Swift
 
 private func fromHexDigit(_ c: Character?) -> UInt32? {
@@ -858,7 +859,7 @@ private func normalizeIntString(_ s: String) -> [Character]? {
     return number
 }
 
-private func decodeBytes(_ s: String) -> [UInt8]? {
+private func decodeBytes(_ s: String) -> Data? {
     var out = [UInt8]()
     let digits = s.utf8
     var n = 0
@@ -889,7 +890,7 @@ private func decodeBytes(_ s: String) -> [UInt8]? {
     if bits != 0 {
         return nil
     }
-    return out
+    return Data(bytes: out)
 }
 
 
@@ -1000,7 +1001,7 @@ public enum ProtobufJSONToken: Equatable, ProtobufFieldDecoder {
         }
     }
 
-    var asBytes: [UInt8]? {
+    var asBytes: Data? {
         switch self {
         case .string(let s): return decodeBytes(s)
         default: return nil

Sources/Protobuf/ProtobufJSONEncoding.swift

@@ -14,6 +14,7 @@
 ///
 // -----------------------------------------------------------------------------
 
+import Foundation
 import Swift
 
 public struct ProtobufJSONEncodingVisitor: ProtobufVisitor {
@@ -248,7 +249,7 @@ public struct ProtobufJSONEncoder {
         }
         append(text: "\"")
     }
-    mutating func putBytesValue(value: [UInt8]) {
+    mutating func putBytesValue(value: Data) {
         var out: String = ""
         if value.count > 0 {
             let digits: [Character] = ["A", "B", "C", "D", "E", "F",

Sources/Protobuf/ProtobufJSONTypes.swift

@@ -15,6 +15,7 @@
 ///
 // -----------------------------------------------------------------------------
 
+import Foundation
 import Swift
 
 public protocol ProtobufJSONCodableType: ProtobufTypePropertiesBase {
@@ -680,11 +681,11 @@ public extension ProtobufBytes {
         }
     }
 
-    public static func serializeJSONValue(encoder: inout ProtobufJSONEncoder, value: [UInt8]) {
+    public static func serializeJSONValue(encoder: inout ProtobufJSONEncoder, value: Data) {
         encoder.putBytesValue(value: value)
     }
 
-    public static func decodeJSONMapFieldValue(jsonDecoder: inout ProtobufJSONDecoder) throws -> [UInt8]? {
+    public static func decodeJSONMapFieldValue(jsonDecoder: inout ProtobufJSONDecoder) throws -> Data? {
         if let token = try jsonDecoder.nextToken() {
             switch token {
             case .string(_):

Sources/Protobuf/ProtobufTypes.swift

@@ -17,6 +17,7 @@
 ///
 // -----------------------------------------------------------------------------
 
+import Foundation
 import Swift
 
 ///
@@ -32,18 +33,21 @@ import Swift
 /// various coding/decoding functions to provide type-specific
 /// information.
 ///
+/// The types defined here are extended in ProtobufBinaryTypes.swift
+/// with serialization support for binary protobuf encoding, and in
+/// ProtobufJSONTypes.swift with serialization support for JSON encoding.
+///
 public protocol ProtobufTypePropertiesBase {
     // Default here is appropriate for enums and messages
     // Other types will override this
     associatedtype BaseType = Self
 
     /// Hash the provided value
-    /// In particular, [UInt8] is not Hashable, so we can't just
-    /// use .hashValue everywhere.
+    /// TODO: Can we just replace this with .hashValue everywhere?
     static func hash(value: BaseType) -> Int
 
-    /// In Swift 3, [UInt8] isn't Equatable, so I've added this method
-    /// to provide a consistent way to compute equality.
+    /// Test if two values are equal
+    /// TODO: Can we just replace this with == everywhere?
     static func isEqual(_ lhs: BaseType, _ rhs: BaseType) -> Bool
 }
 
@@ -77,23 +81,20 @@ public protocol ProtobufMapValueType: ProtobufTypeProperties {
 ///
 public struct ProtobufFloat: ProtobufTypeProperties, ProtobufMapValueType {
     public typealias BaseType = Float
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 ///
 /// Double
 ///
 public struct ProtobufDouble: ProtobufTypeProperties, ProtobufMapValueType {
     public typealias BaseType = Double
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 ///
 /// Int32
 ///
 public struct ProtobufInt32: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = Int32
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 ///
@@ -102,15 +103,13 @@ public struct ProtobufInt32: ProtobufTypeProperties, ProtobufMapKeyType, Protobu
 
 public struct ProtobufInt64: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = Int64
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 ///
 /// UInt32
 ///
 public struct ProtobufUInt32: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = UInt32
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 ///
@@ -119,15 +118,13 @@ public struct ProtobufUInt32: ProtobufTypeProperties, ProtobufMapKeyType, Protob
 
 public struct ProtobufUInt64: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = UInt64
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 ///
 /// SInt32
 ///
 public struct ProtobufSInt32: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = Int32
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 ///
@@ -136,76 +133,61 @@ public struct ProtobufSInt32: ProtobufTypeProperties, ProtobufMapKeyType, Protob
 
 public struct ProtobufSInt64: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = Int64
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 ///
 /// Fixed32
 ///
 public struct ProtobufFixed32: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = UInt32
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 ///
 /// Fixed64
 ///
 public struct ProtobufFixed64: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = UInt64
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 ///
 /// SFixed32
 ///
 public struct ProtobufSFixed32: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = Int32
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 ///
 /// SFixed64
 ///
 public struct ProtobufSFixed64: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = Int64
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 //
 // ========= Bool =========
 //
 public struct ProtobufBool: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = Bool
-    public static func describe(value: BaseType) -> String {return value.description}
 }
 
 //
 // ========== String ==========
 //
 public struct ProtobufString: ProtobufTypeProperties, ProtobufMapKeyType, ProtobufMapValueType {
     public typealias BaseType = String
-    public static func describe(value: BaseType) -> String {return value.debugDescription}
 }
 
 //
 // ========== Bytes ==========
 //
 public struct ProtobufBytes: ProtobufTypeProperties, ProtobufMapValueType {
-    public typealias BaseType = [UInt8]
-
-    public static func hash(value: BaseType) -> Int {return ProtobufHash(bytes: value)}
-    public static func describe(value: BaseType) -> String {return value.debugDescription}
-
-    // Note:  [UInt8] isn't Equatable, so we can't rely on the default implementation above
-    // But there is an == overload, so this same definition works here.
-    public static func isEqual(_ lhs: BaseType, _ rhs: BaseType) -> Bool {return lhs == rhs}
+    public typealias BaseType = Data
 }
 
 //
 // ========== Enum ==========
 //
 extension ProtobufEnum where RawValue == Int {
-    public static func describe(value: Self) -> String {return String(reflecting: value)}
 }
 
 //