scala:为枚举添加方法

Question

我有这样一个简单的枚举:

object ConditionOperator extends Enumeration {

  val Equal           = Value("equal")
  val NotEqual        = Value("notEqual")
  val GreaterOrEqual  = Value("greaterOrEqual")
  val Greater         = Value("greater")
  val LessOrEqual     = Value("lessOrEqual")
  val Less            = Value("less")

我想为每个枚举添加一个方法,以便我可以像这样使用它:

def buildSqlCondition(field: String, operator: ConditionOperator.Value, value: String ) = {
  val sqlOperator = operator.toSql
  [...]

因此,ConditionOperator.Equal.toSql将返回"=",而ConditionOperator.NotEqual.toSql将返回"<>"等...

但我不知道如何定义toSql方法,以便每个枚举可以"看到"它自己的值并决定如何将自己转换为sql运算符...

Answer 1

这是我在过去对该主题的各种搜索中发现的Scala 2.9.2的示例:

object Progress extends Enumeration {
    type enum = Value

    val READY = new ProgressVal {
      val isActive = false
      def myMethod: Any = { .. }
    }

    val EXECUTE = new ProgressVal {
      val isActive = true
      def myMethod: Any = { .. }
    }

    val COMPLETE = new ProgressVal {
      val isActive = false
      def myMethod: Any = { .. }
    }

    protected abstract class ProgressVal extends Val() {
      val isActive: Boolean
      def myMethod: Any
    }
    implicit def valueToProgress(valu: Value) = valu.asInstanceOf[ProgressVal]
}
type Progress = Progress.enum

• 这implicit是使其可用的关键.

• 的type enum和type Progress是有些多余; 我将它们包括在内,将这两个概念作为我发现有用的东西.

为了给予应有的信用,最初的想法来自肖恩·罗斯( Sean Ross)对这个问题的回答.

Answer 2

您可以首先定义一个覆盖Enumeration.Val. 为了简化事情，我们称之为它（我们重载了中定义的Value原始含义）。所以我们有了新的类型，它继承了它本身也继承了。ValueEnumerationValueEnumeration.ValEnumeration.Value

鉴于它toSql没有副作用并且为每个枚举返回不同的字符串，您不妨将其设为val.

最后，为了使其完全可用，您需要使用 ConditionOperator.apply 和 ConditionOperator.withName 返回新定义的Value类，而不是Value中定义的类型Enumeration。否则，当使用 apply 或 withName 按索引/名称查找实例时ConditionOperator，您将无法调用 toSql，因为枚举类型不够具体。理想情况下，我们只想重写apply和withName并将强制转换添加到ConditionOperator.Value，但这些方法是最终的。然而，我们可以在这里使用一个小技巧：定义新方法apply 并withName使用相同的签名，但附加一个始终可用的隐式参数（Predef.DummyImplicit 完美地适合这个滚动）。附加参数确保签名不同，以便我们能够定义这些新方法，同时与原始的 apply/withName 方法几乎没有区别。scala 中重载解析的规则确保我们的新方法是编译器所青睐的方法（因此我们实际上隐藏了原始方法）。

object ConditionOperator extends Enumeration {
  // Here we overload the meaning of "Value" to suit our needs
  class Value(name: String, val toSql: String) extends super.Val(name) {
    def someFlag: Boolean = true // An example of another method, that you can override below
  }
  val Equal           = new Value("equal", "=")
  val NotEqual        = new Value("notEqual", "<>")
  val GreaterOrEqual  = new Value("greaterOrEqual", ">=")
  val Greater         = new Value("greater", ">")
  val LessOrEqual     = new Value("lessOrEqual", "<=") { override def someFlag = false }
  val Less            = new Value("less", "<")  
  final def apply(x: Int)( implicit dummy: DummyImplicit ): Value = super.apply(x).asInstanceOf[Value]
  final def withName(s: String)( implicit dummy: DummyImplicit ): Value = super.withName(s).asInstanceOf[Value]
}

您可以检查现在是否可以执行诸如ConditionOperator(2).toSql或 ConditionOperator.withName("greaterOrEqual") 之类的操作，它们都按预期返回 ">= 。最后，上面的体操可以抽象出来：

abstract class CustomEnumeration extends Enumeration {
  type BaseValue = super.Val
  type CustomValue <: super.Value
  type Value = CustomValue
  final def apply(x: Int)( implicit dummy: DummyImplicit ): CustomValue = super.apply(x).asInstanceOf[CustomValue]
  final def withName(s: String)( implicit dummy: DummyImplicit ): CustomValue = super.withName(s).asInstanceOf[CustomValue]
}
object ConditionOperator extends CustomEnumeration {
  class CustomValue(name: String, val toSql: String) extends BaseValue(name) {
    def someFlag: Boolean = true
  }
  val Equal           = new Value("equal", "=")
  val NotEqual        = new Value("notEqual", "<>")
  val GreaterOrEqual  = new Value("greaterOrEqual", ">=")
  val Greater         = new Value("greater", ">")
  val LessOrEqual     = new Value("lessOrEqual", "<=") { override def someFlag = false }
  val Less            = new Value("less", "<")  
}