जेनेरिक क्लास

Question

के लिए स्विफ्ट प्रतिनिधि प्रोटोकॉल मेरे पास एक कक्षा है, StateMachine, जो कि राज्यों के विभिन्न सेटों को लागू करने के लिए जेनेरिक है, उदाहरण के लिए, एक enum। जब राज्य मशीन एक नई स्थिति में प्रवेश करती है तो मैं एक प्रतिनिधि को सूचित करने के लिए StateMachineDelegate प्रोटोकॉल का उपयोग करना चाहता हूं।

लेकिन यह काम नहीं करता है क्योंकि प्रतिनिधि प्रोटोकॉल भी प्रकार की आवश्यकताओं के साथ सामान्य है। त्रुटि दिखाती है कि 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) 
     ... 
    } 
} 

मैं किसी भी तरह StateMachine कक्षा में है कि StateMachineDelegate.S == S संबद्ध करने की आवश्यकता है, लेकिन मैं ऐसा करने के तरीके यकीन नहीं है, या अगर यह संभव है। मैंने कोशिश की:

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

लेकिन फिर मैं प्रोटोकॉल rework करने के लिए ठीक से StateMachine के जेनेरिक प्रकार की घोषणा करने की कोशिश कर अटक जाते हैं। और StateMachine बनाते समय प्रतिनिधि के सामने के प्रकार की घोषणा करना सही नहीं लगता है।

Answer 1

मुझे लगता है कि इसकी सिर्फ एक नाम टक्कर समस्या ... इस प्रयास करें:

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

आप घोषित करने के लिए क्या सामान्य प्रकार प्रोटोकॉल में परिभाषित के नाम वर्ग यह के अनुरूप में होना चाहिए की जरूरत है। यदि इस समाधान आपकी आवश्यकताओं के लिए ठीक है

Answer 2

देखें, यह @autoclosure का उपयोग करता पुनरावर्ती सामान्य परिभाषा के साथ एक समस्या से छुटकारा पाने के:

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 

वैसे, विचार है कि आप Sander मिलता है, शायद आप डॉन newState पास करने की आवश्यकता नहीं है। उदाहरण के लिए Hashable के स्थान पर मैंने Printable का उपयोग किया।