* 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())) {

                    }
                }
            }
        }
    }

    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"))

            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)

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

        this.inputStream = new ZipInputStream(inputStream);
    }

    @Override
    public Iterator<ZipEntry> iterator() {
        return new AbstractIterator<ZipEntry>() {
            @Override
            protected ZipEntry computeNext() {
                java.util.zip.ZipEntry nextEntry;
                try {
                    nextEntry = inputStream.getNextEntry();
                } catch (IOException e) {

import java.util.jar.Manifest
import java.util.zip.ZipEntry

class JarUtils {
    static def jarWithContents(Map<String, String> contents) {
        def out = new ByteArrayOutputStream()
        def jarOut = new JarOutputStream(out)
        try {
            contents.each { file, fileContents ->
                def zipEntry = new ZipEntry(file)
                zipEntry.setTime(0)
                jarOut.putNextEntry(zipEntry)