metody nadklasy wrócić typu podklasy w Swift

Question

mam ten kod:

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" 

Problem pojawia się, kiedy to zrobić:

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} 

Problem polega na tym, że gdy podklasa wykorzystuje metodę dziedziczoną devour, zwraca obiekt typu Dark. Chcę móc zwrócić typ podklasy, a nie typ nadklasy podczas wywoływania pożera. Przykład kiedy zrobić:

var ret = Black.devour(5) 

Klasa ret powinny być klasy Black i nie stanowi klasę Dark.

Mam nadzieję, że ktoś może mi w tym pomóc. Naprawdę nie mam pomysłów. Dzięki! Chcę uniknąć łańcuchów i uważam to za ostateczność.

Answer 1

Okazuje się, że udało mi się wykonać pracę; Dzięki odpowiedzi na to pytanie: Cast to typeof(self).

Wszystko, co muszę zrobić, to stworzyć metodę, która zwraca obiekt typu Self.

Najpierw utworzyłem klasę, która tworzy instancję klasy bazowej i zwraca ją jako wystąpienie AnyObject.

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

Kiedy wrócę wystąpienie Black automatycznie rzuca go na AnyObject ponieważ był określony typ powrót metody (I szczerze prostu zdobione to i to uratowało mnie).

Następnie utworzony sposób pomocniczy, który wywołuje createDark() i przypisuje właściwości/atrybutów na przykład:

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

kiedyś typu rodzajowego co ma Dark typu lub jego podklasy jako typ powrotnego.

Potem zrobiłem to:

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

określając Self jako typ zwracany automatycznie rzuca go wpisywać z siebie, który może być z Dark typu lub dowolnej klasy, która dziedziczy ją.

Moja ostatnia kod wygląda następująco:

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) 
    } 


} 

aby sprawdzić, czy to rozwiązało problem:

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

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

działa zgodnie z oczekiwaniami!