Coverage Report

##### Coverage Report - org.melati.util.ChildrenDrivenMutableTree

Classes in this File | Line Coverage | Branch Coverage | Complexity
ChildrenDrivenMutableTree |
0% | 0/37
0% | 0/14
| 1.9090909090909092;1.909

1 |  |
     /*
2 |  |
      * $Source: /usr/cvsroot/melati/melati/src/site/resources/withWebmacro/org.melati.util.ChildrenDrivenMutableTree.html,v $
3 |  |
      * $Revision: 1.1 $
4 |  |
      *
5 |  |
      * Copyright (C) 2001 Myles Chippendale
6 |  |
      *
7 |  |
      * Part of Melati (http://melati.org), a framework for the rapid
8 |  |
      * development of clean, maintainable web applications.
9 |  |
      *
10 |  |
      * Melati is free software; Permission is granted to copy, distribute
11 |  |
      * and/or modify this software under the terms either:
12 |  |
      *
13 |  |
      * a) the GNU General Public License as published by the Free Software
14 |  |
      *    Foundation; either version 2 of the License, or (at your option)
15 |  |
      *    any later version,
16 |  |
      *
17 |  |
      *    or
18 |  |
      *
19 |  |
      * b) any version of the Melati Software License, as published
20 |  |
      *    at http://melati.org
21 |  |
      *
22 |  |
      * You should have received a copy of the GNU General Public License and
23 |  |
      * the Melati Software License along with this program;
24 |  |
      * if not, write to the Free Software Foundation, Inc.,
25 |  |
      * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
26 |  |
      * GNU General Public License and visit http://melati.org to obtain the
27 |  |
      * Melati Software License.
28 |  |
      *
29 |  |
      * Feel free to contact the Developers of Melati (http://melati.org),
30 |  |
      * if you would like to work out a different arrangement than the options
31 |  |
      * outlined here.  It is our intention to allow Melati to be used by as
32 |  |
      * wide an audience as possible.
33 |  |
      *
34 |  |
      * This program is distributed in the hope that it will be useful,
35 |  |
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
36 |  |
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
37 |  |
      * GNU General Public License for more details.
38 |  |
      *
39 |  |
      * Contact details for copyright holder:
40 |  |
      *
41 |  |
      *     Myles Chippendale <mylesc At paneris.org>
42 |  |
      */
43 |  |
     package org.melati.util;
44 |  |
45 |  |
     import javax.swing.tree.DefaultMutableTreeNode;
46 |  |
     import java.util.Vector;
47 |  |
     import java.util.Enumeration;
48 |  |
     import org.melati.poem.Treeable;
49 |  |
50 |  |
     /**
51 |  |
      * A tree of <code>DefaultMutableTreeNode</code>s,
52 |  |
      * the <code>userObject</code>s of which
53 |  |
      * are {@link Treeable} objects which supply their own
54 |  |
      * <code>getChildren()</code> functions.
55 |  |
      * This is used to build the tree of
56 |  |
      * <code>DefaultMutableTreeNode</code>s.
57 |  |
      * <p>
58 |  |
      * It also allows you to search the subtree for a particular
59 |  |
      * {@link Treeable} object and returns the corresponding
60 |  |
      * <code>DefaultMutableTreeNode</code> object if one exists.
61 |  |
      *
62 |  |
      * @see DefaultMutableTreeNode
63 |  |
      *
64 |  |
      * @since 04/10/2000
65 |  |
      * @author Myles Chippendale
66 |  |
      **/
67 |  |
68 |  |
69 |  |
     public class ChildrenDrivenMutableTree {
70 |  |
71 |  |
         /**
72 |  |
          * An enumeration that is always empty. This is used when an enumeration
73 |  |
          * of a leaf node's children is requested.
74 |  |
          */
75 |  |
         @SuppressWarnings("unchecked") // FIXME we need our own empty enumeration
76 | 0 |
         public static final Enumeration EMPTY_ENUMERATION =
77 |  |
           DefaultMutableTreeNode.EMPTY_ENUMERATION;
78 |  |
79 |  |
         /** root node */
80 |  |
         protected DefaultMutableTreeNode root;
81 |  |
82 |  |
         /**
83 |  |
          * Constructor.
84 |  |
          */
85 |  |
         public ChildrenDrivenMutableTree() {
86 | 0 |
           this(null);
87 | 0 |
         }
88 |  |
89 |  |
         /**
90 |  |
          * Constructor.
91 |  |
          * @param userObject the root
92 |  |
          */
93 | 0 |
         public ChildrenDrivenMutableTree(Treeable userObject) {
94 | 0 |
           root = new DefaultMutableTreeNode(userObject);
95 | 0 |
           buildTree();
96 | 0 |
         }
97 |  |
98 |  |
         /**
99 |  |
          * Compute the children.
100 |  |
          */
101 |  |
         public void buildTree() {
102 | 0 |
           buildTree(computeChildren(root));
103 | 0 |
         }
104 |  |
105 |  |
         /**
106 |  |
          * Compute the children given the nodes.
107 |  |
          * @param nodes an Enumeration of nodes
108 |  |
          */
109 |  |
         public void buildTree(Enumeration<DefaultMutableTreeNode> nodes) {
110 | 0 |
           while (nodes.hasMoreElements())
111 | 0 |
             buildTree(computeChildren(nodes.nextElement()));
112 | 0 |
         }
113 |  |
114 |  |
         @SuppressWarnings("unchecked")
115 |  |
         private static Enumeration<DefaultMutableTreeNode> computeChildren(DefaultMutableTreeNode node) {
116 | 0 |
           if (node == null)
117 | 0 |
             return EMPTY_ENUMERATION;
118 | 0 |
           Treeable[] kids = ((Treeable)node.getUserObject()).getChildren();
119 | 0 |
           for(int i = 0; i<kids.length; i++) {
120 | 0 |
               node.add(new DefaultMutableTreeNode(kids[i]));
121 |  |
           }
122 | 0 |
           return node.children();
123 |  |
         }
124 |  |
125 |  |
126 |  |
         /**
127 |  |
          * Find a node in a tree.
128 |  |
          * @param search the node object
129 |  |
          * @return a tree node
130 |  |
          */
131 |  |
         @SuppressWarnings("unchecked")
132 |  |
         public DefaultMutableTreeNode getTreeNodeFor(Treeable search) {
133 |  |
134 | 0 |
             Vector<DefaultMutableTreeNode> agenda = new Vector<DefaultMutableTreeNode>();
135 | 0 |
             agenda.addElement(root);
136 |  |
137 | 0 |
             while (!agenda.isEmpty()) {
138 | 0 |
                 DefaultMutableTreeNode current =
139 |  |
                     agenda.firstElement();
140 | 0 |
                 if (current == null)
141 | 0 |
                   return null;
142 | 0 |
                 if (current.getUserObject() == search)
143 | 0 |
                   return current;
144 |  |
145 | 0 |
                 agenda.removeElementAt(0);
146 | 0 |
                 Enumeration<DefaultMutableTreeNode> kids = current.children();
147 | 0 |
                 while(kids.hasMoreElements()) {
148 | 0 |
                   agenda.addElement(kids.nextElement());
149 |  |
                 }
150 | 0 |
             }
151 | 0 |
             return null;
152 |  |
         }
153 |  |
154 |  |
         /**
155 |  |
          * @return the root
156 |  |
          */
157 |  |
         public DefaultMutableTreeNode getRoot() {
158 | 0 |
           return root;
159 |  |
         }
160 |  |
161 |  |
         /**
162 |  |
          * Return an enumeration of nodes in preorder, whatever
163 |  |
          * that means.
164 |  |
          * <p>
165 |  |
          * Root is first node. What is the difference
166 |  |
          * from breadth first?
167 |  |
          * @return the nodes
168 |  |
          */
169 |  |
         @SuppressWarnings("unchecked")
170 |  |
         public Enumeration preorderEnumeration() {
171 | 0 |
           return root.preorderEnumeration();
172 |  |
         }
173 |  |
174 |  |
         /**
175 |  |
          * Return an enumeration of nodes in postorder, whatever
176 |  |
          * that means.
177 |  |
          * <p>
178 |  |
          * Leftmost leaf is first. What is the difference
179 |  |
          * from depth first?
180 |  |
          * @return the nodes
181 |  |
          */
182 |  |
         @SuppressWarnings("unchecked")
183 |  |
         public Enumeration postorderEnumeration() {
184 | 0 |
           return root.postorderEnumeration();
185 |  |
         }
186 |  |
187 |  |
         /**
188 |  |
          * @return an enumeration of nodes in breadth first order.
189 |  |
          */
190 |  |
         @SuppressWarnings("unchecked")
191 |  |
         public Enumeration breadthFirstEnumeration() {
192 | 0 |
           return root.breadthFirstEnumeration();
193 |  |
         }
194 |  |
195 |  |
         /**
196 |  |
          * @return an enumeration of nodes in depth first order.
197 |  |
          */
198 |  |
         @SuppressWarnings("unchecked")
199 |  |
         public Enumeration depthFirstEnumeration() {
200 | 0 |
           return root.depthFirstEnumeration();
201 |  |
         }
202 |  |
     }