Walking the Tree

/**
 * This method will traverse a Tree's model independent of it's
 * type.
 * 
 * <p>Note :: This method may look long and arduous but, rest assured
 * it has all the checks to perform like a champ. Also, you 'could'
 * refactor part of this method but, for the sake of explanation, I
 * kept it all in one place.</p>
 * 
 * <p>Remember, I had coupled the model to this method by tracing
 * @label, obviously you do not need to do this. The intention of
 * this example is to show you that the dataDescriptor seperates
 * the models type and is awesome. It enables you to create a tight 
 * method like this without type checks on the model.</p>
 *
 * @param tree The Tree instance that will be examined by the method.
 * @param item An item found in the dataProvider of the Tree passed in.
 * @param startAtParent A boolean that determines if the method upon
 * initialization will back up one leve3l to the item passed in and
 * start it's recursion at the item's parent node. 
 */
public function walkTree(tree:Tree, item:Object, startAtParent:Boolean = false):void
{
	// get the Tree's data descriptor
	var descriptor:ITreeDataDescriptor = tree.dataDescriptor;
	var cursor:IViewCursor;
 
	var parentItem:Object;
	var childItem:Object;
	var childItems:Object;
 
	// if the item is null, stop
	if (item == null)
		return;
 
	// do we back up one level to the item's parent
	if (startAtParent)
	{
		// get the parent
		parentItem = tree.getParentItem(item);
		// is the parent real
		if (parentItem)
		{
			trace("|-- Parent Node ", parentItem[tree.labelField]);
			// if the parent is a branch
			if (descriptor.isBranch(parentItem))
			{
				// if the branch has children to run through
				if (descriptor.hasChildren(parentItem)) 
				{
					// get the children of the branch
					// this part of the algorithm contains the item
					// passed
					childItems = descriptor.getChildren(parentItem);
				}
			}
			// if the branch has valid child items
			if (childItems)
			{
				// create our back step cursor
				cursor = childItems.createCursor();
				// loop through the items parent's children (item)
				while (!cursor.afterLast)
				{
					// get the current child item
					childItem = cursor.current;
 
					var label:String = childItem[tree.labelField];
					var branch:Boolean = descriptor.isBranch(childItem);
 
					// good place for a custom method()
					trace("Sibling Nodes :: ", label, "Is Branch :: ", branch); 
 
					// if the child item is a branch
					if (descriptor.isBranch(childItem))
						// traverse the childs branch all the way down 
						// before returning
						walkTree(tree, childItem);
					// do it again!
					cursor.moveNext();
				}
			}
		}
	}
	else // we don't want the parent OR this is the second iteration
	{
		// if we are a branch
		if (descriptor.isBranch(item))
		{
			// if the branch has children to run through
			if (descriptor.hasChildren(item)) 
			{
				// get the children of the branch
				childItems = descriptor.getChildren(item);
			}
 
			// if the child items exist
			if (childItems)
			{
				// create our cursor pointer
				cursor = childItems.createCursor();
				// loop through all of the children
				// if one of these children are a branch we will recurse
				while (!cursor.afterLast)
				{
					// get the current child item
					childItem = cursor.current;
 
					var label:String =  childItem[tree.labelField];
					var branch:Boolean = descriptor.isBranch(childItem);
 
					// good place for a custom method()
					trace("-- Sub Node :: ", label, "Is Branch :: ", branch); 
 
					// if the child item is a branch
					if (descriptor.isBranch(childItem))
						// traverse the childs branch all the way down 
						// before returning
						walkTree(tree, childItem);
					// check the next child
					cursor.moveNext();
				}
			}
		}
	}
}