Package org.apache.commons.compress.harmony.unpack200

# Class Segment

java.lang.Object
org.apache.commons.compress.harmony.unpack200.Segment

public class Segment extends Object
A Pack200 archive consists of one or more segments. Each segment is stand-alone, in the sense that every segment has the magic number header; thus, every segment is also a valid archive. However, it is possible to combine (non-GZipped) archives into a single large archive by concatenation alone. Thus, all the hard work in unpacking an archive falls to understanding a segment.

The first component of a segment is the header; this contains (amongst other things) the expected counts of constant pool entries, which in turn defines how many values need to be read from the stream. Because values are variable width (see `Codec`), it is not possible to calculate the start of the next segment, although one of the header values does hint at the size of the segment if non-zero, which can be used for buffering purposes.

Note that this does not perform any buffering of the input stream; each value will be read on a byte-by-byte basis. It does not perform GZip decompression automatically; both of these are expected to be done by the caller if the stream has the magic header for GZip streams (`GZIPInputStream.GZIP_MAGIC`). In any case, if GZip decompression is being performed the input stream will be buffered at a higher level, and thus this can read on a byte-oriented basis.

Format:

       pack200_archive:
          (pack200_segment)+

       pack200_segment:
          segment_header
          *band_headers :BYTE1
          cp_bands
          attr_definition_bands
          ic_bands
          class_bands
          bc_bands
          file_bands

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final int`
  `LOG_LEVEL_QUIET`
  Log level quiet 0
  `static final int`
  `LOG_LEVEL_STANDARD`
  Log level standard 1
  `static final int`
  `LOG_LEVEL_VERBOSE`
  Log level verbose 2

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `Segment()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected AttrDefinitionBands`
  `getAttrDefinitionBands()`
  `protected ClassBands`
  `getClassBands()`
  `SegmentConstantPool`
  `getConstantPool()`
  Gets the constant pool.
  `protected CpBands`
  `getCpBands()`
  Gets the constant pool bands.
  `protected IcBands`
  `getIcBands()`
  Gets the inner class bands.
  `SegmentHeader`
  `getSegmentHeader()`
  Gets the segment header.
  `void`
  `log(int messageLevel, String message)`
  Logs a message.
  `void`
  `overrideDeflateHint(boolean deflateHint)`
  Overrides the archive's deflate hint with the given boolean
  `void`
  `setLogLevel(int logLevel)`
  Sets the log level.
  `void`
  `setLogStream(OutputStream logStream)`
  Sets the log output stream.
  `void`
  `setPreRead(boolean value)`
  Sets whether unpacking buffers its input.
  `void`
  `unpack(InputStream inputStream, JarOutputStream out)`
  Unpacks a packed stream (either .pack. or .pack.gz) into a corresponding JarOuputStream.
  `void`
  `writeJar(JarOutputStream out)`
  Writes the segment to an output stream.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### LOG_LEVEL_VERBOSE

    public static final int LOG_LEVEL_VERBOSE
    Log level verbose 2
    See Also:
      - Constant Field Values

  - ### LOG_LEVEL_STANDARD

    public static final int LOG_LEVEL_STANDARD
    Log level standard 1
    See Also:
      - Constant Field Values

  - ### LOG_LEVEL_QUIET

    public static final int LOG_LEVEL_QUIET
    Log level quiet 0
    See Also:
      - Constant Field Values

- ## Constructor Details

  - ### Segment

    public Segment()

- ## Method Details

  - ### getAttrDefinitionBands

    protected AttrDefinitionBands getAttrDefinitionBands()

  - ### getClassBands

    protected ClassBands getClassBands()

  - ### getConstantPool

    public SegmentConstantPool getConstantPool()
    Gets the constant pool.
    Returns:
      the constant pool.

  - ### getCpBands

    protected CpBands getCpBands()
    Gets the constant pool bands.
    Returns:
      the constant pool bands.

  - ### getIcBands

    protected IcBands getIcBands()
    Gets the inner class bands.
    Returns:
      the inner class bands.

  - ### getSegmentHeader

    public SegmentHeader getSegmentHeader()
    Gets the segment header.
    Returns:
      the segment header.

  - ### log

    public void log(int messageLevel, String message)
    Logs a message.
    Parameters:
      `messageLevel` - the message level.
      `message` - the message.

  - ### overrideDeflateHint

    public void overrideDeflateHint(boolean deflateHint)
    Overrides the archive's deflate hint with the given boolean
    Parameters:
      `deflateHint` - the deflate hint to use

  - ### setLogLevel

    public void setLogLevel(int logLevel)
    Sets the log level.
    Parameters:
      `logLevel` - the log level.

  - ### setLogStream

    public void setLogStream(OutputStream logStream)
    Sets the log output stream.
    Parameters:
      `logStream` - log output stream.

  - ### setPreRead

    public void setPreRead(boolean value)
    Sets whether unpacking buffers its input.
    Parameters:
      `value` - whether unpacking buffers its input.

  - ### unpack

    public void unpack(InputStream inputStream, JarOutputStream out) throws IOException, Pack200Exception
    Unpacks a packed stream (either .pack. or .pack.gz) into a corresponding JarOuputStream.
    Parameters:
      `inputStream` - a packed input stream, preferably a `BoundedInputStream`.
      `out` - output stream.
    Throws:
      `Pack200Exception` - if there is a problem unpacking
      `IOException` - if there is a problem with I/O during unpacking

  - ### writeJar

    public void writeJar(JarOutputStream out) throws IOException
    Writes the segment to an output stream. The output stream should be pre-buffered for efficiency. Also takes the same input stream for reading, since the file bits may not be loaded and thus just copied from one stream to another. Doesn't close the output stream when finished, in case there are more entries (for example further segments) to be written.
    Parameters:
      `out` - the JarOutputStream to write data to
    Throws:
      `IOException` - if an error occurs while reading or writing to the streams