@Override
        public byte[] getContent() throws IOException {
            return entry.getContent();
        }

        @Override
        public CompressionMethod getCompressionMethod() {
            switch (entry.getCompressionMethod()) {
                case STORED:
                    return CompressionMethod.STORED;
                case DEFLATED:
                    return CompressionMethod.DEFLATED;

                } else {
                    return ByteStreams.toByteArray(inputStream);
                }
            }
        });
    }

    @Override
    public ZipCompressionMethod getCompressionMethod() {
        switch (entry.getMethod()) {
            case java.util.zip.ZipEntry.STORED:
                return ZipCompressionMethod.STORED;
            case java.util.zip.ZipEntry.DEFLATED:

        }

        @Override
        public boolean canReopen() {
            return true;
        }

        @Override
        public ZipCompressionMethod getCompressionMethod() {
            return delegate.getCompressionMethod();
        }
    }

        reader.accept(chain.right, 0);
        byte[] bytes = classWriter.toByteArray();
        builder.put(chain.left.getPathString(), bytes, classEntry.getCompressionMethod());
    }

    /**
     * Processes a JAR Manifest. Base class implementation copies the manifest unchanged.
     *
     * @param builder the builder for the transformed output

             */
            UNDEFINED,
        }

        String getName();

        RelativePath getPath();

        CompressionMethod getCompressionMethod();

        /**
         * Can be called at most once for a given entry. If not called, content is skipped.
         */
        byte[] getContent() throws IOException;
    }

            public RelativePath getPath() {
                return RelativePath.parse(true, path);
            }

            @Override
            public ClasspathEntryVisitor.Entry.CompressionMethod getCompressionMethod() {
                return ClasspathEntryVisitor.Entry.CompressionMethod.STORED;
            }

            @Override
            public byte[] getContent() {
                return bytes;
            }

    int size();

    /**
     * Whether or not the zip entry can safely be read again if any bytes
     * have already been read from it.
     */
    boolean canReopen();

    ZipCompressionMethod getCompressionMethod();

    // Copied from org.gradle.internal.io.IoFunction in :functional due to
    // JDK version mismatch between the projects
    interface IoFunction<T, R> {
        @Nullable

            setManifestMainAttribute(processedManifest, JarUtil.MULTI_RELEASE_ATTRIBUTE, "true");

            builder.put(manifestEntry.getName(), toByteArray(processedManifest), manifestEntry.getCompressionMethod());
        } catch (IOException e) {
            LOGGER.debug("Failed to parse Manifest from JAR " + source);
            throw e;
        }
    }

    @Override

            }

            @Override
            boolean canReopen() {
                return !unsafe
            }

            @Override
            ZipEntry.ZipCompressionMethod getCompressionMethod() {
                return ZipEntry.ZipCompressionMethod.DEFLATED
            }
        }
        return new DefaultZipEntryContext(zipEntry, file.path, "foo.zip")
    }

            }

            @Override
            boolean canReopen() {
                return !unsafe
            }

            @Override
            ZipEntry.ZipCompressionMethod getCompressionMethod() {
                return ZipEntry.ZipCompressionMethod.DEFLATED
            }
        }
        return new DefaultZipEntryContext(zipEntry, path, "foo.zip")
    }