For a mapping request, the result mapping will call the first mapping, and then the second mapping for each path that the first mapping returned.

If any of the arguments are null, the other one is returned.

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.

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(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. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the Java™ programming language.)

The identity resource mapping will not transform the paths, and returns them as is.

The method is called when an entry from another archive is being included in the created ZIP. The method should return a collection of resource entries to which the entry should be written to. The result may be null, empty collection, singleton collection, or can contain multiple result entries.

If the result is empty or null, the entry for the argument resource will not be part of the created archive.

If the result contains one or more entries, then the entry will be written to the result archive multiple times specifeid by their entry paths. This can be used to include an entry multiple times with the same contents but different paths.

This method replaces the previous mapResourcePath(SakerPath, boolean). The default implementation calls this method and returns a collection that has the same entry paths as returned by the mapResource(ZipResourceEntry, boolean) function, but all other ZipResourceEntry attributes are taken from the argument.

The method is called when an entry from another archive is being included in the created ZIP. The method should return a set of paths to which the entry should be written to. The result may be null, empty set, singleton set, or can contain multiple result paths.

If the result is empty or null, the entry for the argument path will not be part of the created archive.

If the result contains one or more paths, then the entry will be written to every archive paths in the result set. This can also be used to include an entry multiple times with the same contents.

The returned mapping will call all argument mappings, and merge the result paths.

If the argument is null or empty, the result will exclude all entries.

The returned mapping will call all argument mappings, and concatenate the result paths.

If the argument is null or empty, the result will exclude all entries.

The specified target directory will be prepended to all archive paths.

The result mapping will not transform the archive paths in any way. It will only check if the path is included by the given wildcard, and if so, works the same way as the identity mapping. If it is not included, the archive entry will not be part of the created archive.