在 Swift 中将数据读入结构

Question

我正在尝试使用withUnsafeBytes 方法将裸Data 读入Swift 4 struct。问题

网络UDP数据包格式如下：

data: 0102 0A00 0000 0B00 0000

01           : 1 byte : majorVersion      (decimal 01)
02           : 1 byte : minorVersion      (decimal 02)
0A00 0000    : 4 bytes: applicationHostId (decimal 10)
0B00 0000    : 4 bytes: versionNumber     (decimal 11)

然后我在Data 上有一个扩展，它需要start 和length 字节来读取

extension Data {
    func scanValue<T>(start: Int, length: Int) -> T {
        return self.subdata(in: start..<start+length).withUnsafeBytes { $0.pointee }
    }
}

这在逐个读取值时可以正常工作：

// correctly read as decimal "1"
let majorVersion: UInt8 = data.scanValue(start: 0, length: 1)

// correctly read as decimal "2"
let minorVersion: UInt8 = data.scanValue(start: 1, length: 1)

// correctly read as decimal "10"
let applicationHostId: UInt32 = data.scanValue(start: 2, length: 4)

// correctly read as decimal "11"
let versionNumber: UInt32 = data.scanValue(start: 6, length: 4)

然后我创建了一个struct，代表整个数据包如下

struct XPLBeacon {
    var majorVersion: UInt8        // 1 Byte
    var minorVersion: UInt8        // 1 Byte
    var applicationHostId: UInt32  // 4 Bytes
    var versionNumber: UInt32      // 4 Bytes
}

但是当我将数据直接读入结构时，我遇到了一些问题：

var beacon: XPLBeacon = data.scanValue(start: 0, length: data.count)

// correctly read as decimal "1"
beacon.majorVersion

// correctly read as decimal "2"
beacon.minorVersion

// not correctly read
beacon.applicationHostId

// not correctly read
beacon.versionNumber

我应该像这样解析整个结构吗？

Answer 1

从数据中读取整个结构不起作用，因为 结构成员填充到它们的自然边界。这 struct XPLBeacon的内存布局是

A B x x C C C C D D D D

在哪里

偏移成员 0 A - 主要版本 (UInt8) 1 B - 次要版本 (UInt8) 2 x x - 填充 4 C C C C - applicationHostId (UInt32) 8 D D D D - 版本号 (UInt32)

并插入填充以便UInt32 成员 对齐的内存地址是其大小的倍数。这是 也证实了

print(MemoryLayout<XPLBeacon>.size) // 12

（有关 Swift 中对齐的更多信息，请参阅 Type Layout)。

如果您将整个数据读入结构，则分配字节 如下

01 02 0A 00 00 00 0B 00 00 00 A B x x C C C C D D D D

这解释了为什么major/minorVersion 是正确的，但applicationHostId 和versionNumber 错了。将所有成员与数据分开读取是正确的解决方案。

Answer 2

由于 Swift 3 数据符合RandomAccessCollection、MutableCollection、RangeReplaceableCollection。因此，您可以简单地创建一个自定义初始化程序来初始化您的结构属性，如下所示：

struct XPLBeacon {
    let majorVersion, minorVersion: UInt8             // 1 + 1 = 2 Bytes
    let applicationHostId, versionNumber: UInt32      // 4 + 4 = 8 Bytes
    init(data: Data) {
        self.majorVersion = data[0]
        self.minorVersion = data[1]
        self.applicationHostId = data
            .subdata(in: 2..<6)
            .withUnsafeBytes { $0.load(as: UInt32.self) }
        self.versionNumber = data
            .subdata(in: 6..<10)
            .withUnsafeBytes { $0.load(as: UInt32.self) }
    }
}

---

var data = Data([0x01,0x02, 0x0A, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00,0x00])
print(data as NSData)     // "{length = 10, bytes = 0x01020a0000000b000000}\n" <01020a00 00000b00 0000>

let beacon = XPLBeacon(data: data)
beacon.majorVersion       // 1
beacon.minorVersion       // 2
beacon.applicationHostId  // 10
beacon.versionNumber      // 11

Answer 3

根据 Leo Dabus 的回答，我创建了一个更易读的构造函数：

extension Data {
    func object<T>(at index: Index) -> T {
        subdata(in: index ..< index.advanced(by: MemoryLayout<T>.size))
            .withUnsafeBytes { $0.load(as: T.self) }
    }
}

---

struct XPLBeacon {
    var majorVersion: UInt8
    var minorVersion: UInt8
    var applicationHostId: UInt32
    var versionNumber: UInt32

    init(data: Data) {
        var index = data.startIndex
        majorVersion = data.object(at: index)

        index += MemoryLayout.size(ofValue: majorVersion)
        minorVersion = data.object(at: index)

        index += MemoryLayout.size(ofValue: minorVersion)
        applicationHostId = data.object(at: index)

        index += MemoryLayout.size(ofValue: applicationHostId)
        versionNumber = data.object(at: index)
    }
}

不属于这部分的当然是检查数据的正确性。正如 cmets 中提到的其他内容，这可以通过具有可失败的 init 方法或通过引发错误来完成。