Home/ Questions/Q 3806682
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-19T14:52:21+00:00

Expanding on a question I asked earlier about how to iterate over a collection

  • 0

Expanding on a question I asked earlier about how to iterate over a collection of nodes in scala.xml.Node found here

I wanted to take this 1 step further and ask how I could look up to a previous child inside a recursive function to get a value once I hit a specific situation

For example (the markup is here)

<html>
    <head class="foo">
        <title>Welcome</title>
    </head>
    <body>
        <div>
            <p>Foo</p>
        </div>
    </body>
</html>

With my current implementation (thanks to @knut-arne-vedaa)

def processNode(node: Node) {
  if (node.isInstanceOf[Text]) {
      if (node.text.contains("Welcome"))
      {
        //then inside here I want to go up to the prev element (head) and pull the class 
      }
    }
  node.child foreach processNode
}

I want to add another conditional to get the text “foo” from inside the class section

Any idea what I could add inside this if statement to pull this value directly? Also how can I return the String value from this fx? a break w/ a simple return line or ?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    Note that the parent of the Text node in your example is actually the <title> node.

    Since Nodes don’t have references to their parents, one way to access them is just to pass them with you when walking down the tree, like this:

    def processNode(node: Node, parent: Option[Node]) {
  if (node.isInstanceOf[Text]) {
      if (node.text.contains("Welcome"))
      {
        println("Node: " + node)
        println("Parent: " + parent.getOrElse("[toplevel]"))
      }
    }
  node.child foreach { n: Node => processNode(n, Some(node)) }
}
processNode(xml, None)

    Of course, this becomes unwieldy when you want to climb back up the tree to an arbitrary level. One approach to this is to wrap your nodes in a SuperNode that has an optional parent reference.

    case class SuperNode(current: Node, parent: Option[SuperNode] = None)

    For convenience, make an implicit function to convert nodes to SuperNodes in the default case of no parent.

    implicit def nodeMakeSuper(n: Node) = SuperNode(n)

    Now you can navigate up the tree an arbitrary number of times, like this:

    def processNode(node: SuperNode) {
  node.current match {
      case n @ Text(t) if t.contains("Welcome") => {
          println("Node: " + n)
          node.parent match {
              case Some(p) => {
                  println("Parent: " + p.current)
                  p.parent match {
                      case Some(gp) => println("GrandParent: " + gp.current)
                      case None => println("No grandparent!")
                  }
              }
              case None => println("No parent!")
          }

      }
      case _ => // these aren't the droids you're looking for
  }
  node.current.child foreach { child: Node => processNode(SuperNode(child, Some(node))) }
}
    • 0