<!--
   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with
   the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-->
<html>

<head>
<meta http-equiv="Content-Language" content="en-us">
<link rel="stylesheet" type="text/css" href="style.css">
<title>Compressed Resource</title>
</head>

<body>

<h2><a name="compresource">Compressed Resources</a></h2>

<p>For each of the supported compression formats there is a
  correspondig resource that wraps around another resource providing
  compression or decompression on the fly.  A single element resource
  collection must be specified as a nested element.</p>

<a name="decompressConcatenated">
<p>Resources for the formats that support files holding multiple
  compressed streams (bzip2, gzip, lz4 and xz) support a boolean attribute
  decompressConcatenated.  If set to true all streams will be
  concatenated and treated as a single resource.  With the default
  value false only the first stream is uncompressed.</p>
</a>

<h2><a name="brotliresource">brotliresource</a></h2>

<p>This is a <a href="#compresource">compressed resource</a> using the
  Brotli compression.</p>

  <p><em>Since Compress Antlib 1.5</em>

<h4>Examples</h4>

<pre>
&lt;cmp:tarentry xmlns:cmp="antlib:org.apache.ant.compress"
    name="some-file.txt"&gt;
  &lt;cmp:brotliresource&gt;
    &lt;file file="some-archive.tar.br"/&gt;
  &lt;/cmp:brotliresource&gt;
&lt;/cmp:tarentry&gt;
</pre>

<p>Represents the entry named some-file.txt in archive
  some-archive.tar.br where the <code>brotliresource</code> provides
  the decompression of the archive.</p>

<h2><a name="bzip2resource">bzip2resource</a></h2>

<p>This is a <a href="#compresource">compressed resource</a> using the
  BZIP2 compression.</p>

<p>This resource supports
  the <a href="#decompressConcatenated">decompressConcatenated</a>
  attribute.</p>

<h4>Examples</h4>

<pre>
&lt;cmp:tarentry xmlns:cmp="antlib:org.apache.ant.compress"
    name="some-file.txt"&gt;
  &lt;cmp:bzip2resource&gt;
    &lt;file file="some-archive.tar.bz2"/&gt;
  &lt;/cmp:bzip2resource&gt;
&lt;/cmp:tarentry&gt;
</pre>

<p>Represents the entry named some-file.txt in archive
  some-archive.tar.bz2 where the <code>bzip2resource</code> provides
  the decompression of the archive.</p>

<h2><a name="deflateresource">deflateresource</a></h2>

<p><em>Since Apache Compress Antlib 1.5</em>.</p>

<p>This is a <a href="#compresource">compressed resource</a> using the
  DEFLATE compression.</p>

  <p>This resource supports the following additional attributes:</p>

  <table border="1" cellpadding="2" cellspacing="0">
    <tr>
      <td valign="top"><b>Attribute</b></td>
      <td valign="top"><b>Description</b></td>
      <td align="center" valign="top"><b>Required</b></td>
    </tr>
    <tr>
      <td valign="top">zlibheader</td>
      <td valign="top">Whether to write or expect ZLIB headers. Unfortunately
      it is currently not possible to detect whether zlib headers have
      been used when reading.</td>
      <td valign="top" align="center">No, defaults to <code>true</code></td>
    </tr>
  </table>

<h2><a name="deflate64resource">deflate64resource</a></h2>

<p><em>Since Apache Compress Antlib 1.6</em>.</p>

<p>This is a <a href="#compresource">compressed resource</a> using the
  DEFLATE64 compression.</p>

<h2><a name="gzipresource">gzipresource</a></h2>

<p>This is a <a href="#compresource">compressed resource</a> using the
  GZIP compression.</p>

<p>This resource supports
  the <a href="#decompressConcatenated">decompressConcatenated</a>
  attribute.</p>

<h4>Examples</h4>

<pre>
&lt;cmp:tarentry xmlns:cmp="antlib:org.apache.ant.compress"
    name="some-file.txt"&gt;
  &lt;cmp:gzipresource&gt;
    &lt;file file="some-archive.tar.gz"/&gt;
  &lt;/cmp:gzipresource&gt;
&lt;/cmp:tarentry&gt;
</pre>

<p>Represents the entry named some-file.txt in archive
  some-archive.tar.gz where the <code>gzipresource</code> provides
  the decompression of the archive.</p>

<h2><a name="lz4resource">lz4resource</a></h2>

<p><em>Since Apache Compress Antlib 1.5</em>.</p>

<p>This is a <a href="#compresource">compressed resource</a> using the
  LZ4 compression.</p>

<p>This resource supports
  the <a href="#decompressConcatenated">decompressConcatenated</a>
  attribute if the frame format is used.</p>

<h4>Parameters</h4>
  <p>In addition to the attributes supported by all uncompressing resources
    this resource also supports.</p>
  <table border="1" cellpadding="2" cellspacing="0">
    <tr>
      <td valign="top"><b>Attribute</b></td>
      <td valign="top"><b>Description</b></td>
      <td align="center" valign="top"><b>Required</b></td>
    </tr>
    <tr>
      <td valign="top">framed</td>
      <td valign="top">Whether the input is expected to use
      the <a href="http://lz4.github.io/lz4/lz4_Frame_format.html">frame
     format</a>.</td>
      <td align="center" valign="top">No, defaults to true.</td>
    </tr>
  </table>

<h4>Examples</h4>

<pre>
&lt;cmp:tarentry xmlns:cmp="antlib:org.apache.ant.compress"
    name="some-file.txt"&gt;
  &lt;cmp:lz4resource&gt;
    &lt;file file="some-archive.tar.lz4"/&gt;
  &lt;/cmp:lz4resource&gt;
&lt;/cmp:tarentry&gt;
</pre>

<p>Represents the entry named some-file.txt in archive
  some-archive.tar.lz4 where the <code>lz4resource</code> provides
  the decompression of the archive.</p>

<h2><a name="lzmaresource">lzmaresource</a></h2>

<p><em>Since Apache Compress Antlib 1.3</em>.</p>

<p>This is a <a href="#compresource">compressed resource</a> using the
  LZMA compression.</p>

<h4>Examples</h4>

<pre>
&lt;cmp:tarentry xmlns:cmp="antlib:org.apache.ant.compress"
    name="some-file.txt"&gt;
  &lt;cmp:lzmaresource&gt;
    &lt;file file="some-archive.tar.lzma"/&gt;
  &lt;/cmp:lzmaresource&gt;
&lt;/cmp:tarentry&gt;
</pre>

<p>Represents the entry named some-file.txt in archive
  some-archive.tar.lzma where the <code>lzmaresource</code> provides
  the decompression of the archive.</p>

<h2><a name="pack200resource">pack200resource</a></h2>

<p>This is a <a href="#compresource">compressed resource</a> using the
  <a href="http://download.oracle.com/javase/1.5.0/docs/api/java/util/jar/Pack200.html">Pack200</a>
  compression.</p>

<h4>Examples</h4>

<pre>
&lt;cmp:zipentry xmlns:cmp="antlib:org.apache.ant.compress"
    name="SomeFile.class"&gt;
  &lt;cmp:pack200resource&gt;
    &lt;file file="some-archive.pack"/&gt;
  &lt;/cmp:pack200resource&gt;
&lt;/cmp:zipentry&gt;
</pre>

<p>Represents the entry named Somefile.class in the Pack200 compressed
  JAR some-archive.pack where the <code>pack200resource</code>
  provides the decompression of the archive.</p>

<h2><a name="snappyresource">snappyresource</a></h2>

<p><em>Since Apache Compress Antlib 1.4</em>.</p>

<p>This is a <a href="#compresource">compressed resource</a> using the
  <a href="http://code.google.com/p/snappy/">Snappy</a>
  compression.</p>

<h4>Parameters</h4>
  <p>In addition to the attributes supported by all uncompressing resources
    this resource also supports.</p>
  <table border="1" cellpadding="2" cellspacing="0">
    <tr>
      <td valign="top"><b>Attribute</b></td>
      <td valign="top"><b>Description</b></td>
      <td align="center" valign="top"><b>Required</b></td>
    </tr>
    <tr>
      <td valign="top">framed</td>
      <td valign="top">Whether the input is expected to use
      the <a href="http://code.google.com/p/snappy/source/browse/trunk/framing_format.txt">framing
     format</a>.</td>
      <td align="center" valign="top">No, defaults to true.</td>
    </tr>
  </table>

<h4>Examples</h4>

<pre>
&lt;cmp:tarentry xmlns:cmp="antlib:org.apache.ant.compress"
    name="some-file.txt"&gt;
  &lt;cmp:snappyresource&gt;
    &lt;file file="some-archive.tar.sz"/&gt;
  &lt;/cmp:snappyresource&gt;
&lt;/cmp:tarentry&gt;
</pre>

<p>Represents the entry named some-file.txt in archive
  some-archive.tar.sz where the <code>snappyresource</code> provides
  the decompression of the archive.</p>

<h2><a name="xzresource">xzresource</a></h2>

<p>This is a <a href="#compresource">compressed resource</a> using the
  XZ compression.</p>

<p>This resource supports
  the <a href="#decompressConcatenated">decompressConcatenated</a>
  attribute.</p>

<h4>Examples</h4>

<pre>
&lt;cmp:tarentry xmlns:cmp="antlib:org.apache.ant.compress"
    name="some-file.txt"&gt;
  &lt;cmp:xzresource&gt;
    &lt;file file="some-archive.tar.xz"/&gt;
  &lt;/cmp:xzresource&gt;
&lt;/cmp:tarentry&gt;
</pre>

<p>Represents the entry named some-file.txt in archive
  some-archive.tar.xz where the <code>xzresource</code> provides
  the decompression of the archive.</p>

<h2><a name="zresource">zresource</a></h2>

<p><em>Since Apache Compress Antlib 1.4</em>.</p>

<p>This is a <a href="#compresource">compressed resource</a> using the
  traditional Unix compress (.Z) compression.</p>

<h4>Examples</h4>

<pre>
&lt;cmp:tarentry xmlns:cmp="antlib:org.apache.ant.compress"
    name="some-file.txt"&gt;
  &lt;cmp:zresource&gt;
    &lt;file file="some-archive.tar.Z"/&gt;
  &lt;/cmp:zresource&gt;
&lt;/cmp:tarentry&gt;
</pre>

<p>Represents the entry named some-file.txt in archive
  some-archive.tar.Z where the <code>zresource</code> provides
  the decompression of the archive.</p>
