1 /*
2 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 /** Encapsulates a notion of a directory tree. Designed to allow fast
26 querying of full paths for unique filenames in the hierarchy. */
27
28 import java.io.*;
29 import java.util.*;
30
31 public class DirectoryTree {
32
33 /** The root of the read directoryTree */
34 private Node rootNode;
35
36 /** Subdirs to ignore; Vector of Strings */
37 private Vector subdirsToIgnore;
38
39 /** This maps file names to Lists of nodes. */
40 private Hashtable nameToNodeListTable;
41
42 /** Output "."'s as directories are read. Defaults to false. */
43 private boolean verbose;
44
45 public DirectoryTree() {
46 subdirsToIgnore = new Vector();
47 verbose = false;
48 }
49
50 public void addSubdirToIgnore(String subdir) {
51 subdirsToIgnore.add(subdir);
52 }
53
54 private class FileIterator implements Iterator {
55 private Vector nodes = new Vector();
56
57 public FileIterator(Node rootNode) {
58 if(rootNode == null) {
59 return;
60 }
61 nodes.add(rootNode);
62 prune();
63 }
64 public boolean hasNext() {
65 return nodes.size() > 0;
66 }
67 public Object next() {
68 Node last = (Node)nodes.remove(nodes.size() - 1);
69 prune();
70 return new File(last.getName());
71 }
72
73 public void remove() {
74 throw new RuntimeException();
75 }
76
77 private void prune() {
78 while (nodes.size() > 0) {
79 Node last = (Node)nodes.get(nodes.size() - 1);
80
81 if (last.isDirectory()) {
82 nodes.remove(nodes.size() - 1);
83 nodes.addAll(last.children);
84 } else {
85 // Is at file
86 return;
87 }
88 }
89 }
90 }
91
92 public Iterator getFileIterator() {
93 return new FileIterator(rootNode);
94 }
95
96 /** Output "."'s to System.out as directories are read. Defaults
97 to false. */
98 public void setVerbose(boolean newValue) {
99 verbose = newValue;
100 }
101
102 public boolean getVerbose() {
103 return verbose;
104 }
105
106 public String getRootNodeName() {
107 return rootNode.getName();
108 }
109
110 /** Takes an absolute path to the root directory of this
111 DirectoryTree. Throws IllegalArgumentException if the given
112 string represents a plain file or nonexistent directory. */
113
114 public void readDirectory(String baseDirectory)
115 throws IllegalArgumentException {
116 File root = new File(Util.normalize(baseDirectory));
117 if (!root.isDirectory()) {
118 return;
119 }
120 try {
121 root = root.getCanonicalFile();
122 }
123 catch (IOException e) {
124 throw new RuntimeException(e.toString());
125 }
126 rootNode = new Node(root);
127 readDirectory(rootNode, root);
128 }
129
130 /** Queries the DirectoryTree for a file or directory name. Takes
131 only the name of the file or directory itself (i.e., no parent
132 directory information should be in the passed name). Returns a
133 List of DirectoryTreeNodes specifying the full paths of all of
134 the files or directories of this name in the DirectoryTree.
135 Returns null if the directory tree has not been read from disk
136 yet or if the file was not found in the tree. */
137 public List findFile(String name) {
138 if (rootNode == null) {
139 return null;
140 }
141
142 if (nameToNodeListTable == null) {
143 nameToNodeListTable = new Hashtable();
144 try {
145 buildNameToNodeListTable(rootNode);
146 } catch (IOException e) {
147 e.printStackTrace();
148 return null;
149 }
150 }
151
152 return (List) nameToNodeListTable.get(name);
153 }
154
155 private void buildNameToNodeListTable(Node curNode)
156 throws IOException {
157 String fullName = curNode.getName();
158 String parent = curNode.getParent();
159 String separator = System.getProperty("file.separator");
160
161 if (parent != null) {
162 if (!fullName.startsWith(parent)) {
163 throw new RuntimeException(
164 "Internal error: parent of file name \"" + fullName +
165 "\" does not match file name \"" + parent + "\""
166 );
167 }
168
169 int len = parent.length();
170 if (!parent.endsWith(separator)) {
171 len += separator.length();
172 }
173
174 String fileName = fullName.substring(len);
175
176 if (fileName == null) {
177 throw new RuntimeException(
178 "Internal error: file name was empty"
179 );
180 }
181
182 List nodeList = (List) nameToNodeListTable.get(fileName);
183 if (nodeList == null) {
184 nodeList = new Vector();
185 nameToNodeListTable.put(fileName, nodeList);
186 }
187
188 nodeList.add(curNode);
189 } else {
190 if (curNode != rootNode) {
191 throw new RuntimeException(
192 "Internal error: parent of file + \"" + fullName + "\"" +
193 " was null"
194 );
195 }
196 }
197
198 if (curNode.isDirectory()) {
199 Iterator iter = curNode.getChildren();
200 if (iter != null) {
201 while (iter.hasNext()) {
202 buildNameToNodeListTable((Node) iter.next());
203 }
204 }
205 }
206 }
207
208 /** Reads all of the files in the given directory and adds them as
209 children of the directory tree node. Requires that the passed
210 node represents a directory. */
211
212 private void readDirectory(Node parentNode, File parentDir) {
213 File[] children = parentDir.listFiles();
214 if (children == null)
215 return;
216 if (verbose) {
217 System.out.print(".");
218 System.out.flush();
219 }
220 for (int i = 0; i < children.length; i++) {
221 File child = children[i];
222 children[i] = null;
223 boolean isDir = child.isDirectory();
224 boolean mustSkip = false;
225 if (isDir) {
226 for (Iterator iter = subdirsToIgnore.iterator();
227 iter.hasNext(); ) {
228 if (child.getName().equals((String) iter.next())) {
229 mustSkip = true;
230 break;
231 }
232 }
233 }
234 if (!mustSkip) {
235 Node childNode = new Node(child);
236 parentNode.addChild(childNode);
237 if (isDir) {
238 readDirectory(childNode, child);
239 }
240 }
241 }
242 }
243
244 private class Node implements DirectoryTreeNode {
245 private File file;
246 private Vector children;
247
248 /** file must be a canonical file */
249 Node(File file) {
250 this.file = file;
251 children = new Vector();
252 }
253
254 public boolean isFile() {
255 return file.isFile();
256 }
257
258 public boolean isDirectory() {
259 return file.isDirectory();
260 }
261
262 public String getName() {
263 return file.getPath();
264 }
265
266 public String getParent() {
267 return file.getParent();
268 }
269
270 public void addChild(Node n) {
271 children.add(n);
272 }
273
274 public Iterator getChildren() throws IllegalArgumentException {
275 return children.iterator();
276 }
277
278 public int getNumChildren() throws IllegalArgumentException {
279 return children.size();
280 }
281
282 public DirectoryTreeNode getChild(int i)
283 throws IllegalArgumentException, ArrayIndexOutOfBoundsException {
284 return (DirectoryTreeNode) children.get(i);
285 }
286 }
287 }