Introspecção e genéricos de classe rápida

Estou tentando criar dinamicamente um classtipo baseado em instância usando genéricos, mas estou tendo dificuldades com a introspecção de classe.

Aqui estão as perguntas:

• Existe um equivalente Swift aos Obj-C self.class?
• Existe uma maneira de instanciar uma classe usando o AnyClassresultado NSClassFromString?
• Existe uma maneira de obter AnyClassou digitar informações estritamente de um parâmetro genérico T? (Semelhante à typeof(T)sintaxe do C # )

Bem, por um lado, o equivalente Swift de [NSString class]é .self(consulte os documentos do Metatype , embora eles sejam muito finos).

De fato, NSString.classnem funciona! Você tem que usar NSString.self.

let s = NSString.self
var str = s()
str = "asdf"

Da mesma forma, com uma classe rápida, tentei ...

class MyClass {

}

let MyClassRef = MyClass.self

// ERROR :(
let my_obj = MyClassRef()

Hmm… o erro diz:

Falha na execução do playground: erro:: 16: 1: erro: a construção de um objeto do tipo de classe 'X' com um valor de metatipo requer um inicializador '@required'

 Y().me()
 ^
 <REPL>:3:7: note: selected implicit initializer with type '()'
 class X {
       ^

Levei um tempo para entender o que isso significa ... Acontece que ele quer que a classe tenha um @required init()

class X {
    func me() {
        println("asdf")
    }

    required init () {

    }
}

let Y = X.self

// prints "asdf"
Y().me()

Alguns dos documentos se referem a isso como .Type, mas MyClass.Typeme dão um erro no playground.

Aqui está como usar NSClassFromString. Você precisa conhecer a superclasse do que vai acabar. Aqui estão um par de superclasse-subclasse que sabe como se descrever para println:

@objc(Zilk) class Zilk : NSObject {
    override var description : String {return "I am a Zilk"}
}

@objc(Zork) class Zork : Zilk {
    override var description : String {return "I am a Zork"}
}

Observe o uso da @objsintaxe especial para ditar o nome munged Objective-C dessas classes; isso é crucial, porque, caso contrário, não conhecemos a string munged que designa cada classe.

Agora podemos usar NSClassFromStringpara criar a classe Zork ou Zilk, porque sabemos que podemos digitá-lo como um NSObject e não travar mais tarde:

let aClass = NSClassFromString("Zork") as NSObject.Type
let anObject = aClass()
println(anObject) // "I am a Zork"

E é reversível; println(NSStringFromClass(anObject.dynamicType))também funciona.

Versão moderna:

    if let aClass = NSClassFromString("Zork") as? NSObject.Type {
        let anObject = aClass.init()
        print(anObject) // "I am a Zork"
        print(NSStringFromClass(type(of:anObject))) // Zork
    }

Se estou lendo a documentação corretamente, se você lida com instâncias e, por exemplo, deseja retornar uma nova instância do mesmo tipo que o objeto que você recebeu e o tipo pode ser construído com um init (), você pode:

let typeOfObject = aGivenObject.dynamicType
var freshInstance = typeOfObject()

Eu rapidamente testei com String:

let someType = "Fooo".dynamicType
let emptyString = someType()
let threeString = someType("Three")

que funcionou bem.

Em rápido 3

object.dynamicType

está obsoleto.

Em vez disso, use:

type(of:object)

Implementação rápida de tipos de comparação

protocol Decoratable{}
class A:Decoratable{}
class B:Decoratable{}
let object:AnyObject = A()
object.dynamicType is A.Type//true
object.dynamicType is B.Type//false
object.dynamicType is Decoratable.Type//true

NOTA: Observe que ele também funciona com protocolos em que o objeto pode ou não estender

Finalmente tenho algo para trabalhar. É um pouco preguiçoso, mas mesmo a rota NSClassFromString () não funcionou para mim ...

import Foundation

var classMap = Dictionary<String, AnyObject>()

func mapClass(name: String, constructor: AnyObject) -> ()
{
    classMap[name] = constructor;
}

class Factory
{
    class func create(className: String) -> AnyObject?
    {
        var something : AnyObject?

        var template : FactoryObject? = classMap[className] as? FactoryObject

        if (template)
        {
            let somethingElse : FactoryObject = template!.dynamicType()

            return somethingElse
        }

        return nil
    }
}


 import ObjectiveC

 class FactoryObject : NSObject
{
    @required init() {}
//...
}

class Foo : FactoryObject
{
    class override func initialize()
    {
        mapClass("LocalData", LocalData())
    }
    init () { super.init() }
}

var makeFoo : AnyObject? = Factory.create("Foo")

e o bingo, "makeFoo" contém uma instância do Foo.

A desvantagem é que suas classes devem derivar do FactoryObject e DEVEM ter o método de inicialização do Obj-C + para que sua classe seja inserida automaticamente no mapa da classe pela função global "mapClass".

Aqui está outro exemplo que mostra a implementação da hierarquia de classes, semelhante à resposta aceita, atualizada para a primeira versão do Swift.

class NamedItem : NSObject {
    func display() {
        println("display")
    }

    required override init() {
        super.init()
        println("base")
    }
}

class File : NamedItem {
    required init() {
        super.init()
        println("folder")
    }
}

class Folder : NamedItem {
    required init() {
        super.init()
        println("file")
    }
}

let y = Folder.self
y().display()
let z = File.self
z().display()

Imprime este resultado:

base
file
display
base
folder
display