スウィフト：Javaでは、クラス

Question

内のプロトコルを宣言私が持っている：

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

は、どのように私はスウィフトに似たものを作成することができますか？私はクラス内でプロトコルを宣言できないようです。しかし、プロトコルを外に宣言すると、State enumにアクセスできなくなります。ありがとう。

私はあなたが次の例のようにclassName.[entity]を使用することにより、クラススコープのエンティティにアクセスすることができます

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

のようなものを持ちたい：

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 
} 

次に、あなただけのCallbackで、他のクラスを拡張することができますプロトコル：

class AnyOtherClass { 
    ... 
} 

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

Answer 2

アクセス可能いくつかの素朴なハンドラとEvent.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 
    } 
} 

使用例を使用してsがState：

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) */