scala 中的递归 XML

Question

我正在尝试用 scala 解析此文档：

<?xml version="1.0"?>
<model>
    <joint name="pelvis">
            <joint name="lleg">
                    <joint name="lfoot"/>
            </joint>
            <joint name="rleg">
                    <joint name="rfoot"/>
            </joint>
    </joint>
</model>

我想用它为我的 2d 动画引擎创建一个骨架。每个关节都应该制作成相应的对象，并将所有子对象添加到其中。

所以这部分应该产生与此类似的结果：

j = new Joint("pelvis")
lleg = new Joint("lleg")
lfoot = new Joint("lfoot")
rleg = new Joint("rleg")
rfoot = new Joint("rfoot")
lleg.addJoint(lfoot)
rleg.addJoint(rfoot)
j.addJoint(lleg)
j.addJoint(rleg)

但是，我在浏览 xml 代码时遇到了问题。一方面，我不确定我是否完全理解语法 xml \\ "joint"，它似乎会生成一个包含所有标签的 NodeSeq。

---

主要问题：

1. 理解 scala 中 xml 语法的问题，即 xml \\ "...", Elem.child?,
2. 从父节点获取属性而不从所有子节点获取属性时出现问题 ( xml \\ "@attribute"，生成所有属性的串联..？）

Answer 1

运算符 \\ 是一个类似 XPath 的运算符。它将“选择”所有具有某种特征的后代。

这可以通过两遍来完成，如下所示：

val jointSeq = xml \\ "joint"
val jointMap = scala.collection.mutable.Map[String, Joint]

// First pass, create all joints
for {
  joint <- jointSeq
  names <- joint attribute "name"
  name <- names
} jointMap(name) = new Joint(name)

// Second pass, assign children
for {
  joint <- jointSeq
  names <- joint attribute "name"
  name <- names
  child <- joint \ "joint" // all direct descendants "joint" tags
  childNames <- child attribute "name"
  childName <- childNames
} jointMap(name).addJoint(jointMap(childName))

我想我更喜欢递归解决方案，但这应该是相当可行的。

Answer 2

使用 xtract 可以轻松完成此操作。

case class Joint(name: String, joints: Seq[Joint])
object Joint {
  implicit val reader: XmlReader[Joint] = (
    attribute[String]("name") and
    (__ \ "joint").lazyRead(seq(reader))
  )(apply _)
}

请注意如何使用lazyRead，以便可以递归地使用Joint 的读取器。

这篇博文更详细地讨论了 xtract：https://www.lucidchart.com/techblog/2016/07/12/introducing-xtract-a-new-xml-deserialization-library-for-scala/

免责声明：我在 Lucid Software 工作，并且是 xtract 的主要贡献者。

Answer 3

还有一个使用 scala.xml.pull.XMLEventReader 的解决方案：

val source = Source.fromPath("...") // or use fromString

var result: Joint = null

val xer = new XMLEventReader(source)
val ancestors = new Stack[Joint]()

while (xer.hasNext) {
  xer.next match {
    case EvElemStart(_, "joint", UnprefixedAttribute(_, name, _), _) =>
      val joint = new Joint(name.toString)
      if (ancestors.nonEmpty)
        ancestors.top.addJoint(joint)
      ancestors.push(joint)
    case EvElemEnd(_, "joint") =>
      result = ancestors.pop
    case _ =>
  }
}

println(result)

这是 Scala 2.8。

我已经发布了完整的源代码 此处。处理模型确实是顺序的，但效果很好，因为每个开放标记都将指示我们需要创建一个 Joint 对象，可以选择将其添加到父对象并存储为新的父对象。关闭标签会根据需要弹出父标签。