Source code

001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018package org.apache.commons.io.function;
019
020import java.io.IOException;
021import java.io.UncheckedIOException;
022import java.util.function.Supplier;
023
024/**
025 * Unchecks calls by throwing {@link UncheckedIOException} instead of {@link IOException}.
026 *
027 * @since 2.12.0
028 */
029public final class Uncheck {
030
031    /**
032     * Accepts an IO consumer with the given arguments.
033     *
034     * @param <T> the first input type.
035     * @param <U> the second input type.
036     * @param t the first input argument.
037     * @param u the second input argument.
038     * @param consumer Consumes the value.
039     * @throws UncheckedIOException if an I/O error occurs.
040     */
041    public static <T, U> void accept(final IOBiConsumer<T, U> consumer, final T t, final U u) {
042        try {
043            consumer.accept(t, u);
044        } catch (final IOException e) {
045            throw wrap(e);
046        }
047    }
048
049    /**
050     * Accepts an IO consumer with the given argument.
051     *
052     * @param <T> the input type.
053     * @param t the input argument.
054     * @param consumer Consumes the value.
055     * @throws UncheckedIOException if an I/O error occurs.
056     */
057    public static <T> void accept(final IOConsumer<T> consumer, final T t) {
058        try {
059            consumer.accept(t);
060        } catch (final IOException e) {
061            throw wrap(e);
062        }
063    }
064
065    /**
066     * Accepts an IO consumer with the given arguments.
067     *
068     * @param <T> the first input type.
069     * @param <U> the second input type.
070     * @param <V> the third input type.
071     * @param t the first input argument.
072     * @param u the second input argument.
073     * @param v the third input argument.
074     * @param consumer Consumes the value.
075     * @throws UncheckedIOException if an I/O error occurs.
076     */
077    public static <T, U, V> void accept(final IOTriConsumer<T, U, V> consumer, final T t, final U u, final V v) {
078        try {
079            consumer.accept(t, u, v);
080        } catch (final IOException e) {
081            throw wrap(e);
082        }
083    }
084
085    /**
086     * Applies an IO function with the given arguments.
087     *
088     * @param <T> the first function argument type.
089     * @param <U> the second function argument type.
090     * @param <R> the return type.
091     * @param function the function.
092     * @param t the first function argument.
093     * @param u the second function argument.
094     * @return the function result.
095     * @throws UncheckedIOException if an I/O error occurs.
096     */
097    public static <T, U, R> R apply(final IOBiFunction<T, U, R> function, final T t, final U u) {
098        try {
099            return function.apply(t, u);
100        } catch (final IOException e) {
101            throw wrap(e);
102        }
103    }
104
105    /**
106     * Applies an IO function with the given arguments.
107     *
108     * @param function the function.
109     * @param <T> the first function argument type.
110     * @param <R> the return type.
111     * @param t the first function argument.
112     * @return the function result.
113     * @throws UncheckedIOException if an I/O error occurs.
114     */
115    public static <T, R> R apply(final IOFunction<T, R> function, final T t) {
116        try {
117            return function.apply(t);
118        } catch (final IOException e) {
119            throw wrap(e);
120        }
121    }
122
123    /**
124     * Applies an IO quad-function with the given arguments.
125     *
126     * @param function the function.
127     * @param <T> the first function argument type.
128     * @param <U> the second function argument type.
129     * @param <V> the third function argument type.
130     * @param <W> the fourth function argument type.
131     * @param <R> the return type.
132     * @param t the first function argument.
133     * @param u the second function argument.
134     * @param v the third function argument.
135     * @param w the fourth function argument.
136     * @return the function result.
137     * @throws UncheckedIOException if an I/O error occurs.
138     */
139    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) {
140        try {
141            return function.apply(t, u, v, w);
142        } catch (final IOException e) {
143            throw wrap(e);
144        }
145    }
146
147    /**
148     * Applies an IO tri-function with the given arguments.
149     *
150     * @param <T> the first function argument type.
151     * @param <U> the second function argument type.
152     * @param <V> the third function argument type.
153     * @param <R> the return type.
154     * @param function the function.
155     * @param t the first function argument.
156     * @param u the second function argument.
157     * @param v the third function argument.
158     * @return the function result.
159     * @throws UncheckedIOException if an I/O error occurs.
160     */
161    public static <T, U, V, R> R apply(final IOTriFunction<T, U, V, R> function, final T t, final U u, final V v) {
162        try {
163            return function.apply(t, u, v);
164        } catch (final IOException e) {
165            throw wrap(e);
166        }
167    }
168
169    /**
170     * Compares the arguments with the comparator.
171     *
172     * @param <T> the first function argument type.
173     * @param comparator the function.
174     * @param t the first function argument.
175     * @param u the second function argument.
176     * @return the comparator result.
177     * @throws UncheckedIOException if an I/O error occurs.
178     */
179    public static <T> int compare(final IOComparator<T> comparator, final T t, final T u) {
180        try {
181            return comparator.compare(t, u);
182        } catch (final IOException e) {
183            throw wrap(e);
184        }
185    }
186
187    /**
188     * Gets the result from an IO supplier.
189     *
190     * @param <T> the return type of the operations.
191     * @param supplier Supplies the return value.
192     * @return result from the supplier.
193     * @throws UncheckedIOException if an I/O error occurs.
194     */
195    public static <T> T get(final IOSupplier<T> supplier) {
196        try {
197            return supplier.get();
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     * @param message The UncheckedIOException message if an I/O error occurs.
209     * @return result from the supplier.
210     * @throws UncheckedIOException if an I/O error occurs.
211     */
212    public static <T> T get(final IOSupplier<T> supplier, final Supplier<String> message) {
213        try {
214            return supplier.get();
215        } catch (final IOException e) {
216            throw wrap(e, message);
217        }
218    }
219
220    /**
221     * Gets the result from an IO int supplier.
222     *
223     * @param supplier Supplies the return value.
224     * @return result from the supplier.
225     * @throws UncheckedIOException if an I/O error occurs.
226     * @since 2.14.0
227     */
228    public static int getAsInt(final IOIntSupplier supplier) {
229        try {
230            return supplier.getAsInt();
231        } catch (final IOException e) {
232            throw wrap(e);
233        }
234    }
235
236    /**
237     * Gets the result from an IO int supplier.
238     *
239     * @param supplier Supplies the return value.
240     * @param message The UncheckedIOException message if an I/O error occurs.
241     * @return result from the supplier.
242     * @throws UncheckedIOException if an I/O error occurs.
243     * @since 2.14.0
244     */
245    public static int getAsInt(final IOIntSupplier supplier, final Supplier<String> message) {
246        try {
247            return supplier.getAsInt();
248        } catch (final IOException e) {
249            throw wrap(e, message);
250        }
251    }
252
253    /**
254     * Gets the result from an IO long supplier.
255     *
256     * @param supplier Supplies the return value.
257     * @return result from the supplier.
258     * @throws UncheckedIOException if an I/O error occurs.
259     * @since 2.14.0
260     */
261    public static long getAsLong(final IOLongSupplier supplier) {
262        try {
263            return supplier.getAsLong();
264        } catch (final IOException e) {
265            throw wrap(e);
266        }
267    }
268
269    /**
270     * Gets the result from an IO long supplier.
271     *
272     * @param supplier Supplies the return value.
273     * @param message The UncheckedIOException message if an I/O error occurs.
274     * @return result from the supplier.
275     * @throws UncheckedIOException if an I/O error occurs.
276     * @since 2.14.0
277     */
278    public static long getAsLong(final IOLongSupplier supplier, final Supplier<String> message) {
279        try {
280            return supplier.getAsLong();
281        } catch (final IOException e) {
282            throw wrap(e, message);
283        }
284    }
285
286    /**
287     * Runs an IO runnable.
288     *
289     * @param runnable The runnable to run.
290     * @throws UncheckedIOException if an I/O error occurs.
291     */
292    public static void run(final IORunnable runnable) {
293        try {
294            runnable.run();
295        } catch (final IOException e) {
296            throw wrap(e);
297        }
298    }
299
300    /**
301     * Runs an IO runnable.
302     *
303     * @param runnable The runnable to run.
304     * @param message The UncheckedIOException message if an I/O error occurs.
305     * @throws UncheckedIOException if an I/O error occurs.
306     * @since 2.14.0
307     */
308    public static void run(final IORunnable runnable, final Supplier<String> message) {
309        try {
310            runnable.run();
311        } catch (final IOException e) {
312            throw wrap(e, message);
313        }
314    }
315
316    /**
317     * Tests an IO predicate.
318     *
319     * @param <T> the type of the input to the predicate.
320     * @param predicate the predicate.
321     * @param t the input to the predicate.
322     * @return {@code true} if the input argument matches the predicate, otherwise {@code false}.
323     */
324    public static <T> boolean test(final IOPredicate<T> predicate, final T t) {
325        try {
326            return predicate.test(t);
327        } catch (final IOException e) {
328            throw wrap(e);
329        }
330    }
331
332    /**
333     * Constructs a new {@link UncheckedIOException} for the given exception.
334     *
335     * @param e The exception to wrap.
336     * @return a new {@link UncheckedIOException}.
337     */
338    private static UncheckedIOException wrap(final IOException e) {
339        return new UncheckedIOException(e);
340    }
341
342    /**
343     * Constructs a new {@link UncheckedIOException} for the given exception and detail message.
344     *
345     * @param e The exception to wrap.
346     * @param message The UncheckedIOException message if an I/O error occurs.
347     * @return a new {@link UncheckedIOException}.
348     */
349    private static UncheckedIOException wrap(final IOException e, final Supplier<String> message) {
350        return new UncheckedIOException(message.get(), e);
351    }
352
353    /**
354     * No instances needed.
355     */
356    private Uncheck() {
357        // no instances needed.
358    }
359}