Appends the parameter relative path to this path.

Appending differs from the resolving only that the resulting path is not normalized. It is the responsibility of the user to provide a path that is forward relative.

Creates a relative path builder.

Creates a path builder with the given root.

The parameter might be null to construct a relative path.

Shallow clones this path instance.

All the backing fields are the same for the new instance as this one.

Compares this path to the parameter.

Relative paths are ordered first.

This method compares the root and the path names sequentially. Shorter paths ordered first.

The method works in a case-sensitive manner.

Compares this path to the argument in a case-insensitive manner.

Check if the parameter is a path and represents the same location.

This method works in a case-sensitive manner.

Equals method with already known type of the parameter.

Check if this path equals the argument in a case-insensitive manner.

Forces the path to be relative by removing any root if present.

This method can be used to construct a path which contains the same names as this but has no root assigned.

The resulting path will be relative.

The method returns this if this is already relative.

Counts how many common starting path names does this and the parameter have.

This method computes how many common starting path names does this path have with the parameter.

If the paths have different roots, then the result will be -1.

Else this method will return the number of matching path names at the start of both paths.

Returns the common path of this and the parameter path.

This works in the same way as getCommonNameCount(SakerPath), but will extract the common part of both paths as a result.

If the roots differ then the result will be null.

Gets the last path name of this path if it represents a valid file name.

The last path name represents the file name of the location represented by this path.

If this path is relative and only consists of ".." names then the result will be null as there is no explicit file name defined.

Gets the last path name in this path.

This method is similar to getFileName(), but does not examine the returned name if it is actually a valid file name. If the last name is ".." then it will be returned.

Gets the name at the specified index.

Returns an array copy of the path names of this path.

Gets the path name count in this path.

Returns an unmodifiable list of this path's names.

Returns an unmodifiable list of this path's names in the given range.

Returns the path which represents the parent of this path or null if it cannot exist.

The parent of a path is determined by resolving the ".." path name against it. If the parent path cannot exist (e.g. this is a simple root without subfolders like "/" or "c:") this function returns null.

Relative paths always have parent paths.

Returns an array copy of the optional root and path names of this path.

The root name will be the first element in the array if the path is absolute.

If the path is relative this method returns the same as getNameArray().

Returns an unmodifiable list of this path's optional root and path names of this path.

Gets the root for this path.

Returns a path that contains only the root of this path.

The resulting path will contain the root of this path and have no path names assigned. If this path is already contains no path names the result is this.

If this path is relative then the result will be the empty path instance.

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

Finds the first occurence of the parameter path name in this path.

Returns true if the path is absolute.

It will only be true if getRoot() is null.

Checks if the argument path represents a location that is under this path.

This method works in the same way as startsWith(SakerPath), but in reverse order.

Returns if this is relative and resolving it against an other path will not escape to its parent path.

This method returns true if resolving this path against any given path X to result R, then R.startsWith(X) will return true.

Examples by resolving against c:/Users:

• Forward relative: dir/subdir -> c:/Users/dir/subdir
• Forward relative: dir/.. -> c:/Users
• Forward relative: dir/../otherdir -> c:/Users/otherdir
• Not forward relative: ../dir -> c:/dir

Returns true if the path is relative.

It will only be true if getRoot() is not null.

Checks if the parameter path can be relativized against this path.

This method requires the following conditions to be met to return true:

• Both path have the same root.
• If the paths are relative then this path must have less or equal number of ".." path names at the start of it than the parameter.

  E.g. "../dir" is not relativizable against "some/otherdir" as a path cannot be constructed in order to navigate outside of the ".." name at the start.

Checks if the parameter character can be considered as a path separator slash character.

Checks if the parameter is a valid path name.

Returns true if it doesn't contain any directory separators and colons (':').

Checks if the parameter has a valid root name format.

Valid root name formats are:

• Single forward ('/') or backward ('\\') slash character.
• Drive format matching the following regex: "[a-zA-Z]+:"

Creates an iterable that creates iterators for the path names in this instance.

The iterable will not contain the root name. See pathIterable() for including the root too.

Creates an iterator for the path names in this instance.

Creates an iterator for the path names starting at a given index.

The iterator will not contain the root name. See pathIterator() for including the root too.

Returns the next sibling path in the natural order specified by compareTo(SakerPath).

It is ensured that this.compareTo(result) < 0 is always true. Any other path that compares greater than this and less than the result of this function is a subpath of this path.

The resulting path is not semantically correct, it should not be used with files, and should be restricted for ordering comparisons.

Returns the first subpath that starts with this path specified by the natural order.

It is ensured that this.compareTo(result) < 0 is always true.

The resulting path is not semantically correct, it should not be used with files, and should be restricted for ordering comparisons.

Normalizes the parameter root for unified representation.

If the parameter is "\\" then it will return "/".

In any other case the parameter will be converted to lowercase and any trailing slashes will be removed. It is ensured that the parameter is in a valid root format defined by this class.

Creates an iterable that creates iterators for the root and path names in this instance.

Creates an iterator for the root and path names in this instance.

If this path is absolute then the first element will be the root name.

If this path is relative this call is the same as nameIterator();

Promotes the first path name of this relative path to construct an absolute one.

This method takes the first path name in this path and promotes it to be the root of the newly constructed one. The new root will be removed from the list of path names and will not be duplicated.

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.

Relativizes this path against the parameter.

The result of this operation constructs a path which is resolved against this will result in the parameter path.

The following will be true for any two relativizable paths:

 SakerPath first = ...;
 SakerPath other = ...;
 // the following is true:
 first.resolve(first.relativize(other)).equals(other);
 

Examples:

• "/home" relativized against "/home/user" is "user"
• "/home/user" relativized against "/home" is ".."
• "/home/user" relativized against "/home/user" is ""
• "/home/user" relativized against "/home/john" is "../john"

The same applies for paths without a root name.

Constructs a path which has the parameter as root.

The parameter root is normalized and can be null to construct a relative path with the current names.

Resolves the given path names against this path.

Any directory separator characters are normalized.

Resolves the given path names against this path.

Any directory separator characters are normalized.

Resolves the given relative argument against this path.

Resolves the given relative argument against this path.

Path resolution is a binary operation which results in a single path that is the result of the first path and the second path concatenated. During concatenation any semantically significant path names are normalized ("." and "..")

One can look at this process as navigating to the first path in the filesystem, then navigating according to the second path. The result path is taken using the current path after the navigation.

If this path is absolute, and the argument would escape the root of this path, then an InvalidPathFormatException is thrown. (E.g.: this path is /home and argument is ../../file)

Resolves the given path names against this path.

Any directory separator characters are normalized.

Resolves the path to a sibling name.

Sibling resolution is taking the parent of this and then resolving the parameter against it.

The sibling resolution will not escape root boundaries and works for relative paths too.

This method is generally useful when a direct sibling of a path is needed.

E.g.
Sibling of "/home/user" for "john" is "/home/john"
Sibling of "/home/user" for "john/content" is "/home/john/content"
Sibling of "../directory" for "second" is ../second"

Creates a relative path with a single path name.

The resulting path will be relative and contain only the parameter path name.

Checks if this path starts with the parameter path.

Returns true if both paths have the same roots and all of the path names of the parameter occurs at the start of this path.

This method works in a case-sensitive manner.

Creates a relative subpath starting from the given index.

Creates a relative subpath in the given range.

Creates a subpath starting from the given index with a specific root.

Creates a subpath in the given range with a specific root.

Converts this path to an all lowercase representation.

The default locale is used to convert each character of the path.

Same as:

 toLowerCase(Locale.getDefault())
 

Converts this path to an all lowercase representation using the specified locale.

As paths have a case-sensitive representation, it may be useful to convert them to a lowercase representation when comparing them for equality in some cases.

Converts this path to a String. All path names are separated by forward slashes ('/').

Passing the result of this method to valueOf(String) will result in a path that equals with this.

Converting a path that contains only a single drive root will not end in forward slash.

Converts this path to string, but does not include the root if any.

Tries to relativize this path against the parameter.

If the paths are not relativizable, the parameter path is returned.

Tries to resolve the parameter path against this path.

If the parameter is not relative, then it is returned without modification. Else the parameter path is resolved against this.

Parses the parameter String and creates a path.

Equivalent to calling valueOf(SakerPath, String) with null relative resolve parameter.

Creates a path from the given path argument.

The resulting path will be relative only if the argument path is relative. Roots are normalized and extraneous "." and ".." path names are normalized.

Parses the parameter String and resolves it against the parameter path is it is relative.

This function parses the passed String parameter and constructs a valid immutable SakerPath instance. The path names are semantically checked and an exception is thrown if they are in an illegal format.

The parsed path may be relative or absolute. If it is relative then it will be resolved against the passed path parameter if not null.

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.