< prev index next >

src/java.desktop/share/classes/javax/swing/tree/DefaultMutableTreeNode.java

Print this page

        

*** 30,62 **** import java.io.*; import java.util.*; /** ! * A <code>DefaultMutableTreeNode</code> 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 * 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 * 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 --- 30,62 ---- import java.io.*; import java.util.*; /** ! * 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} 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} 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,86 **** * 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&trade; ! * has been added to the <code>java.beans</code> package. * Please see {@link java.beans.XMLEncoder}. * * @see MutableTreeNode * * @author Rob Davis --- 76,86 ---- * 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&trade; ! * has been added to the {@code java.beans} package. * Please see {@link java.beans.XMLEncoder}. * * @see MutableTreeNode * * @author Rob Davis
*** 151,173 **** // // Primitives // /** ! * Removes <code>newChild</code> 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 * 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 * @exception IllegalArgumentException if ! * <code>newChild</code> is null or is an * ancestor of this node * @exception IllegalStateException if this node does not allow * children * @see #isNodeDescendant */ --- 151,173 ---- // // Primitives // /** ! * 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 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} is out of bounds * @exception IllegalArgumentException if ! * {@code newChild} is null or is an * ancestor of this node * @exception IllegalStateException if this node does not allow * children * @see #isNodeDescendant */
*** 193,219 **** } /** * 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>. * * @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 */ 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 * change the parent's child array. This method is called from ! * <code>insert()</code> and <code>remove()</code> to * reassign a child's parent, it should not be messaged from anywhere * else. * * @param newParent this node's new parent */ --- 193,219 ---- } /** * 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}. * * @param childIndex the index in this node's child array * of the child to remove * @exception ArrayIndexOutOfBoundsException if ! * {@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} but does not * change the parent's child array. This method is called from ! * {@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,243 **** /** * 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> * 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) { --- 233,243 ---- /** * 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} * 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,277 **** } /** * 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) * 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> * 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 * a child of this node */ public int getIndex(TreeNode aChild) { if (aChild == null) { throw new IllegalArgumentException("argument is null"); --- 260,277 ---- } /** * 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}. 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} * is null * @return an int giving the index of the node in this node's child ! * 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,308 **** } } /** * Determines whether or not this node is allowed to have children. ! * If <code>allows</code> 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 --- 298,308 ---- } } /** * Determines whether or not this node is allowed to have children. ! * 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,334 **** public boolean getAllowsChildren() { return allowsChildren; } /** ! * Sets the user object for this node to <code>userObject</code>. * * @param userObject the Object that constitutes this node's * user-specified data * @see #getUserObject * @see #toString --- 324,334 ---- public boolean getAllowsChildren() { return allowsChildren; } /** ! * 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,378 **** parent.remove(this); } } /** ! * Removes <code>aChild</code> 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> * is null or is not a child of this node */ public void remove(MutableTreeNode aChild) { if (aChild == null) { throw new IllegalArgumentException("argument is null"); --- 364,378 ---- parent.remove(this); } } /** ! * 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} * 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,408 **** remove(i); } } /** ! * Removes <code>newChild</code> 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> * is null * @exception IllegalStateException if this node does not allow * children */ public void add(MutableTreeNode newChild) { --- 393,408 ---- remove(i); } } /** ! * 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} * is null * @exception IllegalStateException if this node does not allow * children */ public void add(MutableTreeNode newChild) {
*** 417,437 **** // // Tree Queries // /** ! * Returns true if <code>anotherNode</code> 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 * 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> */ public boolean isNodeAncestor(TreeNode anotherNode) { if (anotherNode == null) { return false; } --- 417,437 ---- // // Tree Queries // /** ! * 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} 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} */ public boolean isNodeAncestor(TreeNode anotherNode) { if (anotherNode == null) { return false; }
*** 446,484 **** return false; } /** ! * Returns true if <code>anotherNode</code> 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 * false. This operation is at worst O(h) where h is the distance from the ! * root to <code>anotherNode</code>. * * @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> */ 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 null, if no such ancestor exists -- if this node and ! * <code>aNode</code> are in different trees or if <code>aNode</code> 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>, * or null if none */ public TreeNode getSharedAncestor(DefaultMutableTreeNode aNode) { if (aNode == this) { return this; --- 446,484 ---- return false; } /** ! * 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} is null, returns * false. This operation is at worst O(h) where h is the distance from the ! * 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} */ 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}. * Returns null, if no such ancestor exists -- if this node and ! * {@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}, * or null if none */ public TreeNode getSharedAncestor(DefaultMutableTreeNode aNode) { if (aNode == this) { return this;
*** 529,557 **** 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. * * @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 */ 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 * tree rooted at this node. * * @see #getLevel * @return the depth of the tree whose root is this node */ --- 529,557 ---- return 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} 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()} 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,733 **** } /** * 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 * 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 --- 723,733 ---- } /** * Returns the node that precedes this node in a preorder traversal of ! * 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,765 **** } /** * 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> * * Modifying the tree by inserting, removing, or moving a node invalidates * any enumerations created before the modification. * * @see #postorderEnumeration --- 755,765 ---- } /** * 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()} 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,780 **** } /** * 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 * same as a depth-first traversal.<P> * * Modifying the tree by inserting, removing, or moving a node invalidates * any enumerations created before the modification. * --- 770,780 ---- } /** * 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()} 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,797 **** } /** * 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> * * Modifying the tree by inserting, removing, or moving a node invalidates * any enumerations created before the modification. * * @see #depthFirstEnumeration --- 787,797 ---- } /** * 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()} 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,812 **** } /** * 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. * 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. * --- 802,812 ---- } /** * 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()} 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,842 **** 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 * 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> * 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 * 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) { --- 818,842 ---- return postorderEnumeration(); } /** * Creates and returns an enumeration that follows the path from ! * {@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}, 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} 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,862 **** // // Child Queries // /** ! * Returns true if <code>aNode</code> is a child of this node. If ! * <code>aNode</code> 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 */ public boolean isNodeChild(TreeNode aNode) { boolean retval; if (aNode == null) { --- 847,862 ---- // // Child Queries // /** ! * 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} is a child of this node; false if ! * {@code aNode} is null */ public boolean isNodeChild(TreeNode aNode) { boolean retval; if (aNode == null) {
*** 903,924 **** } /** * 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 * 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 * 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 * null or is not a child of this node * @return the child of this node that immediately follows ! * <code>aChild</code> */ public TreeNode getChildAfter(TreeNode aChild) { if (aChild == null) { throw new IllegalArgumentException("argument is null"); } --- 903,924 ---- } /** * Returns the child in this node's child array that immediately ! * 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} 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} is * null or is not a child of this node * @return the child of this node that immediately follows ! * {@code aChild} */ public TreeNode getChildAfter(TreeNode aChild) { if (aChild == null) { throw new IllegalArgumentException("argument is null"); }
*** 937,956 **** } /** * 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> * 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 * or is not a child of this node * @return the child of this node that immediately precedes ! * <code>aChild</code> */ public TreeNode getChildBefore(TreeNode aChild) { if (aChild == null) { throw new IllegalArgumentException("argument is null"); } --- 937,956 ---- } /** * Returns the child in this node's child array that immediately ! * 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} is null * or is not a child of this node * @return the child of this node that immediately precedes ! * {@code aChild} */ public TreeNode getChildBefore(TreeNode aChild) { if (aChild == null) { throw new IllegalArgumentException("argument is null"); }
*** 973,988 **** // Sibling Queries // /** ! * Returns true if <code>anotherNode</code> 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. * * @param anotherNode node to test as sibling of this node ! * @return true if <code>anotherNode</code> is a sibling of this node */ public boolean isNodeSibling(TreeNode anotherNode) { boolean retval; if (anotherNode == null) { --- 973,988 ---- // Sibling Queries // /** ! * 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} is null, returns false. * * @param anotherNode node to test as 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,1014 **** /** * 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>). * * @return the number of siblings of this node */ public int getSiblingCount() { TreeNode myParent = getParent(); --- 1004,1014 ---- /** * 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}). * * @return the number of siblings of this node */ public int getSiblingCount() { TreeNode myParent = getParent();
*** 1084,1094 **** /** * 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> * * @see #getAllowsChildren * @return true if this node has no children */ public boolean isLeaf() { --- 1084,1094 ---- /** * 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} * * @see #getAllowsChildren * @return true if this node has no children */ public boolean isLeaf() {
*** 1138,1156 **** /** * 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, * 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> * on each node to determine which are leaves. * * @see #depthFirstEnumeration * @see #isLeaf * @return returns the next leaf past this node --- 1138,1156 ---- /** * 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} 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} ! * 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,1191 **** /** * 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, * 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> * on each node to determine which are leaves. * * @see #depthFirstEnumeration * @see #isLeaf * @return returns the leaf before this node --- 1173,1191 ---- /** * 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} 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} ! * 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,1216 **** } /** * 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) * where n is the number of descendants of this node. * * @see #isNodeAncestor * @return the number of leaves beneath this node */ --- 1206,1216 ---- } /** * Returns the total number of leaves that are descendants of this node. ! * 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,1248 **** // // Overrides // /** ! * Returns the result of sending <code>toString()</code> to this node's * user object, or the empty string if the node has no user object. * * @see #getUserObject */ public String toString() { --- 1238,1248 ---- // // Overrides // /** ! * 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 >