Super Methoden Unterklasse Typ in schnellen

Question

Ich habe diesen Code zurück:

class Dark: NSObject { 
    class var className: String { 
    return NSStringFromClass(self)!.componentsSeparatedByString(".").last! 
    } 

    var success = 0 

    class func devour<T: Dark>(params: Int) -> T { 
    var s = T() 
    return assign(s, params: params) 
    } 

    class func assign<T: Dark>(item: T, params: Int) -> T{ 
    if item.dynamicType === self { 
     item.success = params 
    } 
    return item 
    } 
} 

class Black: Dark { 
} 

class Violet: Dark { 
} 

Black.className // returns "Black" 
Violet.className // returns "Violet" 

Das Problem tritt auf, wenn ich dies tun:

var ret = Black.devour(5) 
ret.success //returns 0 which I expect to be 5 

ret.self // returns {Dark success 0} which I expect to be {Black success 0} 

Das hier Problem ist, dass, wenn die Unterklasse verwendet die geerbte Methode verschlingen, gibt es ein Objekt vom Typ Dark zurück. Ich möchte in der Lage sein, beim Aufruf von devour den Unterklasse-Typ und nicht den Oberklasse-Typ zurückzugeben. Beispiel, wenn ich tun:

var ret = Black.devour(5) 

Die Klasse der ret der Klasse sein sollte Black und nicht der Klasse Dark.

Ich hoffe, dass mir jemand dabei helfen kann. Ich habe wirklich keine Ideen. Vielen Dank! Ich möchte die Verkettung vermeiden und halte es für den letzten Ausweg.

Answer 1

Es stellt sich heraus, dass ich in der Lage war, eine Arbeit zu erledigen; Danke an die Antwort auf diese Frage: Cast to typeof(self).

Alles, was ich tun muss, ist eine Methode erstellen, die ein Objekt vom Typ Self zurückgibt.

Zuerst erstellte ich eine Klasse, die eine Instanz der Basisklasse erstellt und sie als Instanz von AnyObject zurückgibt.

class func createDark() -> AnyObject { 
      var black = Black() 
      return black 
    } 

Wenn ich eine Instanz von Black zurückkehren es wirft sie automatisch in ANYOBJECT, da es die angegebene Rückgabetyp der Methode war (ich ehrlich dachte, dies nur aus, und dies hat mich gerettet).

Dann habe ich eine Hilfsmethode, die createDark() und weist Eigenschaften/Attribute der Instanz ruft:

class func prepare<T: Dark>(params: Int) -> T{ 
     var dark = createDark() as T 
     dark.assign(params) 
     return dark 
    } 

I generische Typ verwendet, die als Rückgabetyp von Dark Art oder seiner Unterklasse ist.

Dann ist dieses ich tat:

class func devour(params: Int) -> Self { 
     return prepare(params) 
    } 

von Self als Rückgabetyp Angabe Es wirft automatisch von selbst zu geben, die von Dark Typ oder jede Klasse sein kann, die es erbt.

sieht Mein letzter Code wie folgt:

class Dark: NSObject { 
    var success = 0 

    func assign(params: Int) { 
     if self.dynamicType === self { // I dont really have to do this anymore 
      self.success = params 
     } 
    } 

    class var className: String { 
     return NSStringFromClass(self)!.componentsSeparatedByString(".").last! 
    } 

    class func createDark() -> AnyObject { 
     var black = Black() 
     return black 
    } 

    class func prepare<T: Dark>(params: Int) -> T { 
     var dark = createDark() as T 
     dark.assign(params) 
     return dark 
    } 

    class func devour(params: Int) -> Self { 
     return prepare(params) 
    } 


} 

zu überprüfen, ob es das Problem gelöst:

var ret = Black.devour(5) 
ret.success //now returns 5 as expected 

ret.self // now returns {Black success 0} as expected 

funktioniert wie erwartet!