* limitations under the License.
 */

package org.gradle.api.internal.file.archive;

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

public interface ZipEntry {
    /**
     * The compression method used for an entry
     */
    enum ZipCompressionMethod {
        /**
         * The entry is compressed with DEFLATE algorithm.
         */
        DEFLATED,

    }

    private static class ZipEntryRelativePath implements Supplier<String[]> {
        private final ZipEntry zipEntry;

        ZipEntryRelativePath(ZipEntry zipEntry) {
            this.zipEntry = zipEntry;
        }

        @Override
        public String[] get() {
            return FilePathUtil.getPathSegments(zipEntry.getName());
        }
    }

            try {
                final Enumeration<? extends ZipEntry> zipFileEntries = zipFile.entries();

                while (zipFileEntries.hasMoreElements()) {
                    final ZipEntry zipEntry = zipFileEntries.nextElement();
                    final String entryName = zipEntry.getName();
                    final String packageName = zipEntry.isDirectory() ? entryName :

        for (ZipEntry zipEntry : input) {
            if (zipEntry.isDirectory()) {
                continue;
            }
            String fullName = parentName.isEmpty() ? zipEntry.getName() : parentName + "/" + zipEntry.getName();
            ZipEntryContext zipEntryContext = new DefaultZipEntryContext(zipEntry, fullName, rootParentName);
            if (isZipFile(zipEntry.getName())) {

        when:
        hasher.hash(zipEntry('META-INF/foo'))
        hasher.hash(zipEntry('META-INF/foo/MANIFEST.MF'))
        hasher.hash(zipEntry('META-INF/properties'))
        hasher.hash(zipEntry('META-INF/build.propertiesX'))
        hasher.hash(zipEntry('bar.properties'))
        hasher.hash(zipEntry('resources/foo.properties'))
        hasher.hash(zipEntry('foo'))
        hasher.hash(zipEntry('org/gradle/foo.class'))

            if (name.endsWith(".class")) {
                processClassFile(zipEntry, builder)
            }
        }

        @Throws(IOException::class)
        private
        fun processClassFile(zipEntry: ZipEntry, builder: Trie.Builder) {
            val endIndex = zipEntry.name.lastIndexOf("/")
            if (endIndex > 0) {
                val packageName = zipEntry.name.substring(0, endIndex)

                    }
                }
            }
        }
    }

    protected void addEntry(JarOutputStream jarOutputStream, ZipEntry entry, ZipFile zip) {
        jarOutputStream.putNextEntry(new ZipEntry (entry.name))
        zip.getInputStream(entry).withCloseable { jarOutputStream << it }
        jarOutputStream.closeEntry()
// tag::artifact-transform-minify[]
    }
}

            it.putNextEntry(new ZipEntry("com/a/b/c/"))
            it.putNextEntry(new ZipEntry("com/a/b/c/A.class"))
            it.putNextEntry(new ZipEntry("com/a/b/c/B.class"))
            it.putNextEntry(new ZipEntry("com/a/b/"))
            it.putNextEntry(new ZipEntry("com/a/b/C.class"))
            it.putNextEntry(new ZipEntry("com/"))
            it.putNextEntry(new ZipEntry("com/D.class"))

import org.gradle.api.internal.file.archive.ZipEntry;

import java.io.IOException;
import java.io.InputStream;

abstract class AbstractZipEntry implements ZipEntry {
    private final java.util.zip.ZipEntry entry;

    public AbstractZipEntry(java.util.zip.ZipEntry entry) {
        this.entry = entry;
    }

    protected java.util.zip.ZipEntry getEntry() {
        return entry;
    }

    @Override

        ZipEntry zipEntry = zipEntryContext.getEntry();

        if (isNotClassFile(zipEntry.getName())) {
            return null;
        }

        // A failure to read the zip entry content is a failure to read from the zip stream and should
        // be handled as a failure at the file level rather than at the entry level
        byte[] content = zipEntry.getContent();