1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.apache.commons.io;
18
19 import java.io.File;
20 import java.io.IOException;
21
22 /**
23 * Strategy for deleting files.
24 * <p>
25 * There is more than one way to delete a file.
26 * You may want to limit access to certain directories, to only delete
27 * directories if they are empty, or maybe to force deletion.
28 * <p>
29 * This class captures the strategy to use and is designed for user subclassing.
30 *
31 * @author Stephen Colebourne
32 * @version $Id: FileDeleteStrategy.java 453903 2006-10-07 13:47:06Z scolebourne $
33 * @since Commons IO 1.3
34 */
35 public class FileDeleteStrategy {
36
37 /**
38 * The singleton instance for normal file deletion, which does not permit
39 * the deletion of directories that are not empty.
40 */
41 public static final FileDeleteStrategy NORMAL = new FileDeleteStrategy("Normal");
42 /**
43 * The singleton instance for forced file deletion, which always deletes,
44 * even if the file represents a non-empty directory.
45 */
46 public static final FileDeleteStrategy FORCE = new ForceFileDeleteStrategy();
47
48 /** The name of the strategy. */
49 private final String name;
50
51 //-----------------------------------------------------------------------
52 /**
53 * Restricted constructor.
54 *
55 * @param name the name by which the strategy is known
56 */
57 protected FileDeleteStrategy(String name) {
58 this.name = name;
59 }
60
61 //-----------------------------------------------------------------------
62 /**
63 * Deletes the file object, which may be a file or a directory.
64 * All <code>IOException</code>s are caught and false returned instead.
65 * If the file does not exist or is null, true is returned.
66 * <p>
67 * Subclass writers should override {@link #doDelete(File)}, not this method.
68 *
69 * @param fileToDelete the file to delete, null returns true
70 * @return true if the file was deleted, or there was no such file
71 */
72 public boolean deleteQuietly(File fileToDelete) {
73 if (fileToDelete == null || fileToDelete.exists() == false) {
74 return true;
75 }
76 try {
77 return doDelete(fileToDelete);
78 } catch (IOException ex) {
79 return false;
80 }
81 }
82
83 /**
84 * Deletes the file object, which may be a file or a directory.
85 * If the file does not exist, the method just returns.
86 * <p>
87 * Subclass writers should override {@link #doDelete(File)}, not this method.
88 *
89 * @param fileToDelete the file to delete, not null
90 * @throws NullPointerException if the file is null
91 * @throws IOException if an error occurs during file deletion
92 */
93 public void delete(File fileToDelete) throws IOException {
94 if (fileToDelete.exists() && doDelete(fileToDelete) == false) {
95 throw new IOException("Deletion failed: " + fileToDelete);
96 }
97 }
98
99 /**
100 * Actually deletes the file object, which may be a file or a directory.
101 * <p>
102 * This method is designed for subclasses to override.
103 * The implementation may return either false or an <code>IOException</code>
104 * when deletion fails. The {@link #delete(File)} and {@link #deleteQuietly(File)}
105 * methods will handle either response appropriately.
106 * A check has been made to ensure that the file will exist.
107 * <p>
108 * This implementation uses {@link File#delete()}.
109 *
110 * @param fileToDelete the file to delete, exists, not null
111 * @return true if the file was deleteds
112 * @throws NullPointerException if the file is null
113 * @throws IOException if an error occurs during file deletion
114 */
115 protected boolean doDelete(File fileToDelete) throws IOException {
116 return fileToDelete.delete();
117 }
118
119 //-----------------------------------------------------------------------
120 /**
121 * Gets a string describing the delete strategy.
122 *
123 * @return a string describing the delete strategy
124 */
125 public String toString() {
126 return "FileDeleteStrategy[" + name + "]";
127 }
128
129 //-----------------------------------------------------------------------
130 /**
131 * Force file deletion strategy.
132 */
133 static class ForceFileDeleteStrategy extends FileDeleteStrategy {
134 /** Default Constructor */
135 ForceFileDeleteStrategy() {
136 super("Force");
137 }
138
139 /**
140 * Deletes the file object.
141 * <p>
142 * This implementation uses <code>FileUtils.forceDelete() <code>
143 * if the file exists.
144 *
145 * @param fileToDelete the file to delete, not null
146 * @return Always returns <code>true</code>
147 * @throws NullPointerException if the file is null
148 * @throws IOException if an error occurs during file deletion
149 */
150 protected boolean doDelete(File fileToDelete) throws IOException {
151 FileUtils.forceDelete(fileToDelete);
152 return true;
153 }
154 }
155
156 }