kotlin - KOTLIN:当条件子句与另一个子句一起使用时，可重构大 yield

Question

这是一个设计和技术方面的问题，因此在进行重构时，我正在对一个随机项目进行更新，遇到了以下部分，即密封类上的infix函数，该类正在执行某种验证:

infix fun TaskState.allowsOperation(operation: TaskOperation): Boolean {
    return when (this) {
        TaskState.Scheduled -> {
            when (operation) {
                TaskOperation.Start -> true
                TaskOperation.Stop -> false
                TaskOperation.Pause -> false
                TaskOperation.Resume -> false
            }
        }
        TaskState.Running -> {
            when (operation) {
                TaskOperation.Start -> false
                TaskOperation.Stop -> true
                TaskOperation.Pause -> true
                TaskOperation.Resume -> false
            }
        }
        TaskState.Stopped -> {
            when (operation) {
                TaskOperation.Start -> false
                TaskOperation.Stop -> false
                TaskOperation.Pause -> false
                TaskOperation.Resume -> false
            }
        }
        TaskState.Suspended -> {
            when (operation) {
                TaskOperation.Start -> false
                TaskOperation.Stop -> true
                TaskOperation.Pause -> false
                TaskOperation.Resume -> true
            }
        }
        TaskState.Terminated -> {
            when (operation) {
                TaskOperation.Start -> true
                TaskOperation.Stop -> false
                TaskOperation.Pause -> false
                TaskOperation.Resume -> false
            }
        }
        TaskState.Created -> {
            when (operation) {
                TaskOperation.Start -> true
                TaskOperation.Stop -> false
                TaskOperation.Pause -> false
                TaskOperation.Resume -> false
            }
        }
    }
}

因此，基本上，正在发生的事情是添加了糖语法，它允许在其他部分中这样调用代码:
if (task.state allowsOperation operation) doSomething()
但是，我发现那一堆特定的代码看起来很丑陋，我无法提出一种合理的另一种实现方式，但同时又不会产生太多更改。

TaskState和TaskOperation只是一些密封的类:

sealed class TaskState {
    object Created : TaskState()
    object Scheduled : TaskState()
    object Running : TaskState()
    object Stopped : TaskState()
    object Terminated : TaskState()
}

sealed class TaskOperation {
    object Start : TaskOperation()
    object Stop : TaskOperation()
    object Pause : TaskOperation()
    object Resume : TaskOperation()
}

您对如何重构这种东西有什么建议吗？

Answer 1

没有必要将这些密封的类，因为每个子类都是object，而且它们都没有任何不同的参数。仅使用枚举，但是您必须在其中一个使用is语句的地方删除所有when关键字。

通过为TaskState类提供允许操作的参数，可以简化代码量。这可以替代您上面的所有内容。

enum class TaskOperation {
    Start, Stop, Pause, Resume
}

enum class TaskState(private vararg val allowableOperations: TaskOperation) {
    Scheduled(TaskOperation.Start),
    Running(TaskOperation.Stop, TaskOperation.Pause),
    Stopped(),
    Suspended(TaskOperation.Stop, TaskOperation.Resume),
    Terminated(TaskOperation.Start);

    infix fun allowsOperation(operation: TaskOperation) = operation in allowableOperations
}

同样，这是一种观点，但是我认为，如果函数不加入或不比较两件事，那么使用 infix会增加可读性，这是很愚蠢的。