Question

在java中我有：

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

如何在Swift中创建类似的东西？好像我无法在类中声明协议。但是当我在外面声明协议时，我无法访问状态枚举。感谢。

我想要像

这样的东西

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

您可以使用className.[entity]访问类范围的实体，如以下示例所示：

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

您可以使用State

访问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
    }
}

使用一些天真的处理程序的示例：

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

Swift：在类中声明协议

2 个答案: