Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## charvax.swing.tree
Class DefaultMutableTreeNode

    java.lang.Object
      charvax.swing.tree.DefaultMutableTreeNode

All Implemented Interfaces:
  MutableTreeNode, TreeNode

public class DefaultMutableTreeNode
extends java.lang.Object
implements MutableTreeNode

A DefaultMutableTreeNode is a general-purpose node in a tree data structure.

A tree node may have at most one parent and 0 or more children. DefaultMutableTreeNode provides operations for examining and modifying a node's parent and children and also operations for examining the tree that the node is a part of. A node's tree is the set of all nodes that can be reached by starting at the node and following all the possible links to parents and children. A node with no parent is the root of its tree; a node with no children is a leaf. A tree may consist of many subtrees, each node acting as the root for its own subtree.

This class provides enumerations for efficiently traversing a tree or subtree in various orders or for following the path between two nodes. A DefaultMutableTreeNode may also hold a reference to a user object, the use of which is left to the user. Asking a DefaultMutableTreeNode for its string representation with toString() returns the string representation of its user object.

Field Summary
`protected boolean` | `_allowsChildren` True if this node can have children.
`protected java.util.Vector` | `_children` Array of children, may be null if this node has no children.
`protected DefaultMutableTreeNode` | `_parent` This node's parent, or null if this node has no parent.
`protected java.lang.Object` | `_userObject` Optional user object.

Method Summary
`void` | `add(MutableTreeNode newChild)` Removes newChild from its parent and makes it a child of this node by adding it to the end of this node's child array.
`java.util.Enumeration` | `children()` Creates and returns a forward-order enumeration of this node's children.
`boolean` | `getAllowsChildren()` Returns true if this node is allowed to have children.
`TreeNode` | `getChildAfter(TreeNode aChild)` Returns the child in this node's child array that immediately follows aChild, which must be a child of this node.
`TreeNode` | `getChildAt(int index)` Returns the child at the specified index in this node's child array.
`TreeNode` | `getChildBefore(TreeNode aChild)` Returns the child in this node's child array that immediately precedes aChild, which must be a child of this node.
`int` | `getChildCount()` Returns the number of children of this node.
`int` | `getDepth()` Returns the depth of the tree rooted at this node -- the longest distance from this node to a leaf.
`TreeNode` | `getFirstChild()` Returns this node's first child.
`DefaultMutableTreeNode` | `getFirstLeaf()` Finds and returns the first leaf that is a descendant of this node -- either this node or its first child's first leaf.
`int` | `getIndex(TreeNode aChild)` Returns the index of the specified child in this node's child array.
`TreeNode` | `getLastChild()` Returns this node's last child.
`DefaultMutableTreeNode` | `getLastLeaf()` Finds and returns the last leaf that is a descendant of this node -- either this node or its last child's last leaf.
`int` | `getLevel()` Returns the number of levels above this node -- the distance from the root to this node.
`DefaultMutableTreeNode` | `getNextLeaf()` Returns the leaf after this node or null if this node is the last leaf in the tree.
`TreeNode` | `getParent()` Returns this node's parent or null if this node has no parent.
`TreeNode[]` | `getPath()` Returns the path from the root, to get to this node.
`DefaultMutableTreeNode` | `getPreviousLeaf()` Returns the leaf before this node or null if this node is the first leaf in the tree.
`TreeNode` | `getRoot()` Returns the root of the tree that contains this node.
`java.lang.Object` | `getUserObject()` Returns this node's user object.
`java.lang.Object[]` | `getUserObjectPath()` Returns the user object path, from the root, to get to this node.
`void` | `insert(MutableTreeNode child, int index)` Adds child to this MutableTreeNode at index.
`boolean` | `isLeaf()` Returns true if this node has no children.
`boolean` | `isNodeAncestor(TreeNode anotherNode)` Returns true if anotherNode is an ancestor of this node -- if it is this node, this node's parent, or an ancestor of this node's parent.
`boolean` | `isNodeChild(TreeNode aNode)` Returns true if aNode is a child of this node.
`boolean` | `isNodeDescendant(TreeNode anotherNode)` Returns true if anotherNode is a descendant of this node -- if it is this node, one of this node's children, or a descendant of one of this node's children.
`boolean` | `isRoot()` Returns true if this node is the root of the tree.
`java.util.Enumeration` | `postorderEnumeration()` Creates and returns an enumeration that traverses the subtree rooted at this node in postorder.
`java.util.Enumeration` | `preorderEnumeration()` Creates and returns an enumeration that traverses the subtree rooted at this node in preorder.
`void` | `remove(int index)` Removes the child at index from this MutableTreeNode.
`void` | `remove(MutableTreeNode node)` Removes node from this MutableTreeNode, giving it a null parent.
`void` | `removeAllChildren()` Removes all of this node's children, setting their parents to null.
`void` | `removeFromParent()` Removes the subtree rooted at this node from the tree, giving this node a null parent.
`void` | `setAllowsChildren(boolean allows)` Determines whether or not this node is allowed to have children.
`void` | `setParent(MutableTreeNode newParent)` Sets this node's parent to newParent but does not change the parent's child array.
`void` | `setUserObject(java.lang.Object object)` Resets the user object of this MutableTreeNode to object.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### _children

    protected java.util.Vector _children

  Array of children, may be null if this node has no children.

### _parent

    protected DefaultMutableTreeNode _parent

  This node's parent, or null if this node has no parent. Note that in javax.swing.tree.DefaultMutableTreeNode, this member is a MutableTreeNode - which makes life difficult.

### _allowsChildren

    protected boolean _allowsChildren

  True if this node can have children.

### _userObject

    protected java.lang.Object _userObject

  Optional user object.

Method Detail

### insert

    public void insert(MutableTreeNode child,
                       int index)

  Adds child to this MutableTreeNode at index. The setParent() method of child will be called.

  Specified by:
    `insert` in interface `MutableTreeNode`

### remove

    public void remove(int index)

  Removes the child at index from this MutableTreeNode.

  Specified by:
    `remove` in interface `MutableTreeNode`

### remove

    public void remove(MutableTreeNode node)

  Removes node from this MutableTreeNode, giving it a null parent. The setParent() method of "node" will be called.

  Specified by:
    `remove` in interface `MutableTreeNode`

### setUserObject

    public void setUserObject(java.lang.Object object)

  Resets the user object of this MutableTreeNode to object.

  Specified by:
    `setUserObject` in interface `MutableTreeNode`

### removeFromParent

    public void removeFromParent()

  Removes the subtree rooted at this node from the tree, giving this node a null parent. Does nothing if this node is the root of its tree.

  Specified by:
    `removeFromParent` in interface `MutableTreeNode`

### setParent

    public void setParent(MutableTreeNode newParent)

  Sets this node's parent to newParent but does not change the parent's child array. This method is called from insert() and remove() to reassign a child's parent, it should not be called from anywhere else.

  Specified by:
    `setParent` in interface `MutableTreeNode`

### getParent

    public TreeNode getParent()

  Returns this node's parent or null if this node has no parent.

  Specified by:
    `getParent` in interface `TreeNode`

### getChildAt

    public TreeNode getChildAt(int index)

  Returns the child at the specified index in this node's child array.

  Specified by:
    `getChildAt` in interface `TreeNode`
  Parameters:
    `index` - an index into this node's child array.
  Returns:
    the TreeNode in this node's child array at the specified index

### getChildCount

    public int getChildCount()

  Returns the number of children of this node.

  Specified by:
    `getChildCount` in interface `TreeNode`

### getIndex

    public int getIndex(TreeNode aChild)

  Returns the index of the specified child in this node's child array. If the specified node is not a child of this node, returns -1. This method performs a linear search and is O(n) where n is the number of children.

  Parameters:
    `aChild` - the TreeNode to search for among this node's children.
  Returns:
    an int giving the index of the node in this node's child array, or -1 if the specified node is a not a child of this node

### children

    public java.util.Enumeration children()

  Creates and returns a forward-order enumeration of this node's children. Modifying this node's child array invalidates any child enumerations created before the modification.

  Specified by:
    `children` in interface `TreeNode`

### setAllowsChildren

    public void setAllowsChildren(boolean allows)

  Determines whether or not this node is allowed to have children. If allows is false, all of this node's children are removed.

  Parameters:
    `allows` - true if this node is allowed to have children.

### getAllowsChildren

    public boolean getAllowsChildren()

  Returns true if this node is allowed to have children.

  Specified by:
    `getAllowsChildren` in interface `TreeNode`

### getUserObject

    public java.lang.Object getUserObject()

  Returns this node's user object.

  Specified by:
    `getUserObject` in interface `MutableTreeNode`

### removeAllChildren

    public void removeAllChildren()

  Removes all of this node's children, setting their parents to null. If this node has no children, this method does nothing.

### add

    public void add(MutableTreeNode newChild)

  Removes newChild from its parent and makes it a child of this node by adding it to the end of this node's child array.

  Parameters:
    `newChild` - node to add as a child of this node.
  Throws:
    `java.lang.IllegalArgumentException` - if newChild is null.
    `java.lang.IllegalStateException` - if this node does not allow children.

### isNodeAncestor

    public boolean isNodeAncestor(TreeNode anotherNode)

  Returns true if anotherNode is an ancestor of this node -- if it is this node, this node's parent, or an ancestor of this node's parent. (Note that a node is considered an ancestor of itself.) If anotherNode is null, this method returns false. This operation is at worst O(h) where h is the distance from the root to this node.

  Parameters:
    `anotherNode` - node to test as an ancestor of this node
  Returns:
    true if this node is a descendant of anotherNode.

### isNodeDescendant

    public boolean isNodeDescendant(TreeNode anotherNode)

  Returns true if anotherNode is a descendant of this node -- if it is this node, one of this node's children, or a descendant of one of this node's children. Note that a node is considered a descendant of itself. If anotherNode is null, returns false. This operation is at worst O(h) where h is the distance from the root to anotherNode.

  Parameters:
    `anotherNode` - node to test as a descendant of this node
  Returns:
    true if this node is an ancestor of anotherNode.

### getDepth

    public int getDepth()

  Returns the depth of the tree rooted at this node -- the longest distance from this node to a leaf. If this node has no children, returns 0. This operation is much more expensive than getLevel() because it must effectively traverse the entire tree rooted at this node.

  Returns:
    the depth of the tree whose root is this node.

### getLevel

    public int getLevel()

  Returns the number of levels above this node -- the distance from the root to this node. If this node is the root, returns 0.

  Returns:
    the number of levels above this node.

### getPath

    public TreeNode[] getPath()

  Returns the path from the root, to get to this node. The last element in the path is this node.

  Returns:
    an array of TreeNode objects giving the path, where the first element in the path is the root and the last element is this node.

### getUserObjectPath

    public java.lang.Object[] getUserObjectPath()

  Returns the user object path, from the root, to get to this node. If some of the TreeNodes in the path have null user objects, the returned path will contain nulls.

### getRoot

    public TreeNode getRoot()

  Returns the root of the tree that contains this node. The root is the ancestor with a null parent.

  Returns:
    the root of the tree that contains this node

### isRoot

    public boolean isRoot()

  Returns true if this node is the root of the tree. The root is the only node in the tree with a null parent; every tree has exactly one root.

  Returns:
    true if this node is the root of its tree

### preorderEnumeration

    public java.util.Enumeration preorderEnumeration()

  Creates and returns an enumeration that traverses the subtree rooted at this node in preorder. The first node returned by the enumeration's nextElement() method is this node.

  Modifying the tree by inserting, removing, or moving a node invalidates any enumerations created before the modification.

  Returns:
    an enumeration for traversing the tree in preorder

### postorderEnumeration

    public java.util.Enumeration postorderEnumeration()

  Creates and returns an enumeration that traverses the subtree rooted at this node in postorder. The first node returned by the enumeration's nextElement() method is the leftmost leaf. This is the same as a depth-first traversal.

  Modifying the tree by inserting, removing, or moving a node invalidates any enumerations created before the modification.

### isNodeChild

    public boolean isNodeChild(TreeNode aNode)

  Returns true if aNode is a child of this node. If aNode is null, this method returns false.

  Returns:
    true if aNode is a child of this node; false if aNode is null

### getFirstChild

    public TreeNode getFirstChild()

  Returns this node's first child. If this node has no children, throws NoSuchElementException.

  Returns:
    the first child of this node
  Throws:
    `java.util.NoSuchElementException` - if this node has no children

### getLastChild

    public TreeNode getLastChild()

  Returns this node's last child. If this node has no children, throws NoSuchElementException.

  Returns:
    the last child of this node
  Throws:
    `java.util.NoSuchElementException` - if this node has no children

### getChildAfter

    public TreeNode getChildAfter(TreeNode aChild)

  Returns the child in this node's child array that immediately follows aChild, which must be a child of this node. If aChild is the last child, returns null. This method performs a linear search of this node's children for aChild and is O(n) where n is the number of children; to traverse the entire array of children, use an enumeration instead.

  Returns:
    the child of this node that immediately follows aChild
  Throws:
    `java.lang.IllegalArgumentException` - - if aChild is null or is not a child of this node

### getChildBefore

    public TreeNode getChildBefore(TreeNode aChild)

  Returns the child in this node's child array that immediately precedes aChild, which must be a child of this node. If aChild is the first child, returns null. This method performs a linear search of this node's children for aChild and is O(n) where n is the number of children.

  Returns:
    the child of this node that immediately precedes aChild.
  Throws:
    `java.lang.IllegalArgumentException` - - if aChild is null or is not a child of this node

### isLeaf

    public boolean isLeaf()

  Returns true if this node has no children. To distinguish between nodes that have no children and nodes that cannot have children (e.g. to distinguish files from empty directories), use this method in conjunction with getAllowsChildren

  Specified by:
    `isLeaf` in interface `TreeNode`
  Returns:
    true if this node has no children.

### getFirstLeaf

    public DefaultMutableTreeNode getFirstLeaf()

  Finds and returns the first leaf that is a descendant of this node -- either this node or its first child's first leaf. Returns this node if it is a leaf.

  Returns:
    the first leaf in the subtree rooted at this node.

### getLastLeaf

    public DefaultMutableTreeNode getLastLeaf()

  Finds and returns the last leaf that is a descendant of this node -- either this node or its last child's last leaf. Returns this node if it is a leaf.

  Returns:
    the last leaf in the subtree rooted at this node

### getNextLeaf

    public DefaultMutableTreeNode getNextLeaf()

  Returns the leaf after this node or null if this node is the last leaf in the tree.

  In this implementation of the MutableNode interface, this operation is very inefficient. In order to determine the next node, this method first performs a linear search in the parent's child-list in order to find the current node.

  That implementation makes the operation suitable for short traversals from a known position. But to traverse all of the leaves in the tree, you should use depthFirstEnumeration to enumerate the nodes in the tree and use isLeaf on each node to determine which are leaves.

  Returns:
    returns the next leaf past this node

### getPreviousLeaf

    public DefaultMutableTreeNode getPreviousLeaf()

  Returns the leaf before this node or null if this node is the first leaf in the tree. In this implementation of the MutableNode interface, this operation is very inefficient. In order to determine the previous node, this method first performs a linear search in the parent's child-list in order to find the current node. That implementation makes the operation suitable for short traversals from a known position. But to traverse all of the leaves in the tree, you should use depthFirstEnumeration to enumerate the nodes in the tree and use isLeaf on each node to determine which are leaves.

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD