Swift Delegate-Protokoll für generische Klasse

Question

Ich habe eine Klasse, StateMachine, die generisch ist, um verschiedene Sätze von Zuständen wie zum Beispiel eine enum zu implementieren. Ich möchte ein StateMachineDelegate Protokoll verwenden, um einen Delegaten zu benachrichtigen, wenn der Zustandsautomat einen neuen Status eingibt.

Dies funktioniert jedoch nicht, da das Delegate-Protokoll auch generisch mit Typanforderungen ist. Der Fehler zeigt an, wo die delegate-Eigenschaft deklariert ist.

protocol StateType: Hashable {} 

protocol StateMachineDelegate: class { 
    typealias S: StateType 
    func stateMachine(stateMachine: StateMachine<S>, didEnterState newState: S) 
} 

class StateMachine<S: StateType> { 
    typealias State = S 

    weak var delegate: StateMachineDelegate? 
    //~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~ 
    //Protocol 'StateMachineDelegate' can only be used as a generic constraint because it has Self or associated type requirements 

    var currentState: State {...} 

    init(initialState: State) {...} 

    func applyState(toState: State) -> Bool { 
     ... 
     currentState = toState 
     delegate?.stateMachine(self, didEnterState: toState) 
     ... 
    } 
} 

Ich brauche irgendwie, dass StateMachineDelegate.S == S in der StateMachine Klasse assoziieren, aber ich bin nicht sicher, wie dies zu tun, oder wenn es möglich ist. Ich habe versucht:

class StateMachine<S: StateType, D: StateMachineDelegate where D.S == S> { 
    ... 
    weak var delegate: D? 
    ... 
} 

aber dann stecken ich versucht, das Protokoll zu überarbeiten, um richtig die allgemeine Art der StateMachine zu erklären. Und es scheint nicht richtig zu sein, den Typ des Delegierten bei der Erstellung eines StateMachine im Voraus zu deklarieren.

Answer 1

Ich denke, es ist nur ein Name Kollisionsproblem ... try this:

protocol StateType: Hashable {} 

protocol StateMachineDelegate: class { 
    typealias State: StateType 
    func stateMachine(stateMachine: StateMachine<State>, didEnterState newState: State) 
} 

class StateMachine<S: StateType> { 
    typealias State = S 

    weak var delegate: StateMachineDelegate? 


    var currentState: State {...} 

    init(initialState: State) {...} 

    func applyState(toState: State) -> Bool { 
     ... 
      currentState = toState 
     delegate?.stateMachine(self, didEnterState: toState) 
     ... 
    } 
} 

Sie müssen die Namen der gattungsgemäßen Art zu erklären, was im Protokoll definiert in der Klasse es konform sein sollten.

Answer 2

Sehen Sie, wenn diese Abhilfe für Ihre Bedürfnisse in Ordnung ist, es @autoclosure verwendet loswerden ein Problem mit rekursive allgemeinen Definitionen zu erhalten:

class StateMachine<S: Printable, D: StateMachineDelegate where S == D.StateType> { 

    var currentState: S { 
     didSet { 
      // The observer 
      if let delegate = self.delegate { 
       delegate.stateMachine(self, didEnterState: self.currentState) 
      } 
     } 
    } 

    var delegate: D? 

    init(initialState: S) { 
     self.currentState = initialState 
    } 


} 


protocol StateMachineDelegate: class { 
    typealias StateType: Printable 

    // Workaround with autoclosure 
    func stateMachine(machine: @autoclosure() -> StateMachine<StateType, Self>, didEnterState newState: StateType) 
} 

final class ADelegate: StateMachineDelegate { 
    typealias StateType = Int 
    func stateMachine(machine: @autoclosure () -> StateMachine<StateType, ADelegate>, didEnterState newState: StateType) { 
     // Need to _unbox_ the sander from the closure 
     let sender = machine() 
     println(newState) 
     println("State from sender: \(sender.currentState)") 
    } 
} 

let stateMachine = StateMachine<Int, ADelegate>(initialState: 24) 

stateMachine.delegate = ADelegate() 
stateMachine.currentState = 50 

By the way, die Ansicht, dass, wenn Sie den Schleifer zu bekommen, haben Sie wahrscheinlich don muss nicht newState übergeben werden. Ich habe Printable anstelle von Hashable für das Beispiel verwendet.