View Javadoc

1   /**
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.creadur.whisker.scan;
20  
21  import java.io.File;
22  import java.io.IOException;
23  import java.util.ArrayList;
24  import java.util.Collection;
25  import java.util.LinkedList;
26  import java.util.Queue;
27  import java.util.Set;
28  import java.util.TreeSet;
29  
30  /**
31   * Scans directories for resources, within a file system.
32   */
33  public class FromFileSystem {
34  
35      /**
36       * Base constructor.
37       */
38      public FromFileSystem() {
39          super();
40      }
41  
42      /**
43       * Builds description based on given directory.
44       * @param base names the base directory, not null
45       * @return collected directories within the base, not null
46       * @throws IOException when the scanning fails
47       */
48      public Collection<Directory> withBase(final String base)
49              throws IOException {
50          return new Builder(base).build();
51      }
52  
53      /**
54       * Builds a description of a file system.
55       */
56      private final static class Builder {
57          /** Initial capacity for the backing array. */
58          private static final int DEFAULT_INITIAL_CAPACITY = 64;
59          /** Directory scanning base. */
60          private final File base;
61          /** Directories scanned. */
62          private final Set<Directory> directories;
63          /** Queues work not yet complete. */
64          private final Queue<Work> workInProgress;
65          /** Stores work done. */
66          private final Collection<Work> workDone;
67  
68          /**
69           * Constructs a builder with given base
70           * (and default backing array).
71           * @param base not null
72           */
73          public Builder(final String base) {
74              this(base, DEFAULT_INITIAL_CAPACITY);
75          }
76  
77          /**
78           * Constructs a builder.
79           * @param base not null
80           * @param initialCapacity initial capacity for backing array
81           */
82          public Builder(final String base, final int initialCapacity) {
83              super();
84              this.base = new File(base);
85              directories = new TreeSet<Directory>();
86              workInProgress = new LinkedList<Work>();
87              workDone = new ArrayList<Work>(initialCapacity);
88          }
89  
90          /**
91           * Builds directories.
92           * @return not null
93           * @throws IOException when scanning fails
94           */
95          public Collection<Directory> build() throws IOException {
96              put(base).andWork().untilDone();
97              return directories;
98          }
99  
100         /**
101          * Waiting until work done.
102          */
103         private void untilDone() { }
104 
105         /**
106          * Adds file work to the queue.
107          * @param file not null
108          * @return this, not null
109          */
110         private Builder put(final File file) {
111             return put(new Work(file));
112         }
113 
114         /**
115          * Queues work.
116          * @param work not null
117          * @return this, not null
118          */
119         private Builder put(final Work work) {
120             if (work != null) {
121                 if (workDone.contains(work)) {
122                     alreadyDone(work);
123                 } else {
124                     this.workInProgress.add(work);
125                 }
126             }
127             return this;
128         }
129 
130         /**
131          * Notes that work has already been done.
132          * @param work not null
133          */
134         private void alreadyDone(final Work work) {
135             System.out.println("Already done " + work);
136         }
137 
138         /**
139          * Starts work.
140          * @return this, not null
141          */
142         private Builder andWork() {
143             while (!workInProgress.isEmpty()) {
144                 workDone.add(workOn(workInProgress.poll()));
145             }
146             return this;
147         }
148 
149         /**
150          * Performs work.
151          * @param next not null
152          * @return the work done, not null
153          */
154         private Work workOn(final Work next) {
155             for (final String name: next.contents()) {
156                 put(next.whenDirectory(name));
157             }
158             directories.add(next.build());
159             return next;
160         }
161 
162         /**
163          * Computes the contents of a directory.
164          */
165         private static final class Work {
166             /** Represents base directory. */
167             private static final String BASE_DIRECTORY = ".";
168             /** Names the directory. */
169             private final String name;
170             /** The directory worked on. */
171             private final File file;
172 
173             /**
174              * Constructs work.
175              * @param file not null
176              */
177             public Work(final File file) {
178                 this(BASE_DIRECTORY, file);
179             }
180 
181             /**
182              * Constructs work.
183              * @param name not null
184              * @param file not null
185              */
186             public Work(final String name, final File file) {
187                 if (!file.exists()) {
188                     throw new IllegalArgumentException(
189                             "Expected '" + file.getAbsolutePath() + "' to exist");
190                 }
191                 if (!file.isDirectory()) {
192                     throw new IllegalArgumentException(
193                             "Expected '" + file.getAbsolutePath() + "' to be a directory");
194                 }
195                 this.name = name;
196                 this.file = file;
197             }
198 
199             /**
200              * Gets the contents of the work directory.
201              * @return not null
202              */
203             public String[] contents() {
204                 final String[] contents = file.list();
205                 if (contents == null) {
206                     throw new IllegalArgumentException("Cannot list content of " + file);
207                 }
208                 return contents;
209             }
210 
211             /**
212              * Builds a directory.
213              * @return not null
214              */
215             public Directory build() {
216                 final Directory result = new Directory().setName(name);
217                 for (final String name : contents()) {
218                     if (isResource(name)) {
219                         result.addResource(name);
220                     }
221                 }
222                 return result;
223             }
224 
225             /**
226              * Is the named file a resource?
227              * @param name not null
228              * @return true when the named file is a resource,
229              * false otherwise
230              */
231             private boolean isResource(final String name) {
232                 return !isDirectory(name);
233             }
234 
235             /**
236              * Is the named file a directory?
237              * @param name not null
238              * @return true when the named file is a directory,
239              * false otherwise
240              */
241             private boolean isDirectory(final String name) {
242                 return file(name).isDirectory();
243             }
244 
245             /**
246              * Creates new work.
247              * @param name not null
248              * @return work for the named directory,
249              * or null when the resource named is not a directory
250              */
251             public Work whenDirectory(final String name) {
252                 final File file = file(name);
253                 final Work result;
254                 if (file.isDirectory()) {
255                     result = new Work(path(name), file);
256                 } else {
257                     result = null;
258                 }
259                 return result;
260             }
261 
262             /**
263              * Converts a name to a path relative to base.
264              * @param name not null
265              * @return not null
266              */
267             private String path(final String name) {
268                 final String result;
269                 if (isBaseDirectory()) {
270                     result = name;
271                 } else {
272                     result = this.name + "/" + name;
273                 }
274                 return result;
275             }
276 
277             /**
278              * This the work done in the base directory.
279              * @return true when this is the base, false otherwise.
280              */
281             private boolean isBaseDirectory() {
282                 return BASE_DIRECTORY.equals(this.name);
283             }
284 
285             /**
286              * Creates a file.
287              * @param name not null
288              * @return file with given name
289              */
290             private File file(String name) {
291                 return new File(this.file, name);
292             }
293 
294             /**
295              * Computes some suitable hash.
296              * @return a hash code
297              * @see java.lang.Object#hashCode()
298              */
299             @Override
300             public int hashCode() {
301                 final int prime = 31;
302                 int result = 1;
303                 result = prime * result
304                         + ((file == null) ? 0 : file.hashCode());
305                 result = prime * result
306                         + ((name == null) ? 0 : name.hashCode());
307                 return result;
308             }
309 
310             /**
311              * Equal when both name and file are equal.
312              * @param obj possibly null
313              * @return true when equal, false otherwise
314              * @see java.lang.Object#equals(java.lang.Object)
315              */
316             @Override
317             public boolean equals(final Object obj) {
318                 if (this == obj) {
319                     return true;
320                 }
321                 if (obj == null) {
322                     return false;
323                 }
324                 if (getClass() != obj.getClass()) {
325                     return false;
326                 }
327                 final Work other = (Work) obj;
328                 if (file == null) {
329                     if (other.file != null)
330                         return false;
331                 } else if (!file.equals(other.file))
332                     return false;
333                 if (name == null) {
334                     if (other.name != null) {
335                         return false;
336                     }
337                 } else if (!name.equals(other.name)) {
338                     return false;
339                 }
340                 return true;
341             }
342 
343             /**
344              * Something suitable for logging.
345              * @return not null
346              * @see java.lang.Object#toString()
347              */
348             @Override
349             public String toString() {
350                 return "Work [name=" + name + ", file=" + file + "]";
351             }
352         }
353     }
354 }