2

在 Eclipse 数据绑定的上下文中，有很多 Java 类充当IObservable对象的工厂。例如，有BeanObservables, PojoObservables,EMFObservables等，它们都实现了一组类似的方法

  public static IObservableValue observeValue(Object target, String property)

现在，如果我们在 Scala 世界中，这些工厂中的每一个都可能是实现一个共同特征的单例对象，例如，IObservableFactory我可以将它们作为隐式值传递给使用它们来创建数据绑定的方法.

但是由于它们是用 Java 定义的，所以我似乎什么都做不了。我不能写

val pojoObservableFact = PojoObservables

因为PojoObservables不被认为是一个值。

有没有办法让编译器“实例化”一个与PojoObservablesScala 中的类相对应的单例？或者有什么解决方法？我知道我可以自己编写单例并转发所有方法调用，但这听起来有点乏味。

编辑

为了更清楚：这就是我想要做的：定义一个使用传递的工厂创建可观察值的方法。

def createObservable(fact: ObservableFactory, target: AnyRef, property: String) =
  fact.observeValue(target, property)

但我不知道如何定义ObservableFactory或如何实际将PojoObservables只有静态方法的 Java 类传递给该createObservable方法。

4

4 回答 4

4

如果没有其他人提出可行的答案，我认为编写基于方法签名的代码生成器并不难。

val a = classOf[String].getMethods.map(_.toString).filter(s =>
  s.contains("public") && s.contains("static")
)

例如，将提取所有方法签名（String在本例中）作为字符串。然后

val b = a.map(_.split(" ").reverse.take(2).reverse)

将只获取函数签名，返回类型在前面拆分。现在

val c = b.map(_(1).dropWhile(_ != '(').drop(1).takeWhile(_ != ')').split(","))
val d = b.map(_(1).takeWhile(_ != '('))

将分别获得函数的参数签名和名称。然后我们需要转换原始类型，这很容易，因为我们只需要将第一个字母大写（除了 void 成为单位）：

def jprim2scala(s: String) = {
  val prim = List("boolean","byte","short","char","int","long","float","double")
  def arrayconvert(s: String): String = {
    if (s.endsWith("[]")) "Array["+arrayconvert(s.substring(0,s.length-2))+"]"
    else if (s=="void") "Unit"
    else if (prim contains s) {
      s.substring(0,1).toUpperCase + s.substring(1)
    }
    else s
  }
  arrayconvert(s)
}

def e = (b,c).zipped.map((bi,ci) => (jprim2scala(bi(0)), ci.map(jprim2scala)))

最后你可以把它们重新组合起来：

val f = (d,e).zipped.map((name,ei) => {
  val (ret,args) = ei
  val lastname = name.split('.').last
  "def "+lastname+"(" +
  (for ((a,i) <- args.zipWithIndex) yield ("a"+i+": "+a)).mkString(", ") +
  "): "+ret+" = "+name+"("+(0 until args.length).map("a"+_).mkString(",")+")"
})

现在您有一堆 Scala 代码，您可以（手动）将它们放入适当的单例中。

object Stringleton {
  // The contents of this is cut-and-paste f.map("  "+_).foreach(println)
  def valueOf(a0: java.lang.Object): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Array[Char]): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Array[Char], a1: Int, a2: Int): java.lang.String = java.lang.String.valueOf(a0,a1,a2)
  def valueOf(a0: Boolean): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Char): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Int): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Long): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Float): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Double): java.lang.String = java.lang.String.valueOf(a0)
  def copyValueOf(a0: Array[Char], a1: Int, a2: Int): java.lang.String = java.lang.String.copyValueOf(a0,a1,a2)
  def copyValueOf(a0: Array[Char]): java.lang.String = java.lang.String.copyValueOf(a0)
  def format(a0: java.lang.String, a1: Array[java.lang.Object]): java.lang.String = java.lang.String.format(a0,a1)
  def format(a0: java.util.Locale, a1: java.lang.String, a2: Array[java.lang.Object]): java.lang.String = java.lang.String.format(a0,a1,a2)
}

（顺便说一句，可变参数在这里不起作用——如果它们存在，你需要修复它们。你可以通过.isVarArgs从方法本身（不是它的字符串表示）返回到方法并转换最后一个 Array[X ] 到 X* 中，然后将其称为ai: _*.)

这种方法的好处是，如果有通用方法，你甚至不需要使用结构类型来提取它们——你可以定义你自己的特征，你的包装方法继承自！（如果你特别有野心，你可以硬塞几乎但不完全符合的方法来实际符合，例如，所有方法都具有相同的方法名称。）

于 2011-02-07T13:32:00.167 回答
3

为什么不简单地传递工厂方法（或一组方法，如果需要）？

def createObservable(fact: (AnyRef, String) => IObservableValue, 
target: AnyRef, property: String) = fact(target, property)

createObservable(BeanObservables.createObservable, target, property)
于 2011-02-07T13:13:19.570 回答
0

所以PojoObservables从这里observeValue获取参考，我可以看到你描述的静态方法。

这是一个简单的方法，Scala 将 Java 类上的静态方法视为它们是在同伴上定义的。您可以像使用老式 Java 一样使用它：

import org.eclipse.core.databinding.beans.PojoObservables
...
val ov = PojoObservables.observeValue(target, property)

或者带有静态导入的新学校变体：

import org.eclipse.core.databinding.beans.PojoObservables._
...
val ov = observeValue(target, property)

然后，您可以将任何此类方法作为函数对象传递。函数需要以某种方式由其接口护送的想法是非常以 Java 为中心的思想，只需引用您需要的任何内容并作为参数提供给其他更高级的函数 :)

于 2011-02-07T12:52:12.660 回答
-1

一种方法是使用反射：

object PojoObservables

val pojoObservableFact = PojoObservables.getClass.getConstructor()
pojoObservableFact.setAccessible(true)
pojoObservableFact.newInstance()

现在我们可以调用 PojoObservables.method 上的方法...

于 2011-02-07T12:36:50.637 回答