如何抽象不同的字节缓冲区类型？ （NSData，[UInt8]等）

Question

在Swift中有多种访问字节缓冲区的方法，最一般的方法可能是通过UnsafeBufferPointer<UInt8>而实际的存储可以在NSData ， [UInt8] ， ContiguousArray<UInt8> 。

如果我正在编写库代码，我希望它尽可能通用，并适应用户对字节缓冲区的选择，同时仍使使用起来尽可能方便。 我当前的代码如下所示：

import Foundation

func stringFromUTF8Bytes(bytes: UnsafeBufferPointer<UInt8>) throws -> String {
    if let s = String(bytes: bytes, encoding: NSUTF8StringEncoding) {
        return s
    } else {
        throw Error.StringEncodingFailure
    }
}

func stringFromUTF8Bytes(bytes: ContiguousArray<UInt8>) throws -> String {
    return try bytes.withUnsafeBufferPointer(stringFromUTF8Bytes)
}

func stringFromUTF8Bytes(bytes: [UInt8]) throws -> String {
    return try bytes.withUnsafeBufferPointer(stringFromUTF8Bytes)
}

func stringFromUTF8Bytes(data: NSData) throws -> String {
    return try data.withUnsafeBufferPointer(stringFromUTF8Bytes)
}

enum Error: ErrorType {
    case StringEncodingFailure
}

这是一个简单的解决方案，但是有点重复。 我想到了一个更通用的解决方案：

protocol BufferType {
    func withUnsafeBufferPointer<R>(@noescape body: (UnsafeBufferPointer<UInt8>) throws -> R) rethrows -> R
}

func stringFromUTF8BytesGeneric(bytes: BufferType) throws -> String {
    return try bytes.withUnsafeBufferPointer { ptr in
        if let s = String(bytes: ptr, encoding: NSUTF8StringEncoding) {
            return s
        } else {
            throw Error.StringEncodingFailure
        }
    }
}

现在，我可以轻松地为NSData实现此协议：

extension NSData: BufferType {
    func withUnsafeBufferPointer<R>(@noescape body: (UnsafeBufferPointer<UInt8>) throws -> R) rethrows -> R {
        let bytesBufferPointer = UnsafeBufferPointer<UInt8>(start: UnsafePointer<UInt8>(bytes), count: length)
        return try body(bytesBufferPointer)
    }
}

但是我找不到一种为通用类型（例如[UInt8]实现此协议的方法：

// error: constrained extension must be declared on the unspecialized generic type 'Array' with constraints specified by a 'where' clause
extension Array<UInt8>: BufferType { }

// error: same-type requirement makes generic parameter 'Element' non-generic
extension Array: BufferType where Element == UInt8 { }

我的问题：

• 有没有一种方法可以为[UInt8]实现BufferType协议，但不能为[NSWindowController]类的其他类型实现BufferType协议？

• 与第一点相反，允许任意数组实际上有意义吗？ 我不这么认为，但也许我缺少了什么？

• 对于我完全想念的我想做的事情（抽象不同的字节缓冲区类型）有更好的解决方案吗？

Answer 1

（好吧，我在输入此问题时确实找到了一个可行的解决方案……因此，为了不浪费精力，我将发表自己的答案。也许还有其他更好的解决方案。）

您可以创建“通用” BufferType协议，并且不限制协议的实现，而是约束协议的实际用法。 这类似于在标准库中使用SequenceType方式。

protocol BufferType {
    typealias Element
    func withUnsafeBufferPointer<R>(@noescape body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
}

extension NSData: BufferType {
    typealias Element = UInt8
    func withUnsafeBufferPointer<R>(@noescape body: (UnsafeBufferPointer<UInt8>) throws -> R) rethrows -> R {
        let bytesBufferPointer = UnsafeBufferPointer<UInt8>(start: UnsafePointer<UInt8>(bytes), count: length)
        return try body(bytesBufferPointer)
    }
}

extension UnsafeBufferPointer: BufferType {
    func withUnsafeBufferPointer<R>(@noescape body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R {
        return try body(self)
    }
}

extension Array: BufferType { }
extension ContiguousArray: BufferType { }

func stringFromUTF8BytesGeneric <BT: BufferType where BT.Element == UInt8> (bytes: BT) throws -> String {
    switch(bytes.withUnsafeBufferPointer { String(bytes: $0, encoding: NSUTF8StringEncoding) }) {
    case let .Some(str): return str
    case .None: throw Error.StringEncodingFailure
    }
}

它确实需要向使用ByteBuffer每个方法中添加通用约束，否则，它将完全按我的方式工作：

// both print "ABC"
print(try stringFromUTF8BytesGeneric([65, 66, 67]))
print(try stringFromUTF8BytesGeneric(ContiguousArray<UInt8>([65, 66, 67])))