Creare una matrice in Swift da un oggetto NSData

Question

Sto cercando di memorizzare una serie di numeri interi su disco in modo rapido. Posso inserirli in un oggetto NSData da archiviare, ma è difficile rimetterli in una matrice. Posso ottenere un COpaquePointer grezzo con i dati con data.bytes ma non riesco a trovare un modo per inizializzare un nuovo array rapido con quel puntatore. Qualcuno sa come farlo?

import Foundation 

var arr : UInt32[] = [32,4,123,4,5,2]; 

let data = NSData(bytes: arr, length: arr.count * sizeof(UInt32)) 

println(data) //data looks good in the inspector 

// now get it back into an array? 

Answer 1

È possibile utilizzare il metodo getBytes di NSData:

// the number of elements: 
let count = data.length/sizeof(UInt32) 

// create array of appropriate length: 
var array = [UInt32](count: count, repeatedValue: 0) 

// copy bytes into array 
data.getBytes(&array, length:count * sizeof(UInt32)) 

print(array) 
// Output: [32, 4, 123, 4, 5, 2] 

---

Aggiornamento per Swift 3 (Xcode 8): Swift 3 ha un nuovo tipo struct Data che è un wrapper per NS(Mutable)Data con semantica del valore appropriato. I metodi di accesso sono leggermente diversi.

Array di dati:

var arr: [UInt32] = [32, 4, UInt32.max] 
let data = Data(buffer: UnsafeBufferPointer(start: &arr, count: arr.count)) 
print(data) // <20000000 04000000 ffffffff> 

dati di Array:

let arr2 = data.withUnsafeBytes { 
    Array(UnsafeBufferPointer<UInt32>(start: $0, count: data.count/MemoryLayout<UInt32>.stride)) 
} 
print(arr2) // [32, 4, 4294967295] 

Answer 2

È anche possibile farlo utilizzando un UnsafeBufferPointer, che è essenzialmente un "puntatore", come implementa il protocollo Sequence:

let data = NSData(/* ... */) 

// Have to cast the pointer to the right size 
let pointer = UnsafePointer<UInt32>(data.bytes) 
let count = data.length/4 

// Get our buffer pointer and make an array out of it 
let buffer = UnsafeBufferPointer<UInt32>(start:pointer, count:count) 
let array = [UInt32](buffer) 

Ciò elimina la necessità di inizializzare un array vuoto con elementi duplicati per primo, per poi sovrascriverlo, anche se non ho idea se sia più veloce. Poiché utilizza il protocollo Sequence, ciò implica l'iterazione anziché la copia veloce della memoria, anche se non so se è ottimizzata quando viene passato un puntatore del buffer. Inoltre, non sono sicuro di quanto sia veloce l'inizializzatore "creare un array vuoto con X identici".

Answer 3

Ecco un modo generico per farlo.

import Foundation 

extension Data { 
    func elements <T>() -> [T] { 
     return withUnsafeBytes { 
      Array(UnsafeBufferPointer<T>(start: $0, count: count/MemoryLayout<T>.size)) 
     } 
    } 
} 

let array = [1, 2, 3] 
let data = Data(buffer: UnsafeBufferPointer(start: array, count: array.count)) 
let array2: [Int] = data.elements() 

array == array2 
// IN THE PLAYGROUND, THIS SHOWS AS TRUE 

È necessario specificare il tipo nella linea array2. Altrimenti, il compilatore non può indovinare.

Answer 4

Se avete a che fare con i dati per array (che so per certo il mio allineamento sarà [String]), sono abbastanza contento di questo:

NSKeyedUnarchiver.unarchiveObject (con: yourdata)

spero che aiuta