stringa convertire Swift per UnsafeMutablePointer <Int8>

Question

Ho una funzione C mappata Swift definito come:

func swe_set_eph_path(path: UnsafeMutablePointer<Int8>) -> Void 

Sto cercando di passare un percorso alla funzione e hanno provato:

 var path = [Int8](count: 1024, repeatedValue: 0); 
     for i in 0...NSBundle.mainBundle().bundlePath.lengthOfBytesUsingEncoding(NSUTF16StringEncoding)-1 
     { 
      var range = i..<i+1 
      path[i] = String.toInt(NSBundle.mainBundle().bundlePath[range]) 
     } 
     println("\(path)") 
     swe_set_ephe_path(&path) 

ma la linea del percorso [i] ottengo l'errore:

'subscript' is unavailable: cannot subscript String with a range of Int

swe_set_ephe_path(NSBundle.mainBundle().bundlePath) 

né

swe_set_ephe_path(&NSBundle.mainBundle().bundlePath) 

non funzionano né

Oltre a non lavorare, mi sento ci deve essere un modo migliore, meno contorto di fare questo. Le risposte precedenti su StackOverflow con CString non sembrano più funzionare. Eventuali suggerimenti?

Answer 1

Previous answers on StackOverflow using CString don't seem to work anymore

Tuttavia, UnsafePointer<Int8> è una stringa C. Se il contesto richiede assolutamente un UnsafeMutablePointer, proprio costringere, in questo modo:

let s = NSBundle.mainBundle().bundlePath 
let cs = (s as NSString).UTF8String 
var buffer = UnsafeMutablePointer<Int8>(cs) 
swe_set_ephe_path(buffer) 

Certo che non ho il tuo swe_set_ephe_path, ma funziona bene nel mio test, quando si spense in questo modo:

Answer 2

In realtà è estremamente irritante per la libreria che si sta utilizzando che richiede (nella dichiarazione C) uno char * path anziché const char * path. (questo presuppone che la funzione non muti la stringa di input - se lo fa, ci si trova in una situazione completamente diversa).

Se non lo fa, la funzione sarebbe venire a Swift come:

// note, UnsafePointer not UnsafeMutablePointer 
func swe_set_eph_path(path: UnsafePointer<Int8>) -> Void 

e si potrebbe quindi fare affidamento sulla conversione implicita di Swift:

let str = "blah" 
swe_set_eph_path(str) // Swift implicitly converts Strings 
         // to const C strings when calling C funcs 

ma si può fare una conversione non sicuro abbastanza facilmente, in combinazione con la funzione withCString:

str.withCString { cstr in 
    swe_set_eph_path(UnsafeMutablePointer(cstr)) 
} 

Answer 3

ho avuto una libreria statica (someLibrary.a) scritta in C++ compilata per iOS. Il file di intestazione (someLibrary.h) ha avuto una funzione esposta come questo:

extern long someFunction(char* aString);

La dichiarazione di Swift si presenta così:

Int someFunction(aString: UnsafeMutablePointer<Int8>)

ho fatto una proroga per String:

extension String { 
    var UTF8CString: UnsafeMutablePointer<Int8> { 
     return UnsafeMutablePointer((self as NSString).UTF8String) 
    } 
} 

Quindi posso chiamare la metanfetamina od in questo modo:

someFunction(mySwiftString.UTF8CString)