Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.wicket.util.file; import java.io.IOException; import java.net.URI; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.apache.wicket.util.lang.Bytes; /** * This folder subclass provides some type safety and extensibility for "files" that hold other * files. * * @author Jonathan Locke */ public class Folder extends File { /** * Filter for files * * @author Jonathan Locke */ public static interface FileFilter { /** * File filter that matches all files */ public static FileFilter ALL_FILES = new FileFilter() { @Override public boolean accept(final File file) { return true; } }; /** * @param file * The file to test * @return True if the file should be accepted */ public boolean accept(File file); } /** * Filter for folders * * @author Jonathan Locke */ public static interface FolderFilter { /** * @param folder * The folder to test * @return True if the file should be accepted */ public boolean accept(Folder folder); } private static final long serialVersionUID = 1L; /** * Constructor. * * @param parent * parent * @param child * child */ public Folder(final Folder parent, final String child) { super(parent, child); } /** * Construct. * * @param file * File */ public Folder(final java.io.File file) { this(file.getPath()); } /** * Constructor. * * @param pathname * path name */ public Folder(final String pathname) { super(pathname); } /** * Constructor. * * @param parent * parent * @param child * child */ public Folder(final String parent, final String child) { super(parent, child); } /** * Constructor. * * @param uri * folder uri */ public Folder(final URI uri) { super(uri); } /** * Does a mkdirs() on this folder if it does not exist. If the folder cannot be created, an * IOException is thrown. * * @throws IOException * Thrown if folder cannot be created */ public void ensureExists() throws IOException { if (!exists() && !mkdirs()) { throw new IOException("Unable to create folder " + this); } } /** * @param name * Name of child folder * @return Child file object */ public Folder folder(final String name) { return new Folder(this, name); } /** * @return Disk space free on the partition where this folder lives */ public Bytes freeDiskSpace() { return Bytes.bytes(super.getFreeSpace()); } /** * @return Files in this folder */ public File[] getFiles() { return getFiles(FileFilter.ALL_FILES); } /** * @return All files nested within this folder */ public File[] getNestedFiles() { return getNestedFiles(FileFilter.ALL_FILES); } /** * Gets files in this folder matching a given filter recursively. * * @param filter * The filter * @return The list of files */ public File[] getNestedFiles(final FileFilter filter) { final List<File> files = new ArrayList<>(); files.addAll(Arrays.asList(getFiles(filter))); final Folder[] folders = getFolders(); for (Folder folder : folders) { files.addAll(Arrays.asList(folder.getNestedFiles(filter))); } return files.toArray(new File[files.size()]); } /** * @param filter * File filter * @return Files */ public File[] getFiles(final FileFilter filter) { // Get list of java.io files final java.io.File[] files = listFiles(new java.io.FileFilter() { /** * @see java.io.FileFilter#accept(java.io.File) */ @Override public boolean accept(final java.io.File file) { return file.isFile() && filter.accept(new File(file)); } }); // Convert java.io files to org.apache.wicket files if (files != null) { final File[] wicketFiles = new File[files.length]; for (int i = 0; i < files.length; i++) { wicketFiles[i] = new File(files[i]); } return wicketFiles; } return new File[0]; } /** * Gets all folders in this folder, except "." and ".." * * @return Folders */ public Folder[] getFolders() { return getFolders(new FolderFilter() { @Override public boolean accept(final Folder folder) { final String name = folder.getName(); return !name.equals(".") && !name.equals(".."); } }); } /** * @param filter * Folder filter * @return Folders */ public Folder[] getFolders(final FolderFilter filter) { // Get java io files that are directories matching the filter final java.io.File[] files = listFiles(new java.io.FileFilter() { /** * @see java.io.FileFilter#accept(java.io.File) */ @Override public boolean accept(final java.io.File file) { return file.isDirectory() && filter.accept(new Folder(file.getPath())); } }); // Convert if (files != null) { final Folder[] wicketFolders = new Folder[files.length]; for (int i = 0; i < files.length; i++) { wicketFolders[i] = new Folder(files[i]); } return wicketFolders; } return new Folder[0]; } /** * Removes this folder and everything in it, recursively. A best effort is made to remove nested * folders and files in depth-first order. * * @return True if the folder was successfully removed */ @Override public boolean remove() { return remove(this); } /** * Removes all the files in this folder. * * @return True if any files were successfully removed */ public boolean removeFiles() { final File[] files = getFiles(); boolean success = true; for (File file : files) { success = file.remove() && success; } return success; } /** * Removes everything in the given folder and then the folder itself. * * @param folder * The folder * @return True if the folder was successfully removed */ private boolean remove(final Folder folder) { final Folder[] folders = getFolders(); boolean success = true; for (Folder subfolder : folders) { success = subfolder.remove() && success; } success = removeFiles() && success; return folder.delete() && success; } }