UniformPath (Giraffe 0.9.0)

java.lang.Object
- com.palantir.giraffe.file.UniformPath

All Implemented Interfaces:

Comparable<UniformPath>, Iterable<UniformPath>
```
public final class UniformPath
extends Object
implements Iterable<UniformPath>, Comparable<UniformPath>
```
A Path-like object that defines a file system independent path syntax and is not associated with any FileSystem instance.
Uniform paths use the following UNIX-like syntax:
[[//root]/]path/to/file/or/directory
where [] indicates an optional component and / serves as the path separator. All names are case-sensitive.
If the root component is present, the path is absolute. For single-root file systems, the root prefix // and the root name are omitted and the path starts with a single forward slash. For multi-root file system, the path starts with the root prefix followed by the name of the root and a single forward slash. Root names that contain the path separator (/) are not allowed.
UniformPaths can be converted to standard Paths using the toPath method.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`compareTo(UniformPath other)`
`boolean`	`endsWith(String other)`
`boolean`	`endsWith(UniformPath other)`
`boolean`	`equals(Object obj)`
`static UniformPath`	`fromPath(Path path)` Converts the specified `Path` into a `UniformPath`.
`static UniformPath`	`get(Iterable<String> components)` Converts a sequence of strings that form a path string when joined to a `UniformPath`.
`static UniformPath`	`get(String first, String... more)` Converts a path string, or a sequence of strings that form a path string when joined, to a `UniformPath`.
`UniformPath`	`getFileName()`
`UniformPath`	`getName(int index)`
`int`	`getNameCount()`
`UniformPath`	`getParent()`
`UniformPath`	`getRoot()`
`int`	`hashCode()`
`boolean`	`isAbsolute()`
`Iterator<UniformPath>`	`iterator()`
`UniformPath`	`normalize()`
`UniformPath`	`relativize(UniformPath other)`
`UniformPath`	`resolve(String other)`
`UniformPath`	`resolve(UniformPath other)`
`UniformPath`	`resolveSibling(String other)`
`UniformPath`	`resolveSibling(UniformPath other)`
`boolean`	`startsWith(String other)`
`boolean`	`startsWith(UniformPath other)`
`UniformPath`	`subpath(int beginIndex, int endIndex)`
`Path`	`toPath()` Converts this uniform path to a real `Path` on the default file system.
`Path`	`toPath(FileSystem fs)` Converts this uniform path to a real `Path` on the given file system.
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Method Detail
  - get
```
public static UniformPath get(String first,
                              String... more)
```
    Converts a path string, or a sequence of strings that form a path string when joined, to a UniformPath.
    
    Parameters:
    
    first - the path string or initial part of the path string
    
    more - additional strings to join to form the path string
  - get
```
public static UniformPath get(Iterable<String> components)
```
    Converts a sequence of strings that form a path string when joined to a UniformPath.
    
    Parameters:
    
    components - the components to join to form the path string
  - fromPath
```
public static UniformPath fromPath(Path path)
```
    Converts the specified Path into a UniformPath.
    For any path p, the following relationship will always hold:
```
  UniformPath.fromPath(p).toPath(p.getFileSystem()).equals(p)
 
```
    Parameters:
    
    path - the path to convert
    
    Returns:
    
    a UniformPath that is equivalent to the given path
    
    Throws:
    
    IllegalArgumentException - if any path segment contains the uniform path separator
  - isAbsolute
```
public boolean isAbsolute()
```
  - getRoot
```
public UniformPath getRoot()
```
  - getFileName
```
public UniformPath getFileName()
```
  - getParent
```
public UniformPath getParent()
```
  - getNameCount
```
public int getNameCount()
```
  - getName
```
public UniformPath getName(int index)
```
  - subpath
```
public UniformPath subpath(int beginIndex,
                           int endIndex)
```
  - startsWith
```
public boolean startsWith(UniformPath other)
```
  - startsWith
```
public boolean startsWith(String other)
```
  - endsWith
```
public boolean endsWith(UniformPath other)
```
  - endsWith
```
public boolean endsWith(String other)
```
  - normalize
```
public UniformPath normalize()
```
  - resolve
```
public UniformPath resolve(UniformPath other)
```
  - resolve
```
public UniformPath resolve(String other)
```
  - resolveSibling
```
public UniformPath resolveSibling(UniformPath other)
```
  - resolveSibling
```
public UniformPath resolveSibling(String other)
```
  - relativize
```
public UniformPath relativize(UniformPath other)
```
  - iterator
```
public Iterator<UniformPath> iterator()
```
    Specified by:
    
    iterator in interface Iterable<UniformPath>
  - toPath
```
public Path toPath()
```
    Converts this uniform path to a real Path on the default file system.
    
    See Also:
    
    toPath(FileSystem)
  - toPath
```
public Path toPath(FileSystem fs)
```
    Converts this uniform path to a real Path on the given file system.
    If this path is a relative path, each segment is passed as a separate argument to the file system's getPath method. If this path is an absolute path, a relative path is constructed as described then resolved against a root path obtained using the following method:
    1. Get all root directories on the file system
    2. If this path does not have a named root and there is one root, use that root
    3. If there are multiple roots or this path has a named root, compare this path's root to the string version of each file system root. If this path's root equals a file system root, ignoring any trailing path separator, use that root
    4. If there are no matches, throw an IllegalArgumentException
    Parameters:
    
    fs - the FileSystem on which to create a path
    
    Throws:
    
    IllegalArgumentException - if this is an absolute path and the given file system does not have a matching root
  - compareTo
```
public int compareTo(UniformPath other)
```
    Specified by:
    
    compareTo in interface Comparable<UniformPath>
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class UniformPath

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Method Detail

get

get

fromPath

isAbsolute

getRoot

getFileName

getParent

getNameCount

getName

subpath

startsWith

startsWith

endsWith

endsWith

normalize

resolve

resolve

resolveSibling

resolveSibling

relativize

iterator

toPath

toPath

compareTo

equals

hashCode

toString