Swift: deklarieren Protokolle innerhalb von Klassen

Question

in Java Ich habe:

public class Event { 

     public enum State { 
      PENDING, 
      UPCOMING, 
      ACTIVE, 
      FINISHED, 
      FAILURE 
     } 

     public interface Callback { 
      void onUpdated(); 
      void onStateChanged(State state); 
     } 

     private State state; 
     private Callback mCallback; 
    } 

Wie kann ich etwas ähnliches in Swift schaffen? Scheint so, als könnte ich das Protokoll nicht innerhalb der Klasse deklarieren. Aber wenn ich das Protokoll außerhalb deklariere, kann ich nicht auf State enum zugreifen. Vielen Dank.

Ich möchte etwas haben, wie

class Event { 

    protocol Delegate { 
     func onUpdated(); 
     func onStateChanged(state: State); 
    } 

    enum State { 
     case PENDING 
     case UPCOMING 
     case ACTIVE 
     case FINISHED 
     case FAILURE 
    } 

    var delegate: Delegate? 
} 

Answer 1

Sie Klasse scoped Einheiten von className.[entity] wie im folgenden Beispiel unter Verwendung von zugreifen können:

protocol Callback { 
    func onUpdated() -> Void 
    func onStateChanged(state: MyClass.State) -> Void 
} 

class MyClass { 
    enum State { 
    case PENDING 
    case UPCOMING 
    case ACTIVE 
    case FINISHED 
    case FAILURE 
    } 

    private var state: State 
    private var mCallback: Callback 
} 

Dann können Sie einfach mit der Callback andere Klasse erweitern Protokoll wie folgt:

class AnyOtherClass { 
    ... 
} 

extension AnyOtherClass: Callback { 
    func onUpdated() { 
    ... 
    } 
    ... 
} 

Answer 2

Sie können zugreifen s StateEvent.State

/* delegate protocol */ 
protocol MyDelegate : class { 
    func onStateChanged(state: Event.State) ->() 
} 

/* default implementation of onStateChanged */ 
extension MyDelegate { 
    func onStateChanged(state: Event.State) { 
     print("State changed to: \(state)") 
    } 
} 

/* your events */ 
class Event { 
    enum State { 
     case Pending 
     case Upcoming 
     case Active 
     case Finished 
     case Failure 
    } 

    weak var delegate: MyDelegate? 

    var state : State { 
     didSet { 
      // call delegate 
      delegate?.onStateChanged(state) 
     } 
    } 

    init(state: State) { 
     self.state = state 
    } 
} 

Beispiel für die Verwendung mit einigen naiven Handler mit:

class EventHandler: MyDelegate { 
    var myEvent : Event 

    init(event: Event) { 
     myEvent = event 
     myEvent.delegate = self 
    } 
} 

class AnotherHandler: MyDelegate { 
    var myEvent : Event 

    init(event: Event) { 
     myEvent = event 
     myEvent.delegate = self 
    } 

    func onStateChanged(state: Event.State) { 
     if state == .Active { 
      print("Event is active") 
     } 
     else { 
      print("Event is not active") 
     } 
    } 
} 

/* example usage */ 
let handler1 = EventHandler(event: Event(state: .Pending)) 
let handler2 = AnotherHandler(event: Event(state: .Pending)) 

handler1.myEvent.state = .Active 
    /* prints "State changed to: Active" (uses default delegate function) */ 

handler2.myEvent.state = .Active 
    /* prints "Event is active" (uses custom delegate function) */