Protocollo Swift delegato per classe generica

Question

Ho una classe, StateMachine, che è generica per consentire l'implementazione di diversi set di stati come, ad esempio, un enum. Voglio utilizzare un protocollo StateMachineDelegate per informare un delegato quando la macchina di stato entra in un nuovo stato.

Ma questo non funziona poiché il protocollo delegato è anche generico con i requisiti del tipo. L'errore mostra dove viene dichiarata la proprietà delegate.

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

ho bisogno di associare in qualche modo che StateMachineDelegate.S == S nella classe StateMachine, ma non sono sicuro come fare questo, o se è possibile. Ho provato:

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

ma poi mi si blocca cercando di rielaborare il protocollo di dichiarare correttamente il tipo generico di StateMachine. E non sembra giusto dover dichiarare in anticipo il tipo di delegato durante la creazione di uno StateMachine.

Answer 1

penso che il suo solo un problema di collisione nome ... provate questo:

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

è necessario dichiarare qual è il nome del tipo generico definito nel protocollo dovrebbe essere nella classe conforme ad esso.

Answer 2

Vedere se questa soluzione è ok per le vostre esigenze, utilizza @autoclosure per sbarazzarsi di un problema con le definizioni ricorsive generiche:

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 

A proposito, considerare che se si ottiene la levigatrice, probabilmente don Non è necessario far passare il newState. Per l'esempio ho utilizzato Printable al posto di Hashable.