Question

我有一个输出信号，当一组给定的定时器之一超时，完成或重置整个列表时，应该输出该信号。

enum DeviceActionStatus {
    case pending
    case completed
    case failed
}

struct DeviceAction {

    let start: Date
    let status: DeviceActionStatus 
    func isTimedOut() -> Bool // if start is over 30 seconds ago
    let id: String

}

输出信号：

let pendingActionUpdated: Signal<[DeviceAction], NoError>

输入：

let completeAction: Signal<String, NoError>
let tick: Signal<Void, NoError>  // runs every 1 second and should iterate to see if any DeviceAction is timed out
let addAction: Signal<DeviceAction, NoError> 
let resetAllActions: Signal<Void, NoError>

它应该输出所有正在运行的设备操作的数组。

let output = Signal.combineLatest( 
                     addAction,
                     resetAllActions,
                     tick,
                     Signal.merge(
                          completeAction,
                          tick.take(first: 1).map { _ in "InvalidActionId" }
                     )) // make sure the combinelatest can fire initially

我尝试将其发送到.scan以在每次触发addAction时进行累积，并在每次触发resetAllActions时进行重置，但是由于无法知道其中哪一个被解雇了，我无法理解逻辑。我如何既可以累积不断增长的列表，又可以浏览并重置我的列表？

Answer 1

这看起来像是合并/枚举模式的工作。我本人更是一个RxSwift家伙，但是如果您将每个Signal映射到一个枚举并合并它们，那么就可以正确地将它们接收到扫描中了……

enum ActionEvent {
    case complete(String)
    case tick
    case add(DeviceAction)
    case reset
}

merge(
    completeAction.map { ActionEvent.complete($0) },
    tick.map { ActionEvent.tick },
    addAction.map { ActionEvent.add($0) },
    resetAllActions.map { ActionEvent.reset }
).scan([DeviceAction]()) { actions, event in 
    switch event {
    case let .complete(id):
        return actions.filter { $0.id != id }
    case .tick:
        return actions.filter { $0.isTimedOut() == false }
    case let .add(action):
        return actions + [action]
    case .reset:
        let resetDate = Date()
        return actions.map { $0.start = resetDate }
        // or
        return []
        // depending on what "reset" means.
}

Answer 2

在这里看到完整的用例有点困难，所以我将只描述如何区分被addAction和resultAllActions被解雇的情况，而将其余的设计搁置一旁。

您可以在Signal.combineLatest之前将这两个信号合并为一个信号。为此，您需要将它们映射到相同的类型。枚举对此非常合适：

enum Action {
    case add(DeviceAction)
    case resetAll
}

现在您可以映射每个信号并将它们合并为一个信号：

let action = Signal.merge(
    addAction.map { Action.add($0) },
    resetAllActions.map { _ in Action.resetAll })

现在，您可以打开scan中的值，并确定它是要添加的新操作还是重置操作。

给定一个计时器列表，如何在其中一个计时器完成时输出，同时又能够重置该列表？

2 个答案: