Make Tree easier to iterate about gwt HOT 20 CLOSED

Example of code:

public void traverseTree(Tree tree) 
{   for(int i = 0; i < tree.getItemCount(); i++) 
    {    TreeItem item = tree.getItem(i); 
          // do action here 
          traverseTree(item); 
    } 
} 


public void traverseTree(TreeItem item) 
{    for(int i = 0; i < item.getChildCount(); i++) 
     {    TreeItem child = item.getChild(i); 
          // do action here 
          traverseTree(child); 
     } 
} 

Possible fix:

It would be much easier if both the Tree and the TreeItem implemented 
an interface called, for example, "HasTreeItemChildren" that would 
include methods "getChildCount" and "getChild". Then the above two ugly 
functions would become one elegant function that would accept both a 
Tree and a TreeItem as follows: 

public void traverseTree(HasTreeItemChildren item) 
{    for(int i = 0; i < item.getChildCount(); i++) 
     {    TreeItem child = item.getChild(i); 
          // do action here 
          traverseTree(child); 
     } 
}

The problem we have here is that Tree and TreeItem actually use different API
methods, which means to implement this, we need to either maintain two seperate APIs
for the same method or depreciate the Tree API, examples are addItem/addChild, 
getItemCount/getChildCount).

Another solution which may work better is to expose the root of the tree to the users
so they may use it instead of the Tree interface.  Can you think of any unintended
consequences for doing that?

Finally, in the current release a depth-first treeItemIterator has been added to
support algorithms that are not sensitive to exact tree position.

...

xcxc

I am voting for common interface for Tree and TreeItem. I would need this interface

to define addItem(...) method.

What about something like this:

class TreeItemIterator implements Iterator {
    private Stack<TreeItem> tree;

    public TreeItemIterator(TreeItem t) {
       tree.push(t);
    }

    public boolean hasNext() {
       return tree.isEmpty();
    }

    public TreeItem next() {
       TreeItem retVal = tree.pop();

       if(retVal.hasChildren()) {
          tree.addAll(retVal.getChildren());
       }

       return retVal;
    }

    // rest omitted.
}

Such an old issue..  Here's a patch of the solution I've been using, brought up to
GWT coding standards.  It uses a HasTreeItems interface to allow the same add/iterate
code to be used between Tree and Treeitem.  For naming consistency with exist add and
remove functions, I chose getItem* over getChild*, and deprecated TreeItem.getChild*.
 I also added an itemIterator method to iterate through the immediate children of a
node, separate from the treeItemIterator method of Tree that runs through the entire
tree, although this is not strictly necessary.

I think this is the right solution vs exposing the root TreeItem, as the latter
really would be an inelegant workaround.  So can we finally fix this issue?

Is it really so difficult to resolve this issue? Give me developer rights on the GWT

project and I'll do it if you are short on resources.

I've been using an approach similar to kozura's with no problems...

Hmm I notice (since it conflicted with my own when updating) that the HasTreeItems interface
has been added in GWT 2.2.  However some methods are still missing from it that really
should be there to be complete:

getItem(int index)
getItemCount()
getItemIndex(TreeItem child)

I also happen to find itemIterator from my patch to be useful, but not required.

review in gerrit: https://gwt-review.googlesource.com/#/c/2520/