Swift 2-UnsafeMutablePointer<Void> al objeto

pointers swift2

Question

Si tengo un método como:

func someMethod(contextPtr: UnsafeMutablePointer<Void>)

¿Cómo obtengo el objeto del contextPtr ?

func someMethod(contextPtr: UnsafeMutablePointer<Void>){    
    let object:MyObject = contextPtr.memory
}

da:

''Void'' no es convertible a ''MyObject''

¿Cuál es la salsa secreta?

Mas detalle:

Lo que realmente estoy haciendo aquí es configurar una función de devolución de llamada global para SCNetworkReachability :

func callback(reachability:SCNetworkReachability, flags: SCNetworkReachabilityFlags, info: UnsafeMutablePointer<Void>) {

    let r:Reachability = info.memory
}

y luego agregando la devolución de llamada de la siguiente manera:

var context = SCNetworkReachabilityContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil)
var s = self
withUnsafeMutablePointer(&s) {
    context.info = UnsafeMutablePointer($0)
}
SCNetworkReachabilitySetCallback(reachability, callback, &context)

Answer 1

Esto debería funcionar: pase el puntero del objeto como un puntero opaco no administrado a la devolución de llamada:

context.info = UnsafeMutablePointer(Unmanaged.passUnretained(myObject).toOpaque())
SCNetworkReachabilitySetCallback(reachability, callback, &context) 

y recuperar en la devolución de llamada a través de:

func callback(reachability:SCNetworkReachability, flags: SCNetworkReachabilityFlags, info: UnsafeMutablePointer<Void>) {

    let myObject = Unmanaged<MyObject>.fromOpaque(COpaquePointer(info)).takeUnretainedValue()

}

Por supuesto, esto supone que existe una fuerte referencia al objeto siempre que la devolución de llamada esté instalada, de modo que el objeto no se desasigne.

Actualización: Tenga en cuenta que ambas conversiones del puntero de objeto a puntero vacío y viceversa pueden simplificarse si está dispuesto a usar funciones "inseguras":

context.info = unsafeAddressOf(myObject)
// ...
myObject = unsafeBitCast(info, MyObject.self)

El código de ensamblaje generado es, por lo que puedo ver, idéntico.

Actualización 2: Vea también Cómo lanzarse a sí mismo al tipo UnsafeMutablePointer <Void> en swift para obtener más información sobre el "puente" y algunas funciones auxiliares que se pueden usar aquí.

Actualización de Swift 3 (Xcode 8 beta 6):

var context = SCNetworkReachabilityContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil)
context.info = UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())

// ...

func callback(reachability:SCNetworkReachability, flags: SCNetworkReachabilityFlags, info: UnsafeMutableRawPointer?) {
    if let info = info {
        let myObject = Unmanaged<MyObject>.fromOpaque(info).takeUnretainedValue()
        // ...
    }
}

Answer 2

struct S {
    var i: Int = 10
}
var first = S()

func foo(contextPtr: UnsafeMutablePointer<Void>){
    let pS = UnsafeMutablePointer<S>(contextPtr)
    pS.memory.i = 100
}
print(first.i) // 10
foo(&first)
print(first.i) // 100

si necesitamos pasar como UnsafeMutablePointer self to async function

import XCPlayground
XCPlaygroundPage.currentPage.needsIndefiniteExecution = true

import Foundation
// can be struct, class ...
class C {
    let queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT)
    var s: String = ""
    func foo() {
        var c = self
        dispatch_async(queue) { () -> Void in
            f(&c)
        }

    }
}

func f(pV: UnsafeMutablePointer<Void>) {
    let pC = UnsafeMutablePointer<C>(pV)
    sleep(1)
    print(pC.memory.s)
}

var c1: C? = C()
c1!.s = "C1"
c1!.foo()        // C1
var c2: C? = C()
c2!.s = "C2"
c2!.foo()        // C2
c1 = nil
c2 = nil
print("test")