func interpretSignal()

in Sources/DistributedActors/Behaviors.swift [646:699]

• 46 lines of code
• 18 McCabe index (conditional complexity)

    func interpretSignal(context: _ActorContext<Message>, signal: Signal) throws -> _Behavior<Message> {
        // This switch does not use a `default:` clause on purpose!
        // This is to enforce having to consider consider how a signal should be interpreted if a new behavior case is added.
        switch self.underlying {
        case .stop(let postStop, let reason):
            if let postStop = postStop {
                return try .stop(postStop: postStop.interpretSignal(context: context, signal: signal), reason: reason)
            } else {
                return .same
            }

        case .failed(let behavior, let cause):
            return try _Behavior(underlying: .failed(behavior: behavior.interpretSignal(context: context, signal: signal), cause: cause))

        case .signalHandling(_, let handleSignal):
            return try handleSignal(context, signal)
        case .signalHandlingAsync(_, let receiveSignalAsync):
            return self.receiveSignalAsync(context: context, signal: signal, handleSignal: receiveSignalAsync)

        case .orElse(let first, let second):
            let maybeHandled = try first.interpretSignal(context: context, signal: signal)
            if maybeHandled.isUnhandled {
                return try second.interpretSignal(context: context, signal: signal)
            } else {
                return maybeHandled
            }
        case .intercept(let behavior, let interceptor):
            return try interceptor.interceptSignal(target: behavior, context: context, signal: signal) // TODO: do we need to try?
        case .suspended(let previous, let handler):
            let nextBehavior = try previous.interpretSignal(context: context, signal: signal)
            if nextBehavior.isTerminal {
                return nextBehavior
            } else {
                return try .suspended(previousBehavior: previous.canonicalize(context, next: nextBehavior), handler: handler)
            }

        case .receiveMessage, .receive:
            return .unhandled
        case .receiveMessageAsync, .receiveAsync:
            return .unhandled
        case .setup:
            return .unhandled

        case .same:
            return .unhandled
        case .ignore:
            return .unhandled
        case .unhandled:
            return .unhandled

        case .suspend:
            return .unhandled
        }
    }