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
18 package org.apache.commons.io.function;
19
20 import java.io.IOException;
21 import java.io.UncheckedIOException;
22 import java.util.function.Supplier;
23
24 /**
25 * Unchecks calls by throwing {@link UncheckedIOException} instead of {@link IOException}.
26 *
27 * @since 2.12.0
28 */
29 public final class Uncheck {
30
31 /**
32 * Accepts an IO consumer with the given arguments.
33 *
34 * @param <T> the first input type.
35 * @param <U> the second input type.
36 * @param t the first input argument.
37 * @param u the second input argument.
38 * @param consumer Consumes the value.
39 * @throws UncheckedIOException if an I/O error occurs.
40 */
41 public static <T, U> void accept(final IOBiConsumer<T, U> consumer, final T t, final U u) {
42 try {
43 consumer.accept(t, u);
44 } catch (final IOException e) {
45 throw wrap(e);
46 }
47 }
48
49 /**
50 * Accepts an IO consumer with the given argument.
51 *
52 * @param <T> the input type.
53 * @param t the input argument.
54 * @param consumer Consumes the value.
55 * @throws UncheckedIOException if an I/O error occurs.
56 */
57 public static <T> void accept(final IOConsumer<T> consumer, final T t) {
58 try {
59 consumer.accept(t);
60 } catch (final IOException e) {
61 throw wrap(e);
62 }
63 }
64
65 /**
66 * Accepts an IO consumer with the given argument.
67 *
68 * @param i the input argument.
69 * @param consumer Consumes the value.
70 * @throws UncheckedIOException if an I/O error occurs.
71 * @since 2.18.0
72 */
73 public static void accept(final IOIntConsumer consumer, final int i) {
74 try {
75 consumer.accept(i);
76 } catch (final IOException e) {
77 throw wrap(e);
78 }
79 }
80
81 /**
82 * Accepts an IO consumer with the given arguments.
83 *
84 * @param <T> the first input type.
85 * @param <U> the second input type.
86 * @param <V> the third input type.
87 * @param t the first input argument.
88 * @param u the second input argument.
89 * @param v the third input argument.
90 * @param consumer Consumes the value.
91 * @throws UncheckedIOException if an I/O error occurs.
92 */
93 public static <T, U, V> void accept(final IOTriConsumer<T, U, V> consumer, final T t, final U u, final V v) {
94 try {
95 consumer.accept(t, u, v);
96 } catch (final IOException e) {
97 throw wrap(e);
98 }
99 }
100
101 /**
102 * Applies an IO function with the given arguments.
103 *
104 * @param <T> the first function argument type.
105 * @param <U> the second function argument type.
106 * @param <R> the return type.
107 * @param function the function.
108 * @param t the first function argument.
109 * @param u the second function argument.
110 * @return the function result.
111 * @throws UncheckedIOException if an I/O error occurs.
112 */
113 public static <T, U, R> R apply(final IOBiFunction<T, U, R> function, final T t, final U u) {
114 try {
115 return function.apply(t, u);
116 } catch (final IOException e) {
117 throw wrap(e);
118 }
119 }
120
121 /**
122 * Applies an IO function with the given arguments.
123 *
124 * @param function the function.
125 * @param <T> the first function argument type.
126 * @param <R> the return type.
127 * @param t the first function argument.
128 * @return the function result.
129 * @throws UncheckedIOException if an I/O error occurs.
130 */
131 public static <T, R> R apply(final IOFunction<T, R> function, final T t) {
132 try {
133 return function.apply(t);
134 } catch (final IOException e) {
135 throw wrap(e);
136 }
137 }
138
139 /**
140 * Applies an IO quad-function with the given arguments.
141 *
142 * @param function the function.
143 * @param <T> the first function argument type.
144 * @param <U> the second function argument type.
145 * @param <V> the third function argument type.
146 * @param <W> the fourth function argument type.
147 * @param <R> the return type.
148 * @param t the first function argument.
149 * @param u the second function argument.
150 * @param v the third function argument.
151 * @param w the fourth function argument.
152 * @return the function result.
153 * @throws UncheckedIOException if an I/O error occurs.
154 */
155 public static <T, U, V, W, R> R apply(final IOQuadFunction<T, U, V, W, R> function, final T t, final U u, final V v, final W w) {
156 try {
157 return function.apply(t, u, v, w);
158 } catch (final IOException e) {
159 throw wrap(e);
160 }
161 }
162
163 /**
164 * Applies an IO tri-function with the given arguments.
165 *
166 * @param <T> the first function argument type.
167 * @param <U> the second function argument type.
168 * @param <V> the third function argument type.
169 * @param <R> the return type.
170 * @param function the function.
171 * @param t the first function argument.
172 * @param u the second function argument.
173 * @param v the third function argument.
174 * @return the function result.
175 * @throws UncheckedIOException if an I/O error occurs.
176 */
177 public static <T, U, V, R> R apply(final IOTriFunction<T, U, V, R> function, final T t, final U u, final V v) {
178 try {
179 return function.apply(t, u, v);
180 } catch (final IOException e) {
181 throw wrap(e);
182 }
183 }
184
185 /**
186 * Compares the arguments with the comparator.
187 *
188 * @param <T> the first function argument type.
189 * @param comparator the function.
190 * @param t the first function argument.
191 * @param u the second function argument.
192 * @return the comparator result.
193 * @throws UncheckedIOException if an I/O error occurs.
194 */
195 public static <T> int compare(final IOComparator<T> comparator, final T t, final T u) {
196 try {
197 return comparator.compare(t, u);
198 } catch (final IOException e) {
199 throw wrap(e);
200 }
201 }
202
203 /**
204 * Gets the result from an IO supplier.
205 *
206 * @param <T> the return type of the operations.
207 * @param supplier Supplies the return value.
208 * @return result from the supplier.
209 * @throws UncheckedIOException if an I/O error occurs.
210 */
211 public static <T> T get(final IOSupplier<T> supplier) {
212 try {
213 return supplier.get();
214 } catch (final IOException e) {
215 throw wrap(e);
216 }
217 }
218
219 /**
220 * Gets the result from an IO supplier.
221 *
222 * @param <T> the return type of the operations.
223 * @param supplier Supplies the return value.
224 * @param message The UncheckedIOException message if an I/O error occurs.
225 * @return result from the supplier.
226 * @throws UncheckedIOException if an I/O error occurs.
227 */
228 public static <T> T get(final IOSupplier<T> supplier, final Supplier<String> message) {
229 try {
230 return supplier.get();
231 } catch (final IOException e) {
232 throw wrap(e, message);
233 }
234 }
235
236 /**
237 * Gets the result from an IO boolean supplier.
238 *
239 * @param supplier Supplies the return value.
240 * @return result from the supplier.
241 * @throws UncheckedIOException if an I/O error occurs.
242 * @since 2.19.0
243 */
244 public static boolean getAsBoolean(final IOBooleanSupplier supplier) {
245 try {
246 return supplier.getAsBoolean();
247 } catch (final IOException e) {
248 throw wrap(e);
249 }
250 }
251
252 /**
253 * Gets the result from an IO int supplier.
254 *
255 * @param supplier Supplies the return value.
256 * @return result from the supplier.
257 * @throws UncheckedIOException if an I/O error occurs.
258 * @since 2.14.0
259 */
260 public static int getAsInt(final IOIntSupplier supplier) {
261 try {
262 return supplier.getAsInt();
263 } catch (final IOException e) {
264 throw wrap(e);
265 }
266 }
267
268 /**
269 * Gets the result from an IO int supplier.
270 *
271 * @param supplier Supplies the return value.
272 * @param message The UncheckedIOException message if an I/O error occurs.
273 * @return result from the supplier.
274 * @throws UncheckedIOException if an I/O error occurs.
275 * @since 2.14.0
276 */
277 public static int getAsInt(final IOIntSupplier supplier, final Supplier<String> message) {
278 try {
279 return supplier.getAsInt();
280 } catch (final IOException e) {
281 throw wrap(e, message);
282 }
283 }
284
285 /**
286 * Gets the result from an IO long supplier.
287 *
288 * @param supplier Supplies the return value.
289 * @return result from the supplier.
290 * @throws UncheckedIOException if an I/O error occurs.
291 * @since 2.14.0
292 */
293 public static long getAsLong(final IOLongSupplier supplier) {
294 try {
295 return supplier.getAsLong();
296 } catch (final IOException e) {
297 throw wrap(e);
298 }
299 }
300
301 /**
302 * Gets the result from an IO long supplier.
303 *
304 * @param supplier Supplies the return value.
305 * @param message The UncheckedIOException message if an I/O error occurs.
306 * @return result from the supplier.
307 * @throws UncheckedIOException if an I/O error occurs.
308 * @since 2.14.0
309 */
310 public static long getAsLong(final IOLongSupplier supplier, final Supplier<String> message) {
311 try {
312 return supplier.getAsLong();
313 } catch (final IOException e) {
314 throw wrap(e, message);
315 }
316 }
317
318 /**
319 * Runs an IO runnable.
320 *
321 * @param runnable The runnable to run.
322 * @throws UncheckedIOException if an I/O error occurs.
323 */
324 public static void run(final IORunnable runnable) {
325 try {
326 runnable.run();
327 } catch (final IOException e) {
328 throw wrap(e);
329 }
330 }
331
332 /**
333 * Runs an IO runnable.
334 *
335 * @param runnable The runnable to run.
336 * @param message The UncheckedIOException message if an I/O error occurs.
337 * @throws UncheckedIOException if an I/O error occurs.
338 * @since 2.14.0
339 */
340 public static void run(final IORunnable runnable, final Supplier<String> message) {
341 try {
342 runnable.run();
343 } catch (final IOException e) {
344 throw wrap(e, message);
345 }
346 }
347
348 /**
349 * Tests an IO predicate.
350 *
351 * @param <T> the type of the input to the predicate.
352 * @param predicate the predicate.
353 * @param t the input to the predicate.
354 * @return {@code true} if the input argument matches the predicate, otherwise {@code false}.
355 */
356 public static <T> boolean test(final IOPredicate<T> predicate, final T t) {
357 try {
358 return predicate.test(t);
359 } catch (final IOException e) {
360 throw wrap(e);
361 }
362 }
363
364 /**
365 * Constructs a new {@link UncheckedIOException} for the given exception.
366 *
367 * @param e The exception to wrap.
368 * @return a new {@link UncheckedIOException}.
369 */
370 private static UncheckedIOException wrap(final IOException e) {
371 return new UncheckedIOException(e);
372 }
373
374 /**
375 * Constructs a new {@link UncheckedIOException} for the given exception and detail message.
376 *
377 * @param e The exception to wrap.
378 * @param message The UncheckedIOException message if an I/O error occurs.
379 * @return a new {@link UncheckedIOException}.
380 */
381 private static UncheckedIOException wrap(final IOException e, final Supplier<String> message) {
382 return new UncheckedIOException(message.get(), e);
383 }
384
385 /**
386 * No instances needed.
387 */
388 private Uncheck() {
389 // no instances needed.
390 }
391 }