Packer

CLASS_ATTRIBUTE_PFX

static val CLASS_ATTRIBUTE_PFX: String

When concatenated with a class attribute name, indicates the format of that attribute, using the layout language specified in the JSR 200 specification.

For example, the effect of this option is built in: pack.class.attribute.SourceFile=RUH.

The special strings ERROR, STRIP, and PASS are also allowed, with the same meaning as UNKNOWN_ATTRIBUTE. This provides a way for users to request that specific attributes be refused, stripped, or passed bitwise (with no class compression).

Code like this might be used to support attributes for JCOV:

<code>
      Map p = packer.properties();
      p.put(CODE_ATTRIBUTE_PFX+"CoverageTable",       "NH[PHHII]");
      p.put(CODE_ATTRIBUTE_PFX+"CharacterRangeTable", "NH[PHPOHIIH]");
      p.put(CLASS_ATTRIBUTE_PFX+"SourceID",           "RUH");
      p.put(CLASS_ATTRIBUTE_PFX+"CompilationID",      "RUH");
  </code>

Code like this might be used to strip debugging attributes:

<code>
      Map p = packer.properties();
      p.put(CODE_ATTRIBUTE_PFX+"LineNumberTable",    STRIP);
      p.put(CODE_ATTRIBUTE_PFX+"LocalVariableTable", STRIP);
      p.put(CLASS_ATTRIBUTE_PFX+"SourceFile",        STRIP);
  </code>

Value: "pack.class.attribute."

CODE_ATTRIBUTE_PFX

static val CODE_ATTRIBUTE_PFX: String

When concatenated with a code attribute name, indicates the format of that attribute. For example, the effect of this option is built in: pack.code.attribute.LocalVariableTable=NH[PHOHRUHRSHH]. The special strings ERROR, STRIP, and PASS are also allowed.

Value: "pack.code.attribute."

DEFLATE_HINT

static val DEFLATE_HINT: String

If this property is set to TRUE or FALSE, the packer will set the deflation hint accordingly in the output archive, and will not transmit the individual deflation hints of archive elements.

If this property is set to the special string KEEP, the packer will attempt to determine an independent deflation hint for each available element of the input archive, and transmit this hint separately.

The default is KEEP, which preserves the input information, but may cause the transmitted archive to be larger than necessary.

It is up to the unpacker implementation to take action upon the hint to suitably compress the elements of the resulting unpacked jar.

The deflation hint of a ZIP or JAR element indicates whether the element was deflated or stored directly.

Value: "pack.deflate.hint"

EFFORT

static val EFFORT: String

If this property is set to a single decimal digit, the packer will use the indicated amount of effort in compressing the archive. Level 1 may produce somewhat larger size and faster compression speed, while level 9 will take much longer but may produce better compression.

The special value 0 instructs the packer to copy through the original JAR file directly, with no compression. The JSR 200 standard requires any unpacker to understand this special case as a pass-through of the entire archive.

The default is 5, investing a modest amount of time to produce reasonable compression.

Value: "pack.effort"

ERROR

static val ERROR: String

The string "error", a possible value for certain properties.

Value: "error"

FALSE

static val FALSE: String

The string "false", a possible value for certain properties.

Value: "false"

FIELD_ATTRIBUTE_PFX

static val FIELD_ATTRIBUTE_PFX: String

When concatenated with a field attribute name, indicates the format of that attribute. For example, the effect of this option is built in: pack.field.attribute.Deprecated=. The special strings ERROR, STRIP, and PASS are also allowed.

Value: "pack.field.attribute."

KEEP

static val KEEP: String

The string "keep", a possible value for certain properties.

Value: "keep"

KEEP_FILE_ORDER

static val KEEP_FILE_ORDER: String

If this property is set to TRUE, the packer will transmit all elements in their original order within the source archive.

If it is set to FALSE, the packer may reorder elements, and also remove JAR directory entries, which carry no useful information for Java applications. (Typically this enables better compression.)

The default is TRUE, which preserves the input information, but may cause the transmitted archive to be larger than necessary.

Value: "pack.keep.file.order"

LATEST

static val LATEST: String

The string "latest", a possible value for certain properties.

Value: "latest"

METHOD_ATTRIBUTE_PFX

static val METHOD_ATTRIBUTE_PFX: String

When concatenated with a method attribute name, indicates the format of that attribute. For example, the effect of this option is built in: pack.method.attribute.Exceptions=NH[RCH]. The special strings ERROR, STRIP, and PASS are also allowed.

Value: "pack.method.attribute."

MODIFICATION_TIME

static val MODIFICATION_TIME: String

If this property is set to the special string LATEST, the packer will attempt to determine the latest modification time, among all the available entries in the original archive or the latest modification time of all the available entries in each segment. This single value will be transmitted as part of the segment and applied to all the entries in each segment, SEGMENT_LIMIT.

This can marginally decrease the transmitted size of the archive, at the expense of setting all installed files to a single date.

If this property is set to the special string KEEP, the packer transmits a separate modification time for each input element.

The default is KEEP, which preserves the input information, but may cause the transmitted archive to be larger than necessary.

It is up to the unpacker implementation to take action to suitably set the modification time of each element of its output file.

Value: "pack.modification.time"

PASS

static val PASS: String

The string "pass", a possible value for certain properties.

Value: "pass"

PASS_FILE_PFX

static val PASS_FILE_PFX: String

Indicates that a file should be passed through bytewise, with no compression. Multiple files may be specified by specifying additional properties with distinct strings appended, to make a family of properties with the common prefix.

There is no pathname transformation, except that the system file separator is replaced by the JAR file separator '/'.

The resulting file names must match exactly as strings with their occurrences in the JAR file.

If a property value is a directory name, all files under that directory will be passed also.

Examples:

<code>Map p = packer.properties();
      p.put(PASS_FILE_PFX+0, "mutants/Rogue.class");
      p.put(PASS_FILE_PFX+1, "mutants/Wolverine.class");
      p.put(PASS_FILE_PFX+2, "mutants/Storm.class");
      # Pass all files in an entire directory hierarchy:
      p.put(PASS_FILE_PFX+3, "police/");
  </code>

Value: "pack.pass.file."

PROGRESS

static val PROGRESS: String

The unpacker's progress as a percentage, as periodically updated by the unpacker. Values of 0 - 100 are normal, and -1 indicates a stall. Progress can be monitored by polling the value of this property.

At a minimum, the unpacker must set progress to 0 at the beginning of a packing operation, and to 100 at the end.

Value: "pack.progress"

SEGMENT_LIMIT

static val SEGMENT_LIMIT: String

This property is a numeral giving the estimated target size N (in bytes) of each archive segment. If a single input file requires more than N bytes, it will be given its own archive segment.

As a special case, a value of -1 will produce a single large segment with all input files, while a value of 0 will produce one segment for each class. Larger archive segments result in less fragmentation and better compression, but processing them requires more memory.

The size of each segment is estimated by counting the size of each input file to be transmitted in the segment, along with the size of its name and other transmitted properties.

The default is -1, which means the packer will always create a single segment output file. In cases where extremely large output files are generated, users are strongly encouraged to use segmenting or break up the input file into smaller JARs.

A 10Mb JAR packed without this limit will typically pack about 10% smaller, but the packer may require a larger Java heap (about ten times the segment limit).

Value: "pack.segment.limit"

STRIP

static val STRIP: String

The string "strip", a possible value for certain properties.

Value: "strip"

TRUE

static val TRUE: String

The string "true", a possible value for certain properties.

Value: "true"

UNKNOWN_ATTRIBUTE

static val UNKNOWN_ATTRIBUTE: String

Indicates the action to take when a class-file containing an unknown attribute is encountered. Possible values are the strings ERROR, STRIP, and PASS.

The string ERROR means that the pack operation as a whole will fail, with an exception of type IOException. The string STRIP means that the attribute will be dropped. The string PASS means that the whole class-file will be passed through (as if it were a resource file) without compression, with a suitable warning. This is the default value for this property.

Examples:

<code>Map p = pack200.getProperties();
      p.put(UNKNOWN_ATTRIBUTE, ERROR);
      p.put(UNKNOWN_ATTRIBUTE, STRIP);
      p.put(UNKNOWN_ATTRIBUTE, PASS);
  </code>

Value: "pack.unknown.attribute"

addPropertyChangeListener

open fun addPropertyChangeListener(listener: PropertyChangeListener!): Unit

Deprecated: The dependency on PropertyChangeListener creates a significant impediment to future modularization of the Java platform. This method will be removed in a future release. Applications that need to monitor progress of the packer can poll the value of the PROGRESS property instead.

Registers a listener for PropertyChange events on the properties map. This is typically used by applications to update a progress bar.

The default implementation of this method does nothing and has no side-effects.

WARNING: This method is omitted from the interface declaration in all subset Profiles of Java SE that do not include the java.beans package.

pack

abstract fun pack(
    in: JarFile!, 
    out: OutputStream!
): Unit

Takes a JarFile and converts it into a Pack200 archive.

Closes its input but not its output. (Pack200 archives are appendable.)

pack

abstract fun pack(
    in: JarInputStream!, 
    out: OutputStream!
): Unit

Takes a JarInputStream and converts it into a Pack200 archive.

Closes its input but not its output. (Pack200 archives are appendable.)

The modification time and deflation hint attributes are not available, for the JAR manifest file and its containing directory.

properties

abstract fun properties(): SortedMap<String!, String!>!

Get the set of this engine's properties. This set is a "live view", so that changing its contents immediately affects the Packer engine, and changes from the engine (such as progress indications) are immediately visible in the map.

The property map may contain pre-defined implementation specific and default properties. Users are encouraged to read the information and fully understand the implications, before modifying pre-existing properties.

Implementation specific properties are prefixed with a package name associated with the implementor, beginning with com. or a similar prefix. All property names beginning with pack. and unpack. are reserved for use by this API.

Unknown properties may be ignored or rejected with an unspecified error, and invalid entries may cause an unspecified error to be thrown.

The returned map implements all optional SortedMap operations

removePropertyChangeListener

open fun removePropertyChangeListener(listener: PropertyChangeListener!): Unit

Deprecated: The dependency on PropertyChangeListener creates a significant impediment to future modularization of the Java platform. This method will be removed in a future release.

Remove a listener for PropertyChange events, added by the addPropertyChangeListener.

The default implementation of this method does nothing and has no side-effects.

WARNING: This method is omitted from the interface declaration in all subset Profiles of Java SE that do not include the java.beans package.