Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
What Is commons-io-2.11.jar
What Is commons-io-2.11.jar?
✍: FYIcenter.com
commons-io-2.11.jar is the JAR file for Commons IO 2.5, which is a library of utilities to assist with developing IO functionality.
JAR File Size and Download Location:
JAR name: commons-io-2.11.0.jar Target JDK version: 8 Dependency: None File name: commons-io.jar, commons-io-2.11.0.jar File size: 327135 bytes Release date: 01-22-2020 Download: Apache Commons IO Website
Java source code files for commons-io-2.11.jar are:
⏎ org/apache/commons/io/function/IOFunction.java
/* * 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.commons.io.function; import java.io.IOException; import java.util.Objects; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Supplier; /** * Like {@link Function} but throws {@link IOException}. * * @param <T> the type of the input to the operations. * @param <R> the return type of the operations. * @since 2.7 */ @FunctionalInterface public interface IOFunction<T, R> { /** * Applies this function to the given argument. * * @param t the function argument * @return the function result * * @throws IOException if the function throws an IOException */ R apply(final T t) throws IOException; /** * Returns a composed {@link IOFunction} that first applies the {@code before} * function to its input, and then applies this function to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param <V> the type of input to the {@code before} function, and to the * composed function * @param before the function to apply before this function is applied * @return a composed function that first applies the {@code before} * function and then applies this function * @throws NullPointerException if before is null * * @see #andThen(IOFunction) */ default <V> IOFunction<V, R> compose(final IOFunction<? super V, ? extends T> before) { Objects.requireNonNull(before, "before"); return (final V v) -> apply(before.apply(v)); } /** * Returns a composed {@link IOFunction} that first applies the {@code before} * function to its input, and then applies this function to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param <V> the type of input to the {@code before} function, and to the * composed function * @param before the function to apply before this function is applied * @return a composed function that first applies the {@code before} * function and then applies this function * @throws NullPointerException if before is null * * @see #andThen(IOFunction) */ default <V> IOFunction<V, R> compose(final Function<? super V, ? extends T> before) { Objects.requireNonNull(before, "before"); return (final V v) -> apply(before.apply(v)); } /** * Returns a composed {@link IOFunction} that first applies the {@code before} * function to its input, and then applies this function to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param before the supplier which feeds the application of this function * @return a composed function that first applies the {@code before} * function and then applies this function * @throws NullPointerException if before is null * * @see #andThen(IOFunction) */ default IOSupplier<R> compose(final IOSupplier<? extends T> before) { Objects.requireNonNull(before, "before"); return () -> apply(before.get()); } /** * Returns a composed {@link IOFunction} that first applies the {@code before} * function to its input, and then applies this function to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param before the supplier which feeds the application of this function * @return a composed function that first applies the {@code before} * function and then applies this function * @throws NullPointerException if before is null * * @see #andThen(IOFunction) */ default IOSupplier<R> compose(final Supplier<? extends T> before) { Objects.requireNonNull(before, "before"); return () -> apply(before.get()); } /** * Returns a composed {@link IOFunction} that first applies this function to * its input, and then applies the {@code after} function to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param <V> the type of output of the {@code after} function, and of the * composed function * @param after the function to apply after this function is applied * @return a composed function that first applies this function and then * applies the {@code after} function * @throws NullPointerException if after is null * * @see #compose(IOFunction) */ default <V> IOFunction<T, V> andThen(final IOFunction<? super R, ? extends V> after) { Objects.requireNonNull(after, "after"); return (final T t) -> after.apply(apply(t)); } /** * Returns a composed {@link IOFunction} that first applies this function to * its input, and then applies the {@code after} function to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param <V> the type of output of the {@code after} function, and of the * composed function * @param after the function to apply after this function is applied * @return a composed function that first applies this function and then * applies the {@code after} function * @throws NullPointerException if after is null * * @see #compose(IOFunction) */ default <V> IOFunction<T, V> andThen(final Function<? super R, ? extends V> after) { Objects.requireNonNull(after, "after"); return (final T t) -> after.apply(apply(t)); } /** * Returns a composed {@link IOFunction} that first applies this function to * its input, and then applies the {@code after} consumer to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param after the consumer to apply after this function is applied * @return a composed function that first applies this function and then * applies the {@code after} consumer * @throws NullPointerException if after is null * * @see #compose(IOFunction) */ default IOConsumer<T> andThen(final IOConsumer<? super R> after) { Objects.requireNonNull(after, "after"); return (final T t) -> after.accept(apply(t)); } /** * Returns a composed {@link IOFunction} that first applies this function to * its input, and then applies the {@code after} consumer to the result. * If evaluation of either function throws an exception, it is relayed to * the caller of the composed function. * * @param after the consumer to apply after this function is applied * @return a composed function that first applies this function and then * applies the {@code after} consumer * @throws NullPointerException if after is null * * @see #compose(IOFunction) */ default IOConsumer<T> andThen(final Consumer<? super R> after) { Objects.requireNonNull(after, "after"); return (final T t) -> after.accept(apply(t)); } /** * Returns a {@link IOFunction} that always returns its input argument. * * @param <T> the type of the input and output objects to the function * @return a function that always returns its input argument */ static <T> IOFunction<T, T> identity() { return t -> t; } }
⏎ org/apache/commons/io/function/IOFunction.java
Or download all of them as a single archive file:
File name: commons-io-2.11.0-sources.jar File size: 398939 bytes Release date: 2020-01-22 Download
⇒ Download and Install commons-io-2.6-bin.zip
⇐ What Is commons-io-2.11-bin.zip
2022-11-10, 74902👍, 2💬
Popular Posts:
JDK 17 jdk.localedata.jmod is the JMOD file for JDK 17 Localedata module. JDK 17 Locale Data module ...
JDK 11 jdk.xml.dom.jmod is the JMOD file for JDK 11 XML DOM module. JDK 11 XML DOM module compiled c...
If you are a Java developer, it is very often that you need to use some 3rd party libraries to perfo...
Commons VFS provides a single API for accessing various different file systems. It presents a unifor...
JDK 11 java.security.jgss.jmod is the JMOD file for JDK 11 Security JGSS (Java Generic Security Serv...