< prev index next >
src/java.desktop/share/classes/javax/swing/tree/DefaultMutableTreeNode.java
Print this page
@@ -30,33 +30,33 @@
import java.io.*;
import java.util.*;
/**
- * A <code>DefaultMutableTreeNode</code> is a general-purpose node in a tree data
+ * A {@code DefaultMutableTreeNode} is a general-purpose node in a tree data
* structure.
* For examples of using default mutable tree nodes, see
* <a
href="http://docs.oracle.com/javase/tutorial/uiswing/components/tree.html">How to Use Trees</a>
* in <em>The Java Tutorial.</em>
*
* <p>
*
* A tree node may have at most one parent and 0 or more children.
- * <code>DefaultMutableTreeNode</code> provides operations for examining and modifying a
+ * {@code 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.
* <p>
* This class provides enumerations for efficiently traversing a tree or
* subtree in various orders or for following the path between two nodes.
- * A <code>DefaultMutableTreeNode</code> may also hold a reference to a user object, the
- * use of which is left to the user. Asking a <code>DefaultMutableTreeNode</code> for its
- * string representation with <code>toString()</code> returns the string
+ * A {@code DefaultMutableTreeNode} may also hold a reference to a user object, the
+ * use of which is left to the user. Asking a {@code DefaultMutableTreeNode} for its
+ * string representation with {@code toString()} returns the string
* representation of its user object.
* <p>
* <b>This is not a thread safe class.</b>If you intend to use
* a DefaultMutableTreeNode (or a tree of TreeNodes) in more than one thread, you
* need to do your own synchronizing. A good convention to adopt is
@@ -76,11 +76,11 @@
* Serialized objects of this class will not be compatible with
* future Swing releases. The current serialization support is
* appropriate for short term storage or RMI between applications running
* the same version of Swing. As of 1.4, support for long term storage
* of all JavaBeans™
- * has been added to the <code>java.beans</code> package.
+ * has been added to the {@code java.beans} package.
* Please see {@link java.beans.XMLEncoder}.
*
* @see MutableTreeNode
*
* @author Rob Davis
@@ -151,23 +151,23 @@
//
// Primitives
//
/**
- * Removes <code>newChild</code> from its present parent (if it has a
+ * Removes {@code newChild} from its present parent (if it has a
* parent), sets the child's parent to this node, and then adds the child
- * to this node's child array at index <code>childIndex</code>.
- * <code>newChild</code> must not be null and must not be an ancestor of
+ * to this node's child array at index {@code childIndex}.
+ * {@code newChild} must not be null and must not be an ancestor of
* this node.
*
* @param newChild the MutableTreeNode to insert under this node
* @param childIndex the index in this node's child array
* where this node is to be inserted
* @exception ArrayIndexOutOfBoundsException if
- * <code>childIndex</code> is out of bounds
+ * {@code childIndex} is out of bounds
* @exception IllegalArgumentException if
- * <code>newChild</code> is null or is an
+ * {@code newChild} is null or is an
* ancestor of this node
* @exception IllegalStateException if this node does not allow
* children
* @see #isNodeDescendant
*/
@@ -193,27 +193,27 @@
}
/**
* Removes the child at the specified index from this node's children
* and sets that node's parent to null. The child node to remove
- * must be a <code>MutableTreeNode</code>.
+ * must be a {@code MutableTreeNode}.
*
* @param childIndex the index in this node's child array
* of the child to remove
* @exception ArrayIndexOutOfBoundsException if
- * <code>childIndex</code> is out of bounds
+ * {@code childIndex} is out of bounds
*/
public void remove(int childIndex) {
MutableTreeNode child = (MutableTreeNode)getChildAt(childIndex);
children.removeElementAt(childIndex);
child.setParent(null);
}
/**
- * Sets this node's parent to <code>newParent</code> but does not
+ * Sets this node's parent to {@code newParent} but does not
* change the parent's child array. This method is called from
- * <code>insert()</code> and <code>remove()</code> to
+ * {@code insert()} and {@code remove()} to
* reassign a child's parent, it should not be messaged from anywhere
* else.
*
* @param newParent this node's new parent
*/
@@ -233,11 +233,11 @@
/**
* Returns the child at the specified index in this node's child array.
*
* @param index an index into this node's child array
- * @exception ArrayIndexOutOfBoundsException if <code>index</code>
+ * @exception ArrayIndexOutOfBoundsException if {@code index}
* is out of bounds
* @return the TreeNode in this node's child array at the specified index
*/
public TreeNode getChildAt(int index) {
if (children == null) {
@@ -260,18 +260,18 @@
}
/**
* 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
- * <code>-1</code>. This method performs a linear search and is O(n)
+ * {@code -1}. This method performs a linear search and is O(n)
* where n is the number of children.
*
* @param aChild the TreeNode to search for among this node's children
- * @exception IllegalArgumentException if <code>aChild</code>
+ * @exception IllegalArgumentException if {@code aChild}
* is null
* @return an int giving the index of the node in this node's child
- * array, or <code>-1</code> if the specified node is a not
+ * array, or {@code -1} if the specified node is a not
* a child of this node
*/
public int getIndex(TreeNode aChild) {
if (aChild == null) {
throw new IllegalArgumentException("argument is null");
@@ -298,11 +298,11 @@
}
}
/**
* Determines whether or not this node is allowed to have children.
- * If <code>allows</code> is false, all of this node's children are
+ * If {@code allows} is false, all of this node's children are
* removed.
* <p>
* Note: By default, a node allows children.
*
* @param allows true if this node is allowed to have children
@@ -324,11 +324,11 @@
public boolean getAllowsChildren() {
return allowsChildren;
}
/**
- * Sets the user object for this node to <code>userObject</code>.
+ * Sets the user object for this node to {@code userObject}.
*
* @param userObject the Object that constitutes this node's
* user-specified data
* @see #getUserObject
* @see #toString
@@ -364,15 +364,15 @@
parent.remove(this);
}
}
/**
- * Removes <code>aChild</code> from this node's child array, giving it a
+ * Removes {@code aChild} from this node's child array, giving it a
* null parent.
*
* @param aChild a child of this node to remove
- * @exception IllegalArgumentException if <code>aChild</code>
+ * @exception IllegalArgumentException if {@code aChild}
* is null or is not a child of this node
*/
public void remove(MutableTreeNode aChild) {
if (aChild == null) {
throw new IllegalArgumentException("argument is null");
@@ -393,16 +393,16 @@
remove(i);
}
}
/**
- * Removes <code>newChild</code> from its parent and makes it a child of
+ * Removes {@code newChild} from its parent and makes it a child of
* this node by adding it to the end of this node's child array.
*
* @see #insert
* @param newChild node to add as a child of this node
- * @exception IllegalArgumentException if <code>newChild</code>
+ * @exception IllegalArgumentException if {@code newChild}
* is null
* @exception IllegalStateException if this node does not allow
* children
*/
public void add(MutableTreeNode newChild) {
@@ -417,21 +417,21 @@
//
// Tree Queries
//
/**
- * Returns true if <code>anotherNode</code> is an ancestor of this node
+ * Returns true if {@code 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 <code>anotherNode</code> is null, this method returns false. This
+ * If {@code 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.
*
* @see #isNodeDescendant
* @see #getSharedAncestor
* @param anotherNode node to test as an ancestor of this node
- * @return true if this node is a descendant of <code>anotherNode</code>
+ * @return true if this node is a descendant of {@code anotherNode}
*/
public boolean isNodeAncestor(TreeNode anotherNode) {
if (anotherNode == null) {
return false;
}
@@ -446,39 +446,39 @@
return false;
}
/**
- * Returns true if <code>anotherNode</code> is a descendant of this node
+ * Returns true if {@code 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 <code>anotherNode</code> is null, returns
+ * descendant of itself. If {@code anotherNode} is null, returns
* false. This operation is at worst O(h) where h is the distance from the
- * root to <code>anotherNode</code>.
+ * root to {@code anotherNode}.
*
* @see #isNodeAncestor
* @see #getSharedAncestor
* @param anotherNode node to test as descendant of this node
- * @return true if this node is an ancestor of <code>anotherNode</code>
+ * @return true if this node is an ancestor of {@code anotherNode}
*/
public boolean isNodeDescendant(DefaultMutableTreeNode anotherNode) {
if (anotherNode == null)
return false;
return anotherNode.isNodeAncestor(this);
}
/**
- * Returns the nearest common ancestor to this node and <code>aNode</code>.
+ * Returns the nearest common ancestor to this node and {@code aNode}.
* Returns null, if no such ancestor exists -- if this node and
- * <code>aNode</code> are in different trees or if <code>aNode</code> is
+ * {@code aNode} are in different trees or if {@code aNode} is
* null. A node is considered an ancestor of itself.
*
* @see #isNodeAncestor
* @see #isNodeDescendant
* @param aNode node to find common ancestor with
- * @return nearest ancestor common to this node and <code>aNode</code>,
+ * @return nearest ancestor common to this node and {@code aNode},
* or null if none
*/
public TreeNode getSharedAncestor(DefaultMutableTreeNode aNode) {
if (aNode == this) {
return this;
@@ -529,29 +529,29 @@
return null;
}
/**
- * Returns true if and only if <code>aNode</code> is in the same tree
- * as this node. Returns false if <code>aNode</code> is null.
+ * Returns true if and only if {@code aNode} is in the same tree
+ * as this node. Returns false if {@code aNode} is null.
*
* @param aNode node to find common ancestor with
* @see #getSharedAncestor
* @see #getRoot
- * @return true if <code>aNode</code> is in the same tree as this node;
- * false if <code>aNode</code> is null
+ * @return true if {@code aNode} is in the same tree as this node;
+ * false if {@code aNode} is null
*/
public boolean isNodeRelated(DefaultMutableTreeNode aNode) {
return (aNode != null) && (getRoot() == aNode.getRoot());
}
/**
* 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
- * <code>getLevel()</code> because it must effectively traverse the entire
+ * {@code getLevel()} because it must effectively traverse the entire
* tree rooted at this node.
*
* @see #getLevel
* @return the depth of the tree whose root is this node
*/
@@ -723,11 +723,11 @@
}
/**
* Returns the node that precedes this node in a preorder traversal of
- * this node's tree. Returns <code>null</code> if this node is the
+ * this node's tree. Returns {@code null} if this node is the
* first node of the traversal -- the root of the tree.
* This is an inefficient way to
* traverse the entire tree; use an enumeration, instead.
*
* @see #preorderEnumeration
@@ -755,11 +755,11 @@
}
/**
* Creates and returns an enumeration that traverses the subtree rooted at
* this node in preorder. The first node returned by the enumeration's
- * <code>nextElement()</code> method is this node.<P>
+ * {@code nextElement()} method is this node.<P>
*
* Modifying the tree by inserting, removing, or moving a node invalidates
* any enumerations created before the modification.
*
* @see #postorderEnumeration
@@ -770,11 +770,11 @@
}
/**
* Creates and returns an enumeration that traverses the subtree rooted at
* this node in postorder. The first node returned by the enumeration's
- * <code>nextElement()</code> method is the leftmost leaf. This is the
+ * {@code nextElement()} method is the leftmost leaf. This is the
* same as a depth-first traversal.<P>
*
* Modifying the tree by inserting, removing, or moving a node invalidates
* any enumerations created before the modification.
*
@@ -787,11 +787,11 @@
}
/**
* Creates and returns an enumeration that traverses the subtree rooted at
* this node in breadth-first order. The first node returned by the
- * enumeration's <code>nextElement()</code> method is this node.<P>
+ * enumeration's {@code nextElement()} method is this node.<P>
*
* Modifying the tree by inserting, removing, or moving a node invalidates
* any enumerations created before the modification.
*
* @see #depthFirstEnumeration
@@ -802,11 +802,11 @@
}
/**
* Creates and returns an enumeration that traverses the subtree rooted at
* this node in depth-first order. The first node returned by the
- * enumeration's <code>nextElement()</code> method is the leftmost leaf.
+ * enumeration's {@code nextElement()} method is the leftmost leaf.
* This is the same as a postorder traversal.<P>
*
* Modifying the tree by inserting, removing, or moving a node invalidates
* any enumerations created before the modification.
*
@@ -818,25 +818,25 @@
return postorderEnumeration();
}
/**
* Creates and returns an enumeration that follows the path from
- * <code>ancestor</code> to this node. The enumeration's
- * <code>nextElement()</code> method first returns <code>ancestor</code>,
- * then the child of <code>ancestor</code> that is an ancestor of this
+ * {@code ancestor} to this node. The enumeration's
+ * {@code nextElement()} method first returns {@code ancestor},
+ * then the child of {@code ancestor} that is an ancestor of this
* node, and so on, and finally returns this node. Creation of the
* enumeration is O(m) where m is the number of nodes between this node
- * and <code>ancestor</code>, inclusive. Each <code>nextElement()</code>
+ * and {@code ancestor}, inclusive. Each {@code nextElement()}
* message is O(1).<P>
*
* Modifying the tree by inserting, removing, or moving a node invalidates
* any enumerations created before the modification.
*
* @param ancestor the node to start enumeration from
* @see #isNodeAncestor
* @see #isNodeDescendant
- * @exception IllegalArgumentException if <code>ancestor</code> is
+ * @exception IllegalArgumentException if {@code ancestor} is
* not an ancestor of this node
* @return an enumeration for following the path from an ancestor of
* this node to this one
*/
public Enumeration<TreeNode> pathFromAncestorEnumeration(TreeNode ancestor) {
@@ -847,16 +847,16 @@
//
// Child Queries
//
/**
- * Returns true if <code>aNode</code> is a child of this node. If
- * <code>aNode</code> is null, this method returns false.
+ * Returns true if {@code aNode} is a child of this node. If
+ * {@code aNode} is null, this method returns false.
*
* @param aNode the node to determinate whether it is a child
- * @return true if <code>aNode</code> is a child of this node; false if
- * <code>aNode</code> is null
+ * @return true if {@code aNode} is a child of this node; false if
+ * {@code aNode} is null
*/
public boolean isNodeChild(TreeNode aNode) {
boolean retval;
if (aNode == null) {
@@ -903,22 +903,22 @@
}
/**
* Returns the child in this node's child array that immediately
- * follows <code>aChild</code>, which must be a child of this node. If
- * <code>aChild</code> is the last child, returns null. This method
+ * follows {@code aChild}, which must be a child of this node. If
+ * {@code aChild} is the last child, returns null. This method
* performs a linear search of this node's children for
- * <code>aChild</code> and is O(n) where n is the number of children; to
+ * {@code aChild} and is O(n) where n is the number of children; to
* traverse the entire array of children, use an enumeration instead.
*
* @param aChild the child node to look for next child after it
* @see #children
- * @exception IllegalArgumentException if <code>aChild</code> is
+ * @exception IllegalArgumentException if {@code aChild} is
* null or is not a child of this node
* @return the child of this node that immediately follows
- * <code>aChild</code>
+ * {@code aChild}
*/
public TreeNode getChildAfter(TreeNode aChild) {
if (aChild == null) {
throw new IllegalArgumentException("argument is null");
}
@@ -937,20 +937,20 @@
}
/**
* Returns the child in this node's child array that immediately
- * precedes <code>aChild</code>, which must be a child of this node. If
- * <code>aChild</code> is the first child, returns null. This method
- * performs a linear search of this node's children for <code>aChild</code>
+ * precedes {@code aChild}, which must be a child of this node. If
+ * {@code aChild} is the first child, returns null. This method
+ * performs a linear search of this node's children for {@code aChild}
* and is O(n) where n is the number of children.
*
* @param aChild the child node to look for previous child before it
- * @exception IllegalArgumentException if <code>aChild</code> is null
+ * @exception IllegalArgumentException if {@code aChild} is null
* or is not a child of this node
* @return the child of this node that immediately precedes
- * <code>aChild</code>
+ * {@code aChild}
*/
public TreeNode getChildBefore(TreeNode aChild) {
if (aChild == null) {
throw new IllegalArgumentException("argument is null");
}
@@ -973,16 +973,16 @@
// Sibling Queries
//
/**
- * Returns true if <code>anotherNode</code> is a sibling of (has the
+ * Returns true if {@code anotherNode} is a sibling of (has the
* same parent as) this node. A node is its own sibling. If
- * <code>anotherNode</code> is null, returns false.
+ * {@code anotherNode} is null, returns false.
*
* @param anotherNode node to test as sibling of this node
- * @return true if <code>anotherNode</code> is a sibling of this node
+ * @return true if {@code anotherNode} is a sibling of this node
*/
public boolean isNodeSibling(TreeNode anotherNode) {
boolean retval;
if (anotherNode == null) {
@@ -1004,11 +1004,11 @@
/**
* Returns the number of siblings of this node. A node is its own sibling
* (if it has no parent or no siblings, this method returns
- * <code>1</code>).
+ * {@code 1}).
*
* @return the number of siblings of this node
*/
public int getSiblingCount() {
TreeNode myParent = getParent();
@@ -1084,11 +1084,11 @@
/**
* Returns true if this node has no children. To distinguish between
* nodes that have no children and nodes that <i>cannot</i> have
* children (e.g. to distinguish files from empty directories), use this
- * method in conjunction with <code>getAllowsChildren</code>
+ * method in conjunction with {@code getAllowsChildren}
*
* @see #getAllowsChildren
* @return true if this node has no children
*/
public boolean isLeaf() {
@@ -1138,19 +1138,19 @@
/**
* Returns the leaf after this node or null if this node is the
* last leaf in the tree.
* <p>
- * In this implementation of the <code>MutableNode</code> interface,
+ * In this implementation of the {@code 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.
* <p>
* 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 <code>depthFirstEnumeration</code>
- * to enumerate the nodes in the tree and use <code>isLeaf</code>
+ * leaves in the tree, you should use {@code depthFirstEnumeration}
+ * to enumerate the nodes in the tree and use {@code isLeaf}
* on each node to determine which are leaves.
*
* @see #depthFirstEnumeration
* @see #isLeaf
* @return returns the next leaf past this node
@@ -1173,19 +1173,19 @@
/**
* Returns the leaf before this node or null if this node is the
* first leaf in the tree.
* <p>
- * In this implementation of the <code>MutableNode</code> interface,
+ * In this implementation of the {@code 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.
* <p>
* 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 <code>depthFirstEnumeration</code>
- * to enumerate the nodes in the tree and use <code>isLeaf</code>
+ * leaves in the tree, you should use {@code depthFirstEnumeration}
+ * to enumerate the nodes in the tree and use {@code isLeaf}
* on each node to determine which are leaves.
*
* @see #depthFirstEnumeration
* @see #isLeaf
* @return returns the leaf before this node
@@ -1206,11 +1206,11 @@
}
/**
* Returns the total number of leaves that are descendants of this node.
- * If this node is a leaf, returns <code>1</code>. This method is O(n)
+ * If this node is a leaf, returns {@code 1}. This method is O(n)
* where n is the number of descendants of this node.
*
* @see #isNodeAncestor
* @return the number of leaves beneath this node
*/
@@ -1238,11 +1238,11 @@
//
// Overrides
//
/**
- * Returns the result of sending <code>toString()</code> to this node's
+ * Returns the result of sending {@code toString()} to this node's
* user object, or the empty string if the node has no user object.
*
* @see #getUserObject
*/
public String toString() {
< prev index next >