Module jdk.jlink
Package jdk.tools.jlink.plugin

## Class Pool.ModuleData

- java.lang.Object
- - jdk.tools.jlink.plugin.Pool.ModuleData

Enclosing class:
  Pool

    public static class Pool.ModuleData
    extends Object

A ModuleData is the elementary unit of data inside an image. It is generally a file. e.g.: a java class file, a resource file, a shared library, ...
A ModuleData is identified by a path of the form:

- For jimage content: /{module name}/{package1}/.../{packageN}/{file name}
- For other files (shared lib, launchers, config, ...):/{module name}/ bin|conf|native/{dir1}>/.../{dirN}/{file name}

### Constructor Summary

Constructors
Constructor and Description
`ModuleData(String module, String path, Pool.ModuleDataType type, InputStream stream, long length)` Create a new ModuleData.

### Method Summary

All Methods Instance Methods Concrete Methods
`boolean` `equals(Object other)` Indicates whether some other object is "equal to" this one.
`byte[]` `getBytes()` The ModuleData content as an array of byte.
`long` `getLength()` The ModuleData content length.
`String` `getModule()` The ModuleData module name.
`String` `getPath()` The ModuleData path.
`Pool.ModuleDataType` `getType()` The ModuleData type.
`int` `hashCode()` Returns a hash code value for the object.
`InputStream` `stream()` The ModuleData stream.
`String` `toString()` Returns a string representation of the object.

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

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

### Constructor Detail

#### ModuleData

    public ModuleData(String module,
                      String path,
                      Pool.ModuleDataType type,
                      InputStream stream,
                      long length)

Create a new ModuleData.

Parameters:
  `module` - The module name.
  `path` - The data path identifier.
  `type` - The data type.
  `stream` - The data content stream.
  `length` - The stream length.

### Method Detail

#### getModule

    public final String getModule()

The ModuleData module name.

Returns:
  The module name.

#### getPath

    public final String getPath()

The ModuleData path.

Returns:
  The module path.

#### getType

    public final Pool.ModuleDataType getType()

The ModuleData type.

Returns:
  The data type.

#### getBytes

    public byte[] getBytes()

The ModuleData content as an array of byte.

Returns:
  An Array of bytes.

#### getLength

    public long getLength()

The ModuleData content length.

Returns:
  The length.

#### stream

    public InputStream stream()

The ModuleData stream.

Returns:
  The module data stream.

#### hashCode

    public int hashCode()

Description copied from class: `java.lang.Object`
Returns a hash code value for the object. This method is supported for the benefit of hash tables such as those provided by `HashMap`.

The general contract of `hashCode` is:

- Whenever it is invoked on the same object more than once during an execution of a Java application, the `hashCode` method must consistently return the same integer, provided no information used in `equals` comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
- If two objects are equal according to the `equals(Object)` method, then calling the `hashCode` method on each of the two objects must produce the same integer result.
- It is not required that if two objects are unequal according to the `Object.equals(java.lang.Object)` method, then calling the `hashCode` method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.

As much as is reasonably practical, the hashCode method defined by class `Object` does return distinct integers for distinct objects. (The hashCode may or may not be implemented as some function of an object's memory address at some point in time.)

Overrides:
  `hashCode` in class `Object`
Returns:
  a hash code value for this object.
See Also:
  `Object.equals(java.lang.Object)`, `System.identityHashCode(java.lang.Object)`

#### equals

    public boolean equals(Object other)

Description copied from class: `java.lang.Object`
Indicates whether some other object is "equal to" this one.

The `equals` method implements an equivalence relation on non-null object references:

- It is reflexive: for any non-null reference value `x`, `x.equals(x)` should return `true`.
- It is symmetric: for any non-null reference values `x` and `y`, `x.equals(y)` should return `true` if and only if `y.equals(x)` returns `true`.
- It is transitive: for any non-null reference values `x`, `y`, and `z`, if `x.equals(y)` returns `true` and `y.equals(z)` returns `true`, then `x.equals(z)` should return `true`.
- It is consistent: for any non-null reference values `x` and `y`, multiple invocations of `x.equals(y)` consistently return `true` or consistently return `false`, provided no information used in `equals` comparisons on the objects is modified.
- For any non-null reference value `x`, `x.equals(null)` should return `false`.

The `equals` method for class `Object` implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values `x` and `y`, this method returns `true` if and only if `x` and `y` refer to the same object (`x == y` has the value `true`).

Note that it is generally necessary to override the `hashCode` method whenever this method is overridden, so as to maintain the general contract for the `hashCode` method, which states that equal objects must have equal hash codes.

Overrides:
  `equals` in class `Object`
Parameters:
  `other` - the reference object with which to compare.
Returns:
  `true` if this object is the same as the obj argument; `false` otherwise.
See Also:
  `Object.hashCode()`, `HashMap`

#### toString

    public String toString()

Description copied from class: `java.lang.Object`
Returns a string representation of the object. In general, the `toString` method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method.

The `toString` method for class `Object` returns a string consisting of the name of the class of which the object is an instance, the at-sign character ``@`', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:

>      getClass().getName() + '@' + Integer.toHexString(hashCode())

Overrides:
  `toString` in class `Object`
Returns:
  a string representation of the object.