*/
@FunctionalInterface
public interface IoFunction<T, R> {
    @Nullable
    R apply(@Nullable T t) throws IOException;

    /**
     * Wraps an {@link IOException}-throwing {@link IoFunction} into a regular {@link Function}.
     *
     * Any {@code IOException}s are rethrown as {@link UncheckedIOException}.
     */
    static <T, R> Function<T, R> wrap(IoFunction<T, R> function) {
        return t -> {
            try {

     * The {@link InputStream} passed to the {@link IoFunction#apply(Object)} will
     * be closed right after the action's return.
     *
     * This method or {@link #getContent()} may or may not support being called more than once per entry.
     * Use {@link #canReopen()} to determine if more than one call is supported.
     */
    <T> T withInputStream(IoFunction<InputStream, T> action) throws IOException;

    /**

            @Override
            HashCode handle(RegularFileSnapshot fileSnapshot, IoFunction<RegularFileSnapshot, HashCode> function) throws IOException {
                return function.apply(fileSnapshot);
            }

            @Nullable
            @Override
            HashCode handle(ZipEntryContent zipEntry, IoFunction<ZipEntryContent, HashCode> function) throws IOException {

        return Optional.of(snapshotContext)
            .flatMap(IoFunction.wrap(this::hashContent));
    }

    @Override
    Optional<HashCode> tryHash(ZipEntryContext zipEntryContext) {
        return Optional.of(zipEntryContext)
            .flatMap(IoFunction.wrap(this::hashContent));
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.io


import static org.gradle.internal.io.IoFunction.wrap

class IoFunctionTest extends AbstractIoTest {

    def "executed when it doesn't throw"() {
        expect:
        wrap({ String t -> "wrapped:$t" }).apply("lajos") == "wrapped:lajos"
    }

import org.gradle.internal.fingerprint.hashing.ZipEntryContext;
import org.gradle.internal.hash.HashCode;
import org.gradle.internal.hash.Hasher;
import org.gradle.internal.io.IoFunction;
import org.gradle.internal.io.IoSupplier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.Nullable;
import java.io.ByteArrayInputStream;
import java.io.IOException;

    }

    @Override
    public int size() {
        return (int) entry.getSize();
    }

    @Override
    public byte[] getContent() throws IOException {
        return withInputStream(new IoFunction<InputStream, byte[]>() {
            @Override
            public byte[] apply(InputStream inputStream) throws IOException {
                int size = size();
                if (size >= 0) {

import org.gradle.internal.fingerprint.hashing.ResourceHasher
import org.gradle.internal.fingerprint.hashing.ZipEntryContext
import org.gradle.internal.hash.Hashing
import org.gradle.internal.io.IoFunction
import org.gradle.internal.snapshot.RegularFileSnapshot
import spock.lang.Specification
import spock.lang.TempDir

import java.nio.charset.Charset

        private boolean opened;

        public StreamZipEntry(java.util.zip.ZipEntry entry) {
            super(entry);
        }

        @Override
        public <T> T withInputStream(IoFunction<InputStream, T> action) throws IOException {
            if (opened) {
                throw new IllegalStateException("The input stream for " + getName() + " has already been opened.  It cannot be reopened again.");
            }

    private class FileZipEntry extends AbstractZipEntry {
        public FileZipEntry(java.util.zip.ZipEntry entry) {
            super(entry);
        }

        @Override
        public <T> T withInputStream(IoFunction<InputStream, T> action) throws IOException {
            InputStream inputStream = getInputStream();
            try {
                return action.apply(inputStream);
            } finally {