Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

The implementor must ensure sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y. (This implies that x.compareTo(y) must throw an exception iff y.compareTo(x) throws an exception.)

The implementor must also ensure that the relation is transitive: (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0.

Finally, the implementor must ensure that x.compareTo(y)==0 implies that sgn(x.compareTo(z)) == sgn(y.compareTo(z)), for all z.

It is strongly recommended, but not strictly required that (x.compareTo(y)==0) == (x.equals(y)). Generally speaking, any class that implements the Comparable interface and violates this condition should clearly indicate this fact. The recommended language is "Note: this class has a natural ordering that is inconsistent with equals."

In the foregoing description, the notation sgn(expression) designates the mathematical signum function, which is defined to return one of -1, 0, or 1 according to whether the value of expression is negative, zero or positive.

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.

Checks if appending one or more names to the argument path can result in the wildcard including it.

The method returns true if any only if there exists an appending operation to the argument path that results in the wildcard matching the result.

Checks if appending one or more names to the argument array of path names can result in the wildcard including it.

The method returns true if any only if there exists an appending operation to the argument path that results in the wildcard matching the result.

Collects the files for multiple wildcard paths, a given execution directory context, and a working directory.

If the execution directory context is null, no root directories are considered.

Collects the files for multiple wildcard paths, and a given task context.

The root directories and working directory for the task is used for base directories.

Collects the files for a given file provider.

As no working directory is specified, only absolute wildcards should use this function.

Collects the files for a given file provider and working directory.

Collects the files for the specified directories.

The root directories specified by the execution directory will be used to discover absolute files.

Collects the files for the specified execution path configuration.

The root file providers and working directory in the argument configuration will be used as a base for file collection.

Collects the files for the specified task context.

The root directories and working directory for the task is used for base directories.

Collects the items for multiple wildcard paths and a given ItemLister.

Collects the items for a given ItemLister.

Collects a single file matching this wildcard for the given execution directory context and working directory.

The root directories specified by the execution directory will be used to discover absolute files.

Collects a single file matching this wildcard for the given task context.

The root directories and working directory for the task is used for base directories.

Collects a single item matching this wildcard for the given ItemLister.

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(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.)

Checks if this wildcard includes/matches the specified path.

The argument will be split up in the same way valueOf(String) does.

The argument path may be relative or absolute.

Checks if this wildcard includes/matches the path specified by a list of path names.

The argument path may be relative or absolute.

Checks if this wildcard includes/matches the specified path.

The argument path may be relative or absolute.

Checks if this wildcard includes/matches the path specified by an array of path names.

The argument path may be relative or absolute.

Checks if this wildcard path only consists of path names that will match all files recursively.

The object implements the readExternal method to restore its contents by calling the methods of DataInput for primitive types and readObject for objects, strings and arrays. The readExternal method must read the values in the same sequence and with the same types as were written by writeExternal.

Tries to optimize this wildcard path by removing (reducing) the starting path names that match the path names in an exact manner.

As a result of this call, the wildcard path will be separated into two parts:

1. The first part contains the path names which doesn't contain any wildcards, therefore matching the input in an exact manner.
2. The second part starts with the first wildcarded path name and lasts until the end of this path.

The resulting reduced wildcard can be used by resolving possible inputs against the reduced first part, and applying the remaining wildcard to that.

The resulting first or second parts might be null in which case this wildcard either fully matches paths exactly, or is wildcarded from the beginning.

Examples:

• dir/*.ext will be reduced to dir and *ext
• dir/file.ext will be reduced to dir/file.ext and null
• *.ext will be reduced to null and *ext
• (empty string wildcard) will be reduced to empty path and null
• . will be reduced to empty path and null

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())
 

Creates a new wildcard path based on the given path string.

The argument will be split up by '/' and '\\' characters. The path is considered to be absolute with the same rules as SakerPath.

Trailing slash ('/' or '\\') will be ignored by this function.

Creates a new wildcard path for the specified path.

The argument path will be normalized.

The created wildcard will have the same root (if absolute) and all path names as in the argument.

Creates a new wildcard path for the specified path.

The created wildcard will have the same root (if absolute) and all path names as in the argument.

Creates a new wildcard path for the specified path names.

The argument is not sanity checked in any way. If it includes slashes, or other semantically important characters, they are not removed or split up. Passing an array containing invalid path names is considered to be undefined behaviour.

The array will be cloned, any modifications to it won't propagate to the created wildcard.

The object implements the writeExternal method to save its contents by calling the methods of DataOutput for its primitive values or calling the writeObject method of ObjectOutput for objects, strings, and arrays.