<?xml version="1.0"?>
<!--

   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.

-->
<document>
    <properties>
        <title>Overview</title>
        <author email="dev@commons.apache.org">Commons Documentation Team</author>
    </properties>
    <body>
        <section name="Apache Commons Compress&#x2122;">
            <p>
                The Apache Commons Compress library defines an API for
                working with ar, cpio, Unix dump, tar, zip, gzip, XZ, Pack200,
                bzip2, 7z, arj, lzma, snappy, DEFLATE and Z files.
            </p>
            <p>
                The code in this component has many origins:
            </p>
            <ul>
              <li>The bzip2, tar and zip support came from Avalon's
                Excalibur, but originally from Ant, as far as life in
                Apache goes. The tar package is originally Tim Endres'
                public domain package. The bzip2 package is based on
                the work done by Keiron Liddle as well as Julian Seward's
                <a href="http://www.bzip.org/index.html">libbzip2</a>.
                It has migrated
                via:<br/> Ant -&gt; Avalon-Excalibur -&gt; Commons-IO
                -&gt; Commons-Compress.</li>
              <li>The cpio package has been contributed by Michael Kuss
                and
                the <a href="http://jrpm.sourceforge.net/">jRPM</a>
                project.</li>
            </ul>

        </section>

        <section name="Status">
          <p>The current release is 1.11 and requires Java 5.</p>

          <p>Below we highlight some new features, for a full list
          of changes see the <a href="changes-report.html">Changes
          Report</a>.</p>

          <subsection name="What's new in 1.11?">
            <ul>
              <li>Added read-only support for BZIP2 compression used
              inside of ZIP archives.</li>
              <li>Speed improvements in <code>SevenZFile</code></li>
              <li>Various fixes and improvements for tar, ar, snappy
              and zip.</li>
            </ul>
          </subsection>

          <!--subsection name="What's coming in 1.12?">
            <ul>
            </ul>
          </subsection-->
        </section>

        <section name="Documentation">
          <p>The compress component is split into <em>compressors</em> and
            <em>archivers</em>.  While <em>compressors</em>
            (un)compress streams that usually store a single
            entry, <em>archivers</em> deal with archives that contain
            structured content represented
            by <code>ArchiveEntry</code> instances which in turn
            usually correspond to single files or directories.</p>

          <p>Currently the bzip2, Pack200, XZ, gzip, lzma and Z formats are
            supported as compressors where gzip support is mostly provided by
            the <code>java.util.zip</code> package and Pack200 support
            by the <code>java.util.jar</code> package of the Java
            class library.  XZ and lzma support is provided by the public
            domain <a href="http://tukaani.org/xz/java.html">XZ for
            Java</a> library.  As of Commons Compress 1.11 support for
            the lzma, Z and Snappy formats is read-only.</p>

          <p>The ar, arj, cpio, dump, tar, 7z and zip formats are supported as
            archivers where the <a href="zip.html">zip</a>
            implementation provides capabilities that go beyond the
            features found in java.util.zip.  As of Commons Compress
            1.11 support for the dump and arj formats is
            read-only - 7z can read most compressed and encrypted
            archives but only write unencrypted ones.  LZMA(2) support
            in 7z requires <a href="http://tukaani.org/xz/java.html">XZ for
            Java</a> as well.</p>

          <p>The compress component provides abstract base classes for
            compressors and archivers together with factories that can
            be used to choose implementations by algorithm name.  In
            the case of input streams the factories can also be used
            to guess the format and provide the matching
            implementation.</p>

          <ul>
            <li>The <a href="examples.html">examples page</a> contains
            more detailed information and some examples.</li>
            <li>The <a href="limitations.html">known limitations and
            problems</a> page lists the currently known problems
            grouped by the format they apply to.</li>
            <li>The <a href="apidocs/index.html">Javadoc</a> of the latest GIT</li>
            <li>The <a href="https://git-wip-us.apache.org/repos/asf?p=commons-compress.git;a=tree">GIT
                repository</a> can be browsed.</li>
            </ul>
        </section>
        <section name="Releases">
          <p>
            <a href="http://commons.apache.org/compress/download_compress.cgi">Download now!</a>
          </p>
        </section>
    </body>
</document>
