public class ZipArchiveOutputStream extends ArchiveOutputStream
java.util.zip.ZipOutputStream
that does handle the extended
functionality of this package, especially internal/external file
attributes and extra fields with different layouts for local file
data and central directory entries.
This class will try to use SeekableByteChannel
when it knows that the
output is going to go to a file.
If SeekableByteChannel cannot be used, this implementation will use
a Data Descriptor to store size and CRC information for DEFLATED
entries, this means, you don't need to
calculate them yourself. Unfortunately this is not possible for
the STORED
method, here setting the CRC and
uncompressed size information is required before putArchiveEntry(ArchiveEntry)
can be called.
As of Apache Commons Compress 1.3 it transparently supports Zip64
extensions and thus individual entries and archives larger than 4
GB or with more than 65536 entries in most cases but explicit
control is provided via setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode)
. If the stream can not
use SeekableByteChannel and you try to write a ZipArchiveEntry of
unknown size then Zip64 extensions will be disabled by default.
Modifier and Type | Class and Description |
---|---|
private static class |
ZipArchiveOutputStream.CurrentEntry
Structure collecting information for the entry that is
currently being written.
|
private static class |
ZipArchiveOutputStream.EntryMetaData |
static class |
ZipArchiveOutputStream.UnicodeExtraFieldPolicy
enum that represents the possible policies for creating Unicode
extra fields.
|
Modifier and Type | Field and Description |
---|---|
(package private) static int |
BUFFER_SIZE |
private java.util.Calendar |
calendarInstance |
private long |
cdLength
Length of central directory.
|
private long |
cdOffset
Start of central directory.
|
private static int |
CFH_COMMENT_LENGTH_OFFSET |
private static int |
CFH_COMPRESSED_SIZE_OFFSET |
private static int |
CFH_CRC_OFFSET |
private static int |
CFH_DISK_NUMBER_OFFSET |
private static int |
CFH_EXTERNAL_ATTRIBUTES_OFFSET |
private static int |
CFH_EXTRA_LENGTH_OFFSET |
private static int |
CFH_FILENAME_LENGTH_OFFSET |
private static int |
CFH_FILENAME_OFFSET |
private static int |
CFH_GPB_OFFSET |
private static int |
CFH_INTERNAL_ATTRIBUTES_OFFSET |
private static int |
CFH_LFH_OFFSET |
private static int |
CFH_METHOD_OFFSET |
private static int |
CFH_ORIGINAL_SIZE_OFFSET |
(package private) static byte[] |
CFH_SIG
central file header signature
|
private static int |
CFH_SIG_OFFSET |
private static int |
CFH_TIME_OFFSET |
private static int |
CFH_VERSION_MADE_BY_OFFSET |
private static int |
CFH_VERSION_NEEDED_OFFSET |
private java.nio.channels.SeekableByteChannel |
channel
Optional random access output.
|
private java.lang.String |
comment
The file comment.
|
private byte[] |
copyBuffer |
private ZipArchiveOutputStream.UnicodeExtraFieldPolicy |
createUnicodeExtraFields
whether to create UnicodePathExtraField-s for each entry.
|
(package private) static byte[] |
DD_SIG
data descriptor signature
|
protected java.util.zip.Deflater |
def
This Deflater object is used for output.
|
static int |
DEFAULT_COMPRESSION
Default compression level for deflated entries.
|
(package private) static java.lang.String |
DEFAULT_ENCODING
default encoding for file names and comment.
|
static int |
DEFLATED
Compression method for deflated entries.
|
static int |
EFS_FLAG
Deprecated.
use
GeneralPurposeBit.UFT8_NAMES_FLAG instead |
private static byte[] |
EMPTY |
private java.lang.String |
encoding
The encoding to use for filenames and the file comment.
|
private java.util.List<ZipArchiveEntry> |
entries
List of ZipArchiveEntries written so far.
|
private ZipArchiveOutputStream.CurrentEntry |
entry
Current entry.
|
(package private) static byte[] |
EOCD_SIG
end of central dir signature
|
private boolean |
fallbackToUTF8
Whether to encode non-encodable file names as UTF-8.
|
protected boolean |
finished
indicates if this archive is finished.
|
private boolean |
hasCompressionLevelChanged
Has the compression level changed when compared to the last
entry?
|
private boolean |
hasUsedZip64
Whether anything inside this archive has used a ZIP64 feature.
|
private int |
level
Compression level for next entry.
|
private static int |
LFH_COMPRESSED_SIZE_OFFSET |
private static int |
LFH_CRC_OFFSET |
private static int |
LFH_EXTRA_LENGTH_OFFSET |
private static int |
LFH_FILENAME_LENGTH_OFFSET |
private static int |
LFH_FILENAME_OFFSET |
private static int |
LFH_GPB_OFFSET |
private static int |
LFH_METHOD_OFFSET |
private static int |
LFH_ORIGINAL_SIZE_OFFSET |
(package private) static byte[] |
LFH_SIG
local file header signature
|
private static int |
LFH_SIG_OFFSET |
private static int |
LFH_TIME_OFFSET |
private static int |
LFH_VERSION_NEEDED_OFFSET |
private static byte[] |
LZERO
Helper, a 0 as ZipLong.
|
private java.util.Map<ZipArchiveEntry,ZipArchiveOutputStream.EntryMetaData> |
metaData
Holds some book-keeping data for each entry.
|
private int |
method
Default compression method for next entry.
|
private static byte[] |
ONE |
private java.io.OutputStream |
out |
static int |
STORED
Compression method for stored entries.
|
private StreamCompressor |
streamCompressor |
private boolean |
useUTF8Flag
whether to use the general purpose bit flag when writing UTF-8
filenames or not.
|
private static byte[] |
ZERO
Helper, a 0 as ZipShort.
|
(package private) static byte[] |
ZIP64_EOCD_LOC_SIG
ZIP64 end of central dir locator signature
|
(package private) static byte[] |
ZIP64_EOCD_SIG
ZIP64 end of central dir signature
|
private Zip64Mode |
zip64Mode |
private ZipEncoding |
zipEncoding
The zip encoding to use for filenames and the file comment.
|
Constructor and Description |
---|
ZipArchiveOutputStream(java.io.File file)
Creates a new ZIP OutputStream writing to a File.
|
ZipArchiveOutputStream(java.io.OutputStream out)
Creates a new ZIP OutputStream filtering the underlying stream.
|
ZipArchiveOutputStream(java.nio.channels.SeekableByteChannel channel)
Creates a new ZIP OutputStream writing to a SeekableByteChannel.
|
Modifier and Type | Method and Description |
---|---|
void |
addRawArchiveEntry(ZipArchiveEntry entry,
java.io.InputStream rawStream)
Adds an archive entry with a raw input stream.
|
private void |
addUnicodeExtraFields(ZipArchiveEntry ze,
boolean encodable,
java.nio.ByteBuffer name)
Adds UnicodeExtra fields for name and file comment if mode is
ALWAYS or the data cannot be encoded using the configured
encoding.
|
boolean |
canWriteEntryData(ArchiveEntry ae)
Whether this stream is able to write the given entry.
|
private boolean |
checkIfNeedsZip64(Zip64Mode effectiveMode)
Verifies the sizes aren't too big in the Zip64Mode.Never case
and returns whether the entry would require a Zip64 extra
field.
|
void |
close()
Closes this output stream and releases any system resources
associated with the stream.
|
void |
closeArchiveEntry()
Writes all necessary data for this entry.
|
private void |
closeCopiedEntry(boolean phased)
Writes all necessary data for this entry.
|
private void |
closeEntry(boolean actuallyNeedsZip64,
boolean phased) |
private void |
copyFromZipInputStream(java.io.InputStream src) |
ArchiveEntry |
createArchiveEntry(java.io.File inputFile,
java.lang.String entryName)
Creates a new zip entry taking some information from the given
file and using the provided name.
|
private byte[] |
createCentralFileHeader(ZipArchiveEntry ze) |
private byte[] |
createCentralFileHeader(ZipArchiveEntry ze,
java.nio.ByteBuffer name,
ZipArchiveOutputStream.EntryMetaData entryMetaData,
boolean needsZip64Extra)
Writes the central file header entry.
|
private byte[] |
createLocalFileHeader(ZipArchiveEntry ze,
java.nio.ByteBuffer name,
boolean encodable,
boolean phased,
long archiveOffset) |
protected void |
deflate()
Writes next block of compressed data to the output stream.
|
(package private) void |
destroy()
Closes the underlying stream/file without finishing the
archive, the result will likely be a corrupt archive.
|
void |
finish()
Finishes the addition of entries to this stream, without closing it.
|
void |
flush()
Flushes this output stream and forces any buffered output bytes
to be written out to the stream.
|
private void |
flushDeflater()
Ensures all bytes sent to the deflater are written to the stream.
|
private Zip64Mode |
getEffectiveZip64Mode(ZipArchiveEntry ze)
If the mode is AsNeeded and the entry is a compressed entry of
unknown size that gets written to a non-seekable stream then
change the default to Never.
|
java.lang.String |
getEncoding()
The encoding to use for filenames and the file comment.
|
private ZipEncoding |
getEntryEncoding(ZipArchiveEntry ze) |
private GeneralPurposeBit |
getGeneralPurposeBits(boolean utfFallback,
boolean usesDataDescriptor) |
private java.nio.ByteBuffer |
getName(ZipArchiveEntry ze) |
private Zip64ExtendedInformationExtraField |
getZip64Extra(ZipArchiveEntry ze)
Get the existing ZIP64 extended information extra field or
create a new one and add it to the entry.
|
private boolean |
handleSizesAndCrc(long bytesWritten,
long crc,
Zip64Mode effectiveMode)
Ensures the current entry's size and CRC information is set to
the values just written, verifies it isn't too big in the
Zip64Mode.Never case and returns whether the entry would
require a Zip64 extra field.
|
private void |
handleZip64Extra(ZipArchiveEntry ze,
long lfhOffset,
boolean needsZip64Extra)
If the entry needs Zip64 extra information inside the central
directory then configure its data.
|
private boolean |
hasZip64Extra(ZipArchiveEntry ze)
Is there a ZIP64 extended information extra field for the
entry?
|
boolean |
isSeekable()
This method indicates whether this archive is writing to a
seekable stream (i.e., to a random access file).
|
private boolean |
isTooLageForZip32(ZipArchiveEntry zipArchiveEntry) |
private boolean |
isZip64Required(ZipArchiveEntry entry1,
Zip64Mode requestedMode) |
private void |
preClose() |
void |
putArchiveEntry(ArchiveEntry archiveEntry)
Writes the headers for an archive entry to the output stream.
|
private void |
putArchiveEntry(ArchiveEntry archiveEntry,
boolean phased)
Writes the headers for an archive entry to the output stream.
|
private void |
rewriteSizesAndCrc(boolean actuallyNeedsZip64)
When using random access output, write the local file header
and potentiall the ZIP64 extra containing the correct CRC and
compressed/uncompressed sizes.
|
void |
setComment(java.lang.String comment)
Set the file comment.
|
void |
setCreateUnicodeExtraFields(ZipArchiveOutputStream.UnicodeExtraFieldPolicy b)
Whether to create Unicode Extra Fields.
|
private void |
setDefaults(ZipArchiveEntry entry)
Provides default values for compression method and last
modification time.
|
void |
setEncoding(java.lang.String encoding)
The encoding to use for filenames and the file comment.
|
void |
setFallbackToUTF8(boolean b)
Whether to fall back to UTF and the language encoding flag if
the file name cannot be encoded using the specified encoding.
|
void |
setLevel(int level)
Sets the compression level for subsequent entries.
|
void |
setMethod(int method)
Sets the default compression method for subsequent entries.
|
void |
setUseLanguageEncodingFlag(boolean b)
Whether to set the language encoding flag if the file name
encoding is UTF-8.
|
void |
setUseZip64(Zip64Mode mode)
Whether Zip64 extensions will be used.
|
private boolean |
shouldAddZip64Extra(ZipArchiveEntry entry,
Zip64Mode mode)
Whether to addd a Zip64 extended information extra field to the
local file header.
|
private boolean |
usesDataDescriptor(int zipMethod,
boolean phased) |
private void |
validateSizeInformation(Zip64Mode effectiveMode)
Throws an exception if the size is unknown for a stored entry
that is written to a non-seekable output or the entry is too
big to be written without Zip64 extra but the mode has been set
to Never.
|
private int |
versionNeededToExtract(int zipMethod,
boolean zip64,
boolean usedDataDescriptor) |
private int |
versionNeededToExtractMethod(int zipMethod) |
void |
write(byte[] b,
int offset,
int length)
Writes bytes to ZIP entry.
|
protected void |
writeCentralDirectoryEnd()
Writes the "End of central dir record".
|
private void |
writeCentralDirectoryInChunks() |
protected void |
writeCentralFileHeader(ZipArchiveEntry ze)
Writes the central file header entry.
|
private void |
writeCounted(byte[] data)
Write bytes to output or random access file.
|
protected void |
writeDataDescriptor(ZipArchiveEntry ze)
Writes the data descriptor entry.
|
protected void |
writeLocalFileHeader(ZipArchiveEntry ze)
Writes the local file header entry
|
private void |
writeLocalFileHeader(ZipArchiveEntry ze,
boolean phased) |
protected void |
writeOut(byte[] data)
Write bytes to output or random access file.
|
protected void |
writeOut(byte[] data,
int offset,
int length)
Write bytes to output or random access file.
|
protected void |
writeZip64CentralDirectory()
Writes the "ZIP64 End of central dir record" and
"ZIP64 End of central dir locator".
|
count, count, getBytesWritten, getCount, write
static final int BUFFER_SIZE
private static final int LFH_SIG_OFFSET
private static final int LFH_VERSION_NEEDED_OFFSET
private static final int LFH_GPB_OFFSET
private static final int LFH_METHOD_OFFSET
private static final int LFH_TIME_OFFSET
private static final int LFH_CRC_OFFSET
private static final int LFH_COMPRESSED_SIZE_OFFSET
private static final int LFH_ORIGINAL_SIZE_OFFSET
private static final int LFH_FILENAME_LENGTH_OFFSET
private static final int LFH_EXTRA_LENGTH_OFFSET
private static final int LFH_FILENAME_OFFSET
private static final int CFH_SIG_OFFSET
private static final int CFH_VERSION_MADE_BY_OFFSET
private static final int CFH_VERSION_NEEDED_OFFSET
private static final int CFH_GPB_OFFSET
private static final int CFH_METHOD_OFFSET
private static final int CFH_TIME_OFFSET
private static final int CFH_CRC_OFFSET
private static final int CFH_COMPRESSED_SIZE_OFFSET
private static final int CFH_ORIGINAL_SIZE_OFFSET
private static final int CFH_FILENAME_LENGTH_OFFSET
private static final int CFH_EXTRA_LENGTH_OFFSET
private static final int CFH_COMMENT_LENGTH_OFFSET
private static final int CFH_DISK_NUMBER_OFFSET
private static final int CFH_INTERNAL_ATTRIBUTES_OFFSET
private static final int CFH_EXTERNAL_ATTRIBUTES_OFFSET
private static final int CFH_LFH_OFFSET
private static final int CFH_FILENAME_OFFSET
protected boolean finished
public static final int DEFLATED
public static final int DEFAULT_COMPRESSION
public static final int STORED
static final java.lang.String DEFAULT_ENCODING
@Deprecated public static final int EFS_FLAG
GeneralPurposeBit.UFT8_NAMES_FLAG
insteadprivate static final byte[] EMPTY
private ZipArchiveOutputStream.CurrentEntry entry
private java.lang.String comment
private int level
private boolean hasCompressionLevelChanged
private int method
private final java.util.List<ZipArchiveEntry> entries
private final StreamCompressor streamCompressor
private long cdOffset
private long cdLength
private static final byte[] ZERO
private static final byte[] LZERO
private static final byte[] ONE
private final java.util.Map<ZipArchiveEntry,ZipArchiveOutputStream.EntryMetaData> metaData
private java.lang.String encoding
For a list of possible values see http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html. Defaults to UTF-8.
private ZipEncoding zipEncoding
setEncoding(String)
.protected final java.util.zip.Deflater def
private final java.nio.channels.SeekableByteChannel channel
private final java.io.OutputStream out
private boolean useUTF8Flag
private boolean fallbackToUTF8
private ZipArchiveOutputStream.UnicodeExtraFieldPolicy createUnicodeExtraFields
private boolean hasUsedZip64
private Zip64Mode zip64Mode
private final byte[] copyBuffer
private final java.util.Calendar calendarInstance
static final byte[] LFH_SIG
static final byte[] DD_SIG
static final byte[] CFH_SIG
static final byte[] EOCD_SIG
static final byte[] ZIP64_EOCD_SIG
static final byte[] ZIP64_EOCD_LOC_SIG
public ZipArchiveOutputStream(java.io.OutputStream out)
out
- the outputstream to zippublic ZipArchiveOutputStream(java.io.File file) throws java.io.IOException
file
- the file to zip tojava.io.IOException
- on errorpublic ZipArchiveOutputStream(java.nio.channels.SeekableByteChannel channel) throws java.io.IOException
SeekableInMemoryByteChannel
allows you to write to an in-memory archive using random
access.
channel
- the channel to zip tojava.io.IOException
- on errorpublic boolean isSeekable()
For seekable streams, you don't need to calculate the CRC or
uncompressed size for STORED
entries before
invoking putArchiveEntry(ArchiveEntry)
.
public void setEncoding(java.lang.String encoding)
For a list of possible values see http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html. Defaults to UTF-8.
encoding
- the encoding to use for file names, use null
for the platform's default encodingpublic java.lang.String getEncoding()
public void setUseLanguageEncodingFlag(boolean b)
Defaults to true.
b
- whether to set the language encoding flag if the file
name encoding is UTF-8public void setCreateUnicodeExtraFields(ZipArchiveOutputStream.UnicodeExtraFieldPolicy b)
Defaults to NEVER.
b
- whether to create Unicode Extra Fields.public void setFallbackToUTF8(boolean b)
Defaults to false.
b
- whether to fall back to UTF and the language encoding
flag if the file name cannot be encoded using the specified
encoding.public void setUseZip64(Zip64Mode mode)
When setting the mode to Never
,
putArchiveEntry(org.apache.commons.compress.archivers.ArchiveEntry)
, closeArchiveEntry()
, finish()
or close()
may throw a Zip64RequiredException
if the entry's size or the total size
of the archive exceeds 4GB or there are more than 65536 entries
inside the archive. Any archive created in this mode will be
readable by implementations that don't support Zip64.
When setting the mode to Always
,
Zip64 extensions will be used for all entries. Any archive
created in this mode may be unreadable by implementations that
don't support Zip64 even if all its contents would be.
When setting the mode to AsNeeded
, Zip64 extensions will transparently be used for
those entries that require them. This mode can only be used if
the uncompressed size of the ZipArchiveEntry
is known
when calling putArchiveEntry(org.apache.commons.compress.archivers.ArchiveEntry)
or the archive is written
to a seekable output (i.e. you have used the File-arg constructor
) -
this mode is not valid when the output stream is not seekable
and the uncompressed size is unknown when putArchiveEntry(org.apache.commons.compress.archivers.ArchiveEntry)
is called.
If no entry inside the resulting archive requires Zip64
extensions then Never
will create the
smallest archive. AsNeeded
will
create a slightly bigger archive if the uncompressed size of
any entry has initially been unknown and create an archive
identical to Never
otherwise. Always
will create an archive that is at
least 24 bytes per entry bigger than the one Never
would create.
Defaults to AsNeeded
unless
putArchiveEntry(org.apache.commons.compress.archivers.ArchiveEntry)
is called with an entry of unknown
size and data is written to a non-seekable stream - in this
case the default is Never
.
mode
- Whether Zip64 extensions will be used.public void finish() throws java.io.IOException
finish
in class ArchiveOutputStream
Zip64RequiredException
- if the archive's size exceeds 4
GByte or there are more than 65535 entries inside the archive
and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode)
is Zip64Mode.Never
.java.io.IOException
- if the user forgets to close the entry.private void writeCentralDirectoryInChunks() throws java.io.IOException
java.io.IOException
public void closeArchiveEntry() throws java.io.IOException
closeArchiveEntry
in class ArchiveOutputStream
java.io.IOException
- on errorZip64RequiredException
- if the entry's uncompressed or
compressed size exceeds 4 GByte and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode)
is Zip64Mode.Never
.private void closeCopiedEntry(boolean phased) throws java.io.IOException
phased
- This entry is second phase of a 2-phase zip creation, size, compressed size and crc
are known in ZipArchiveEntryjava.io.IOException
- on errorZip64RequiredException
- if the entry's uncompressed or
compressed size exceeds 4 GByte and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode)
is Zip64Mode.Never
.private void closeEntry(boolean actuallyNeedsZip64, boolean phased) throws java.io.IOException
java.io.IOException
private void preClose() throws java.io.IOException
java.io.IOException
public void addRawArchiveEntry(ZipArchiveEntry entry, java.io.InputStream rawStream) throws java.io.IOException
entry
- The archive entry to addrawStream
- The raw input stream of a different entry. May be compressed/encrypted.java.io.IOException
- If copying failsprivate void flushDeflater() throws java.io.IOException
java.io.IOException
private boolean handleSizesAndCrc(long bytesWritten, long crc, Zip64Mode effectiveMode) throws java.util.zip.ZipException
java.util.zip.ZipException
private boolean checkIfNeedsZip64(Zip64Mode effectiveMode) throws java.util.zip.ZipException
java.util.zip.ZipException
private boolean isZip64Required(ZipArchiveEntry entry1, Zip64Mode requestedMode)
private boolean isTooLageForZip32(ZipArchiveEntry zipArchiveEntry)
private void rewriteSizesAndCrc(boolean actuallyNeedsZip64) throws java.io.IOException
java.io.IOException
public void putArchiveEntry(ArchiveEntry archiveEntry) throws java.io.IOException
ArchiveOutputStream.closeArchiveEntry()
to complete the process.putArchiveEntry
in class ArchiveOutputStream
archiveEntry
- describes the entryjava.lang.ClassCastException
- if entry is not an instance of ZipArchiveEntryZip64RequiredException
- if the entry's uncompressed or
compressed size is known to exceed 4 GByte and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode)
is Zip64Mode.Never
.java.io.IOException
- if an I/O error occursprivate void putArchiveEntry(ArchiveEntry archiveEntry, boolean phased) throws java.io.IOException
closeArchiveEntry()
to complete the process.archiveEntry
- The archiveEntryphased
- If true size, compressedSize and crc required to be known up-front in the archiveEntryjava.lang.ClassCastException
- if entry is not an instance of ZipArchiveEntryZip64RequiredException
- if the entry's uncompressed or
compressed size is known to exceed 4 GByte and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode)
is Zip64Mode.Never
.java.io.IOException
private void setDefaults(ZipArchiveEntry entry)
private void validateSizeInformation(Zip64Mode effectiveMode) throws java.util.zip.ZipException
java.util.zip.ZipException
private boolean shouldAddZip64Extra(ZipArchiveEntry entry, Zip64Mode mode)
Returns true if
public void setComment(java.lang.String comment)
comment
- the commentpublic void setLevel(int level)
Default is Deflater.DEFAULT_COMPRESSION.
level
- the compression level.java.lang.IllegalArgumentException
- if an invalid compression
level is specified.public void setMethod(int method)
Default is DEFLATED.
method
- an int
from java.util.zip.ZipEntrypublic boolean canWriteEntryData(ArchiveEntry ae)
May return false if it is set up to use encryption or a compression method that hasn't been implemented yet.
canWriteEntryData
in class ArchiveOutputStream
ae
- the entry to testpublic void write(byte[] b, int offset, int length) throws java.io.IOException
write
in class java.io.OutputStream
b
- the byte array to writeoffset
- the start position to write fromlength
- the number of bytes to writejava.io.IOException
- on errorprivate void writeCounted(byte[] data) throws java.io.IOException
data
- the byte array to writejava.io.IOException
- on errorprivate void copyFromZipInputStream(java.io.InputStream src) throws java.io.IOException
java.io.IOException
public void close() throws java.io.IOException
close
in interface java.io.Closeable
close
in interface java.lang.AutoCloseable
close
in class java.io.OutputStream
java.io.IOException
- if an I/O error occurs.Zip64RequiredException
- if the archive's size exceeds 4
GByte or there are more than 65535 entries inside the archive
and setUseZip64(org.apache.commons.compress.archivers.zip.Zip64Mode)
is Zip64Mode.Never
.public void flush() throws java.io.IOException
flush
in interface java.io.Flushable
flush
in class java.io.OutputStream
java.io.IOException
- if an I/O error occurs.protected final void deflate() throws java.io.IOException
java.io.IOException
- on errorprotected void writeLocalFileHeader(ZipArchiveEntry ze) throws java.io.IOException
ze
- the entry to writejava.io.IOException
- on errorprivate void writeLocalFileHeader(ZipArchiveEntry ze, boolean phased) throws java.io.IOException
java.io.IOException
private byte[] createLocalFileHeader(ZipArchiveEntry ze, java.nio.ByteBuffer name, boolean encodable, boolean phased, long archiveOffset)
private void addUnicodeExtraFields(ZipArchiveEntry ze, boolean encodable, java.nio.ByteBuffer name) throws java.io.IOException
java.io.IOException
protected void writeDataDescriptor(ZipArchiveEntry ze) throws java.io.IOException
ze
- the entry to writejava.io.IOException
- on errorprotected void writeCentralFileHeader(ZipArchiveEntry ze) throws java.io.IOException
ze
- the entry to writejava.io.IOException
- on errorZip64RequiredException
- if the archive's size exceeds 4
GByte and #setUseZip64
is Zip64Mode.Never
.private byte[] createCentralFileHeader(ZipArchiveEntry ze) throws java.io.IOException
java.io.IOException
private byte[] createCentralFileHeader(ZipArchiveEntry ze, java.nio.ByteBuffer name, ZipArchiveOutputStream.EntryMetaData entryMetaData, boolean needsZip64Extra) throws java.io.IOException
ze
- the entry to writename
- The encoded nameentryMetaData
- meta data for this filejava.io.IOException
- on errorprivate void handleZip64Extra(ZipArchiveEntry ze, long lfhOffset, boolean needsZip64Extra)
protected void writeCentralDirectoryEnd() throws java.io.IOException
java.io.IOException
- on errorZip64RequiredException
- if the archive's size exceeds 4
GByte or there are more than 65535 entries inside the archive
and #setUseZip64
is Zip64Mode.Never
.protected void writeZip64CentralDirectory() throws java.io.IOException
java.io.IOException
- on errorprotected final void writeOut(byte[] data) throws java.io.IOException
data
- the byte array to writejava.io.IOException
- on errorprotected final void writeOut(byte[] data, int offset, int length) throws java.io.IOException
data
- the byte array to writeoffset
- the start position to write fromlength
- the number of bytes to writejava.io.IOException
- on errorprivate GeneralPurposeBit getGeneralPurposeBits(boolean utfFallback, boolean usesDataDescriptor)
private int versionNeededToExtract(int zipMethod, boolean zip64, boolean usedDataDescriptor)
private boolean usesDataDescriptor(int zipMethod, boolean phased)
private int versionNeededToExtractMethod(int zipMethod)
public ArchiveEntry createArchiveEntry(java.io.File inputFile, java.lang.String entryName) throws java.io.IOException
The name will be adjusted to end with a forward slash "/" if the file is a directory. If the file is not a directory a potential trailing forward slash will be stripped from the entry name.
Must not be used if the stream has already been closed.
createArchiveEntry
in class ArchiveOutputStream
inputFile
- the file to create the entry fromentryName
- name to use for the entryjava.io.IOException
- if an I/O error occursprivate Zip64ExtendedInformationExtraField getZip64Extra(ZipArchiveEntry ze)
private boolean hasZip64Extra(ZipArchiveEntry ze)
private Zip64Mode getEffectiveZip64Mode(ZipArchiveEntry ze)
private ZipEncoding getEntryEncoding(ZipArchiveEntry ze)
private java.nio.ByteBuffer getName(ZipArchiveEntry ze) throws java.io.IOException
java.io.IOException
void destroy() throws java.io.IOException
This method only exists to support tests that generate corrupt archives so they can clean up any temporary files.
java.io.IOException