KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > j2ee > ejbjarproject > ui > wizards > FileSearchUtility


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */
19
20 package org.netbeans.modules.j2ee.ejbjarproject.ui.wizards;
21
22 import java.io.BufferedReader JavaDoc;
23 import java.io.File JavaDoc;
24 import java.io.InputStreamReader JavaDoc;
25 import java.util.ArrayList JavaDoc;
26 import java.util.Arrays JavaDoc;
27 import java.util.Collection JavaDoc;
28 import java.util.Enumeration JavaDoc;
29 import java.util.List JavaDoc;
30 import java.util.StringTokenizer JavaDoc;
31 import org.openide.ErrorManager;
32 import org.openide.filesystems.FileObject;
33 import org.openide.filesystems.FileStateInvalidException;
34 import org.openide.filesystems.FileUtil;
35 import org.openide.util.Enumerations;
36
37 final class FileSearchUtility {
38     
39     /** Creates a new instance of FileSearchUtility. */
40     private FileSearchUtility() {
41     }
42         
43    /** Recursively enumerate all children of this folder to some specified depth.
44     * All direct children are listed; then children of direct subfolders; and so on.
45     *
46     * @param root the starting directory
47     * @param depth the search limit
48     * @param onlyWritables only recurse into wriable directories
49     * @return enumeration of type <code>FileObject</code>
50     */
51     static Enumeration JavaDoc getChildrenToDepth(final FileObject root, final int depth, final boolean onlyWritables) {
52         class WithChildren implements Enumerations.Processor {
53             private int rootDepth;
54             public WithChildren(final int rootDepth) {
55                 this.rootDepth = rootDepth;
56             }
57             public Object JavaDoc process(final Object JavaDoc obj, final Collection JavaDoc toAdd) {
58                 FileObject fo = (FileObject)obj;
59                 if (!onlyWritables || (onlyWritables && fo.canWrite())) {
60                     if (fo.isFolder() && (getDepth(fo) - rootDepth) < depth) {
61                         toAdd.addAll(Arrays.asList(fo.getChildren()));
62                     }
63                 }
64                 return fo;
65             }
66         }
67
68         return Enumerations.queue(
69             Enumerations.array(root.getChildren()),
70             new WithChildren(getDepth(root))
71         );
72     }
73
74     static FileObject[] guessJavaRoots(final FileObject dir) {
75         List JavaDoc foundRoots = new ArrayList JavaDoc();
76         if (null == dir)
77             return null;
78         Enumeration JavaDoc ch = FileSearchUtility.getChildrenToDepth(dir, 10, true); // .getChildren(true);
79 try {
80             // digging through 10 levels exhaustively is WAY TOO EXPENSIVE
81 while (ch.hasMoreElements () && foundRoots.isEmpty()) {
82                 FileObject f = (FileObject) ch.nextElement ();
83                 if (f.getExt().equals("java") && !f.isFolder()) { //NOI18N
84 String JavaDoc pckg = guessPackageName(f);
85                     String JavaDoc pkgPath = f.getParent().getPath();
86                     if (pckg != null && pkgPath.endsWith(pckg.replace('.', '/'))) {
87                         String JavaDoc rootName = pkgPath.substring(0, pkgPath.length() - pckg.length());
88                         FileObject fr = f.getFileSystem().findResource(rootName);
89                         if (!foundRoots.contains(fr)) {
90                             foundRoots.add(fr);
91                         }
92                     }
93                 }
94             }
95         } catch (FileStateInvalidException fsie) {
96             ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, fsie);
97         }
98         if (foundRoots.size() == 0) {
99             return null;
100         } else {
101             FileObject[] resultArr = new FileObject[foundRoots.size()];
102             for (int i = 0; i < foundRoots.size(); i++) {
103                 resultArr[i] = (FileObject) foundRoots.get(i);
104             }
105             return resultArr;
106         }
107     }
108     
109     static FileObject guessConfigFilesPath(final FileObject dir) {
110         if (null == dir)
111             return null;
112         Enumeration JavaDoc ch = FileSearchUtility.getChildrenToDepth(dir, 3, true); //getChildren(true);
113 try {
114             while (ch.hasMoreElements()) {
115                 FileObject f = (FileObject) ch.nextElement();
116                 if (f.getNameExt().equals("ejb-jar.xml")) { //NOI18N
117 String JavaDoc rootName = f.getParent().getPath();
118                     return f.getFileSystem().findResource(rootName);
119                 }
120             }
121         } catch (FileStateInvalidException fsie) {
122             ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, fsie);
123         }
124         return null;
125     }
126
127
128     static File JavaDoc[] guessJavaRootsAsFiles(final FileObject dir) {
129         FileObject[] rootsFOs = guessJavaRoots(dir);
130         if (rootsFOs == null) {
131             return new File JavaDoc[0];
132         }
133         File JavaDoc[] resultArr = new File JavaDoc[rootsFOs.length];
134         for (int i = 0; i < resultArr.length; i++) {
135             resultArr[i] = FileUtil.toFile(rootsFOs[i]);
136         }
137         return resultArr;
138     }
139
140     private static String JavaDoc guessPackageName(final FileObject f) {
141         java.io.Reader JavaDoc r = null;
142         try {
143             r = new BufferedReader JavaDoc(new InputStreamReader JavaDoc(f.getInputStream(), "utf-8")); // NOI18N
144 StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
145             final char[] buffer = new char[4096];
146             int len;
147
148             for (;;) {
149                 len = r.read(buffer);
150                 if (len == -1) { break; }
151                 sb.append(buffer, 0, len);
152             }
153             int idx = sb.indexOf("package"); // NOI18N
154 if (idx >= 0) {
155                 int idx2 = sb.indexOf(";", idx); // NOI18N
156 if (idx2 >= 0) {
157                     return sb.substring(idx + "package".length(), idx2).trim();
158                 }
159             }
160         } catch (java.io.IOException JavaDoc ioe) {
161             ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, ioe);
162         } finally {
163             try { if (r != null) { r.close(); }} catch (java.io.IOException JavaDoc ioe) { ; // ignore this
164 }
165         }
166         // AB: fix for #56160: assume the class is in the default package
167 return ""; // NOI18N
168 }
169
170     static FileObject guessLibrariesFolder(final FileObject dir) {
171         if (dir != null) {
172             FileObject lib = dir.getFileObject("lib"); //NOI18N
173 if (lib != null) {
174                 return lib;
175             }
176         }
177         Enumeration JavaDoc ch = FileSearchUtility.getChildrenToDepth(dir, 3, true);
178         while (ch.hasMoreElements()) {
179             FileObject f = (FileObject) ch.nextElement();
180             if (f.getExt().equals("jar")) { //NOI18N
181 return f.getParent();
182             }
183         }
184         return null;
185     }
186
187     private static int getDepth(final FileObject fo) {
188         String JavaDoc path = FileUtil.toFile(fo).getAbsolutePath();
189         StringTokenizer JavaDoc toker = new StringTokenizer JavaDoc(path, File.separator);
190         return toker.countTokens();
191     }
192 }
193
Popular Tags