[jdom-interest] new to jdom .. and many questions

[Dennis Sosnoski]

If you truly want to navigate the tree in a breath-first manner it's 
going to be messy. Probably the easiest way of doing this is to have a 
recursive walker that you pass a depth parameter to. This would look 
something like this:

Element nextAtDepth(Element from, int depth) {
  // depth must always be <= 0
  if (depth > 0) {  // meaning we need to go deeper in the tree
    if (from.hasChildren()) {
      Iterator iter = from.getChildren().iterator();  // check all 
children to find descendant at depth
      while (iter.hasNext()) {
        Element found = nextAtDepth((Element)iter.next(), depth-1);
        if (found != null) {
          return found;
        }
      }
    }
    // no descendants at depth we want
    return null;
  } else {
    // next at same level as this element, loop to move up tree until 
sibling found
    Element parent;
    Element match = from;
    while ((parent = match.getParent()) != null) {
      // see if there's a sibling following our current element
      List children = parent.getChildren();
      int index = children.indexOf(from);
      if (index >= 0)
        while ((index+1) < children.size()) {
          // if this is our first time through this loop we've found the 
next one; otherwise we need to descend
          Element sibling = (Element)children.get(index+1);
          if (depth == 0) {
            return sibling;
          } else {
            Element found = nextAtDepth(sibling, depth);
            if (found != null) {
              return found;
            }
          }
          // try next sibling for descendants at target depth
          index++;
        }
      }
      // move up the tree for next pass through this loop
      depth++;
      match = parent;
    }
  }
}

There might be a cleaner way of structuring this, but I'm not going to 
worry about it. The basic idea is that you mix two techniques; one finds 
the first descendant at a specified depth from the supplied element, the 
other finds the next sibling of the supplied element (or if there is 
none, the first child element of the next sibling of the parent of the 
supplied element, or the first grandchild of the next sibling of the 
grandparent, etc.).

The first element in a breath-first walk is always the root element. The 
next one is returned by this method when you call it with (root, 1). You 
can then call it with (current, 0) until it returns null, at which point 
you call it with (root, 2) to find the first element at the next level. 
Keep repeating until you reach some depth n where (root, n) returns 
null, at which point you're done.

Hope that helps.

  - Dennis

Azrael wrote:

> Of course, you're very much correct regarding my first question.. it's
> late and I wasn't thinking straight :)
> I badly explained with extra detail what would have been simpler with a
> shorter question.. of how to find if it was the very last element or not.
> I don't really want to be learning to use XPATH in java right now.. 
> and so will go for the iterating method you suggest..
> finding next sibling as you say is easy enough.. but I am a little 
> unsure about how to navigate the jdom tree breadth first using the 
> Lists.. does anyone have example code that I could use as a guide?
>