TPath (TrueZIP Path 7.3.2 API)

java.lang.Object
- de.schlichtherle.truezip.nio.file.TPath

All Implemented Interfaces:

Comparable<Path>, Iterable<Path>, Path, Watchable
```
@Immutable
@DefaultAnnotation(value=edu.umd.cs.findbugs.annotations.NonNull.class)
public final class TPath
extends Object
implements Path
```
A Path implementation based on the TrueZIP Kernel module. Applications should directly instantiate this class to overcome the restrictions of the file system provider service location in the NIO.2 API for JSE 7. Once created, it's safe to use TPath instances polymorphically as Path instances.
Objects of this class are immutable and inherently volatile because all virtual file system state is managed by the TrueZIP Kernel module.
You should never use object identity ('==') to test for equality of objects of this class with another object. Use the method equals(Object) instead.
Unless otherwise noted, you should not assume that calling the same method on an instance of this class multiple times will return the same object.
Unless otherwise noted, when an instance of this class is created, the resulting path name gets scanned for prospective archive files using the default archive detector. To change this, wrap the object creation in a code block which pushes a temporary configuration on the inheritbale thread local stack of configurations as follows:
```
// Create reference to the current directory.
     TPath directory = new TPath("");
     // This is how you would detect a prospective archive file, supposing
     // the JAR of the module TrueZIP Driver ZIP is present on the run time
     // class path.
     TPath archive = directory.resolve("archive.zip");
     TPath file;
     try (TConfig config = TConfig.push()) {
         config.setArchiveDetector(TArchiveDetector.NULL);
         // Ignore prospective archive file here.
         file = directory.resolve("archive.zip");
     }
     // Once created, the prospective archive file detection does not change
     // because a TPath is immutable.
     assert archive.getArchiveDetector() == TArchiveDetector.ALL;
     assert archive.isArchive();
     assert file.getArchiveDetector() == TArchiveDetector.NULL;
     assert !file.isArchive();
 
```
Mind that you should either use archive or file from the previous example to do any subsequent I/O - but not both - so that you don't bypass or corrupt the state which gets implicitly associated with any archive file by the TrueZIP Kernel module!
Since:

TrueZIP 7.2

Author:

Christian Schlichtherle

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`TPath.SegmentIterator`
`private static class`	`TPath.TPathComparator` The methods in this class use `getAddress()`.
`private static class`	`TPath.WindowsTPathComparator` The methods in this class use `getAddress()`.

Field Summary

Fields
Modifier and Type	Field and Description
`private FsPath`	`address`
`private static TPath.TPathComparator`	`COMPARATOR`
`private TArchiveDetector`	`detector`
`private List<String>`	`elements`
`private TFileSystem`	`fileSystem`
`private Integer`	`hashCode`
`private URI`	`name`
`private String`	`string`

Constructor Summary

Constructors
Modifier	Constructor and Description
	`TPath(File file)` Constructs a new path from the given file.
	`TPath(Path path)` Constructs a new path from the given path.
	`TPath(String first, String... more)` Constructs a new path from the given path strings.
`(package private)`	`TPath(TFileSystem fileSystem, String first, String... more)` Constructs a new path from the given file system and sub path strings.
	`TPath(URI name)` Constructs a new path from the given hierarchical URI.
`private`	`TPath(URI name, TArchiveDetector detector, FsPath address)`

Method Summary

Methods
Modifier and Type	Method and Description
`private static FsPath`	`address(URI name, TArchiveDetector detector)`
`(package private) void`	`checkAccess(AccessMode... modes)`
`int`	`compareTo(Path that)` The natural ordering imposed by this implementation is identical to the natural ordering of path's `name`.
`(package private) void`	`createDirectory(FileAttribute<?>... attrs)`
`private static String`	`cutLeadingSeparators(String p)`
`(package private) static String`	`cutTrailingSeparators(String p, int o)`
`(package private) void`	`delete()`
`boolean`	`endsWith(Path that)`
`boolean`	`endsWith(String other)`
`boolean`	`equals(Object that)` This path is considered equal to the given `other` object if and only if the other object is identical to this object or if the other object is a `TPath` object with a `file system` which is considered `equal` to this path's file system and a `name` which is considered `equal` to this path's name.
`private FsPath`	`getAddress()` Returns the file system path for this path with an absolute URI.
`(package private) TArchiveDetector`	`getArchiveDetector()` Returns the `TArchiveDetector` used for scanning this path's `name` for prospective archive files at construction time.
`static TArchiveDetector`	`getDefaultArchiveDetector()` Equivalent to `TConfig.get().getArchiveDetector()`.
`private List<String>`	`getElements()` Returns the segments of this path's `name`.
`private List<String>`	`getElements0()`
`(package private) FsEntry`	`getEntry()`
`(package private) FsEntryName`	`getEntryName()` Returns the file system entry name for this path.
`(package private) <V extends FileAttributeView> V`	`getFileAttributeView(Class<V> type, LinkOption... options)`
`TPath`	`getFileName()`
`TFileSystem`	`getFileSystem()` Returns the `TFileSystem` for this path.
`private TFileSystem`	`getFileSystem0()`
`(package private) BitField<FsInputOption>`	`getInputPreferences()`
`(package private) InputSocket<?>`	`getInputSocket(BitField<FsInputOption> options)`
`(package private) FsMountPoint`	`getMountPoint()` Returns the file system mount point for this path.
`(package private) URI`	`getName()` Returns the name of this path as a `URI`.
`TPath`	`getName(int index)`
`int`	`getNameCount()`
`(package private) TPath`	`getNonArchivePath()`
`(package private) BitField<FsOutputOption>`	`getOutputPreferences()`
`(package private) OutputSocket<?>`	`getOutputSocket(BitField<FsOutputOption> options, Entry template)`
`TPath`	`getParent()`
`TPath`	`getRoot()`
`int`	`hashCode()` Returns a hash code which is consistent with `equals(Object)`.
`private boolean`	`invariants()` Checks the invariants of this class and throws an AssertionError if any is violated even if assertion checking is disabled.
`boolean`	`isAbsolute()`
`boolean`	`isArchive()` Returns `true` if and only if this `TPath` addresses an archive file.
`boolean`	`isEntry()` Returns `true` if and only if this `TPath` addresses an entry located within an archive file.
`Iterator<Path>`	`iterator()`
`(package private) BitField<FsInputOption>`	`mapInput(OpenOption... options)`
`(package private) BitField<FsInputOption>`	`mapInput(Set<? extends OpenOption> options)`
`(package private) BitField<FsOutputOption>`	`mapOutput(OpenOption... options)`
`(package private) BitField<FsOutputOption>`	`mapOutput(Set<? extends OpenOption> options)`
`private static URI`	`name(String first, String... more)`
`private static URI`	`name(URI uri)`
`(package private) SeekableByteChannel`	`newByteChannel(Set<? extends OpenOption> options, FileAttribute<?>... attrs)`
`(package private) DirectoryStream<Path>`	`newDirectoryStream(DirectoryStream.Filter<? super Path> filter)`
`(package private) InputStream`	`newInputStream(OpenOption... options)`
`(package private) OutputStream`	`newOutputStream(OpenOption... options)`
`TPath`	`normalize()`
`private static int`	`prefixLength(String p)`
`(package private) <A extends BasicFileAttributes> A`	`readAttributes(Class<A> type, LinkOption... options)`
`WatchKey`	`register(WatchService watcher, WatchEvent.Kind<?>... events)`
`WatchKey`	`register(WatchService watcher, WatchEvent.Kind<?>[] events, WatchEvent.Modifier... modifiers)`
`TPath`	`relativize(Path other)`
`TPath`	`resolve(Path other)`
`TPath`	`resolve(String other)`
`private TPath`	`resolve(URI m)`
`TPath`	`resolveSibling(Path other)`
`TPath`	`resolveSibling(String other)`
`static void`	`setDefaultArchiveDetector(TArchiveDetector detector)` Equivalent to `TConfig.get().setArchiveDetector(detector)`.
`boolean`	`startsWith(Path that)`
`boolean`	`startsWith(String other)`
`TPath`	`subpath(int beginIndex, int endIndex)`
`TPath`	`toAbsolutePath()`
`TFile`	`toFile()` Returns a new `TFile` object for this path.
`TPath`	`toRealPath(LinkOption... options)`
`String`	`toString()`
`private String`	`toString0()`
`URI`	`toUri()`

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

- Field Detail
  - address
```
private final FsPath address
```
  - COMPARATOR
```
private static final TPath.TPathComparator COMPARATOR
```
  - detector
```
private final TArchiveDetector detector
```
  - elements
```
@CheckForNull
private volatile List<String> elements
```
  - fileSystem
```
@CheckForNull
private volatile TFileSystem fileSystem
```
  - hashCode
```
@CheckForNull
private volatile Integer hashCode
```
  - name
```
private final URI name
```
  - string
```
@CheckForNull
private volatile String string
```
- Constructor Detail
  - TPath
```
public TPath(File file)
```
    Constructs a new path from the given file.
    This constructor is required for interoperability with the TFile class because it does not support TFile.toPath().
    If file is an instance of TFile, its archive detector and file system path get shared with this instance.
    Otherwise, this constructor scans the path name of the file to detect prospective archive files using the default archive detector.
    Examples
    
    On all platforms:
    
    Relative path name:
    
    Path path = new TPath(new File("app.war/WEB-INF/lib", "lib.jar/META-INF/MANIFEST.MF"));
    
    On POSIX platforms (Unix, Linux, Mac OS X):
    
    Absolute path name with plain File:
    
    Path path = new TPath(new File("/home/christian/archive.zip"));
    
    Absolute path name with plain TFile:
    
    Path path = new TPath(new TFile("/home/christian/archive.zip"));
    
    On the Windows platform:
    
    Absolute path name with plain File:
    
    Path path = new TPath(new File("c:\home\christian\archive.zip"));
    
    Absolute path name with TFile:
    
    Path path = new TPath(new TFile("c:\home\christian\archive.zip"));
    
    Parameters:
    file - a file. If this is an instance of TFile, its archive detector and address get shared with this instance.
  - TPath
```
public TPath(Path path)
```
    Constructs a new path from the given path.
    This constructor scans the path name of the given path to detect prospective archive files using the default archive detector.
    Examples
    
    On all platforms:
    
    Relative path name:
    
    Path path = new TPath(Paths.get("app.war/WEB-INF/lib", "lib.jar/META-INF/MANIFEST.MF"));
    
    Parameters:
    path - a path.
  - TPath
```
public TPath(String first,
     String... more)
```
    Constructs a new path from the given path strings.
    The supported path name separators are "File.separator" and "/". Any trailing separators in the resulting path name get discarded.
    This constructor scans the path name resulting from the segment parameters to detect prospective archive files using the default archive detector.
    Examples
    
    On all platforms:
    
    Relative path name:
    
    Path path = new TPath("app.war/WEB-INF/lib", "lib.jar/META-INF/MANIFEST.MF");
    
    On POSIX platforms (Unix, Linux, Mac OS X):
    
    Absolute path name:
    
    Path path = new TPath("/home/christian/archive.zip");
    
    On the Windows platform:
    
    Relative path name:
    
    Path path = new TPath("app.war\WEB-INF\lib", "lib.jar\META-INF\MANIFEST.MF");
    
    Absolute path name with C: drive letter and wierd case letters:
    
    Path path = new TPath("c:\UsErS\cHrIsTiAn\ArChIvE.zIp");
    
    Absolute path name with separated UNC host and share name and forward slash separator:
    
    Path path = new TPath("//host", "share", "archive.zip");
    
    Dito with mixed slash separators:
    
    Path path = new TPath("\\host/share\archive.zip");
    
    Parameters:
    first - the first sub path string.
    more - optional sub path strings.
  - TPath
```
TPath(TFileSystem fileSystem,
     String first,
     String... more)
```
    Constructs a new path from the given file system and sub path strings.
    The supported path name separators are "File.separator" and "/". Any leading and trailing separators in the resulting path name get discarded.
    This constructor scans the path name resulting from the segment parameters to detect prospective archive files using the default archive detector.
    
    Parameters:
    fileSystem - the file system to access.
    first - the first sub path string.
    more - optional sub path strings.
  - TPath
```
public TPath(URI name)
```
    Constructs a new path from the given hierarchical URI.
    If the scheme component of the URI is undefined and the scheme specific part does not start with a "/", then the URI gets resolved against the "file:" based URI for the current directory in the platform file system. Otherwise, if the scheme component is undefined, then the URI gets resolved against the URI "file:/".
    This constructor scans the path component of the URI to detect prospective archive files using the default archive detector.
    Examples
    
    On all platforms:
    
    Relative URI with relative path component:
    
    Path path = new TPath(new URI("app.war/WEB-INF/lib/lib.jar/META-INF/MANIFEST.MF"));
    
    HTTP URI:
    
    Path path = new TPath(new URI("http://acme.com/download/everything.tar.gz/README.TXT"));
    
    On POSIX platforms (Unix, Linux, Mac OS X):
    
    Relative URI with absolute path component:
    
    Path path = new TPath(new URI("/home/christian/archive.zip"));
    
    Dito with absolute, hierarchical URI:
    
    Path path = new TPath(new URI("file:/home/christian/archive.zip"));
    
    On the Windows platform:
    
    Relative URI with relative path component with C: drive letter and following absolute path name:
    
    Path path = new TPath(new URI("c%3A/Users/christian/archive.zip"));
    
    Dito with absolute, hierarchical URI:
    
    Path path = new TPath(new URI("file:/c:/Users/christian/archive.zip"));
    
    Relative URI with UNC host and share name:
    
    Path path = new TPath(new URI("//host/share/archive.zip"));
    
    Dito with absolute, hierarchical URI:
    
    Path path = new TPath(new URI("file://host/share/archive.zip"));
    
    Parameters:
    name - the path name. This must be a hierarchical URI with an undefined fragment component. Any trailing separators in the path component get discarded.
    
    Throws:
    
    IllegalArgumentException - if the preconditions for the parameter do not hold.
  - TPath
```
private TPath(URI name,
     @CheckForNull
     TArchiveDetector detector,
     @CheckForNull
     FsPath address)
```
- Method Detail
  - address
```
private static FsPath address(URI name,
             TArchiveDetector detector)
```
  - checkAccess
```
void checkAccess(AccessMode... modes)
           throws IOException
```
    Throws:
    
    IOException
  - compareTo
```
public int compareTo(Path that)
```
    The natural ordering imposed by this implementation is identical to the natural ordering of path's name. On Windows, case is ignored when comparing the path names.
    
    Specified by:
    
    compareTo in interface Comparable<Path>
    
    Specified by:
    
    compareTo in interface Path
  - createDirectory
```
void createDirectory(FileAttribute<?>... attrs)
               throws IOException
```
    Throws:
    
    IOException
  - cutLeadingSeparators
```
private static String cutLeadingSeparators(String p)
```
  - cutTrailingSeparators
```
static String cutTrailingSeparators(String p,
                           int o)
```
  - delete
```
void delete()
      throws IOException
```
    Throws:
    
    IOException
  - endsWith
```
public boolean endsWith(Path that)
```
    Specified by:
    
    endsWith in interface Path
  - endsWith
```
public boolean endsWith(String other)
```
    Specified by:
    
    endsWith in interface Path
  - equals
```
public boolean equals(Object that)
```
    This path is considered equal to the given other object if and only if the other object is identical to this object or if the other object is a TPath object with a file system which is considered equal to this path's file system and a name which is considered equal to this path's name. On Windows, case is ignored when comparing the path names.
    
    Specified by:
    
    equals in interface Path
    
    Overrides:
    
    equals in class Object
  - getAddress
```
private FsPath getAddress()
```
    Returns the file system path for this path with an absolute URI.
    
    Returns:
    The file system path for this path with an absolute URI.
  - getArchiveDetector
```
TArchiveDetector getArchiveDetector()
```
    Returns the TArchiveDetector used for scanning this path's name for prospective archive files at construction time. Multiple invocations of this method will return the same object.
    
    Returns:
    The TArchiveDetector used for scanning this path's name for prospective archive files at construction time.
  - getDefaultArchiveDetector
```
public static TArchiveDetector getDefaultArchiveDetector()
```
    Equivalent to TConfig.get().getArchiveDetector().
  - getElements
```
private List<String> getElements()
```
    Returns the segments of this path's name. Multiple invocations of this method will return the same object.
    
    Returns:
    The segments of this path's name.
  - getElements0
```
private List<String> getElements0()
```
  - getEntry
```
FsEntry getEntry()
           throws IOException
```
    Throws:
    
    IOException
  - getEntryName
```
FsEntryName getEntryName()
```
    Returns the file system entry name for this path.
    
    Returns:
    The file system entry name for this path.
  - getFileAttributeView
```
@Nullable
<V extends FileAttributeView> V getFileAttributeView(Class<V> type,
                                                            LinkOption... options)
```
  - getFileName
```
@Nullable
public TPath getFileName()
```
    Specified by:
    
    getFileName in interface Path
  - getFileSystem
```
public TFileSystem getFileSystem()
```
    Returns the TFileSystem for this path. Multiple invocations of this method will return the same object.
    
    Specified by:
    
    getFileSystem in interface Path
    
    Returns:
    the TFileSystem for this path.
  - getFileSystem0
```
private TFileSystem getFileSystem0()
```
  - getInputPreferences
```
BitField<FsInputOption> getInputPreferences()
```
  - getInputSocket
```
InputSocket<?> getInputSocket(BitField<FsInputOption> options)
```
  - getMountPoint
```
FsMountPoint getMountPoint()
```
    Returns the file system mount point for this path.
    
    Returns:
    The file system mount point for this path.
  - getName
```
URI getName()
```
    Returns the name of this path as a URI. Multiple invocations of this method will return the same object.
    
    Returns:
    the name of this path as a URI.
  - getName
```
public TPath getName(int index)
```
    Specified by:
    
    getName in interface Path
  - getNameCount
```
public int getNameCount()
```
    Specified by:
    
    getNameCount in interface Path
  - getNonArchivePath
```
TPath getNonArchivePath()
```
  - getOutputPreferences
```
BitField<FsOutputOption> getOutputPreferences()
```
  - getOutputSocket
```
OutputSocket<?> getOutputSocket(BitField<FsOutputOption> options,
                              @CheckForNull
                              Entry template)
```
  - getParent
```
@Nullable
public TPath getParent()
```
    Specified by:
    
    getParent in interface Path
  - getRoot
```
@Nullable
public TPath getRoot()
```
    Specified by:
    
    getRoot in interface Path
  - hashCode
```
public int hashCode()
```
    Returns a hash code which is consistent with equals(Object).
    
    Specified by:
    
    hashCode in interface Path
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    A hash code which is consistent with equals(Object).
  - invariants
```
private boolean invariants()
```
    Checks the invariants of this class and throws an AssertionError if any is violated even if assertion checking is disabled.
    The constructors call this method like this:
```
assert invariants();
```
    This calls the method if and only if assertions are enabled in order to assert that the instance invariants are properly obeyed. If assertions are disabled, the call to this method is thrown away by the HotSpot compiler, so there is no performance penalty.
    If assertions are enabled however, a call to this method will initialize all volatile fields as a side effect.
    Returns:
    true
    
    Throws:
    
    AssertionError - If assertions are enabled and any invariant is violated.
  - isAbsolute
```
public boolean isAbsolute()
```
    Specified by:
    
    isAbsolute in interface Path
  - isArchive
```
public boolean isArchive()
```
    Returns true if and only if this TPath addresses an archive file. Whether or not this is true solely depends on the TArchiveDetector which was used to construct this TPath - no file system tests are performed by this method!
    
    Returns:
    true if and only if this TPath addresses an archive file.
    See Also:
    isEntry()
  - isEntry
```
public boolean isEntry()
```
    Returns true if and only if this TPath addresses an entry located within an archive file. Whether or not this is true solely depends on the TArchiveDetector which was used to construct this TPath - no file system tests are performed by this method!
    
    Returns:
    true if and only if this TPath addresses an entry located within an archive file.
    See Also:
    isArchive()
  - iterator
```
public Iterator<Path> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Path>
    
    Specified by:
    
    iterator in interface Path
  - mapInput
```
BitField<FsInputOption> mapInput(OpenOption... options)
```
  - mapInput
```
BitField<FsInputOption> mapInput(Set<? extends OpenOption> options)
```
  - mapOutput
```
BitField<FsOutputOption> mapOutput(OpenOption... options)
```
  - mapOutput
```
BitField<FsOutputOption> mapOutput(Set<? extends OpenOption> options)
```
  - name
```
private static URI name(String first,
       String... more)
```
  - name
```
private static URI name(URI uri)
```
  - newByteChannel
```
SeekableByteChannel newByteChannel(Set<? extends OpenOption> options,
                                 FileAttribute<?>... attrs)
                             throws IOException
```
    Throws:
    
    IOException
  - newDirectoryStream
```
DirectoryStream<Path> newDirectoryStream(DirectoryStream.Filter<? super Path> filter)
                                   throws IOException
```
    Throws:
    
    IOException
  - newInputStream
```
InputStream newInputStream(OpenOption... options)
                     throws IOException
```
    Throws:
    
    IOException
  - newOutputStream
```
OutputStream newOutputStream(OpenOption... options)
                       throws IOException
```
    Throws:
    
    IOException
  - normalize
```
public TPath normalize()
```
    Specified by:
    
    normalize in interface Path
  - prefixLength
```
private static int prefixLength(String p)
```
  - readAttributes
```
<A extends BasicFileAttributes> A readAttributes(Class<A> type,
                                               LinkOption... options)
                                       throws IOException
```
    Throws:
    
    IOException
  - register
```
public WatchKey register(WatchService watcher,
                WatchEvent.Kind<?>... events)
                  throws IOException
```
    Specified by:
    
    register in interface Path
    
    Specified by:
    
    register in interface Watchable
    
    Throws:
    
    UnsupportedOperationException - always
    
    IOException
  - register
```
public WatchKey register(WatchService watcher,
                WatchEvent.Kind<?>[] events,
                WatchEvent.Modifier... modifiers)
                  throws IOException
```
    Specified by:
    
    register in interface Path
    
    Specified by:
    
    register in interface Watchable
    
    Throws:
    
    UnsupportedOperationException - always
    
    IOException
  - relativize
```
public TPath relativize(Path other)
```
    Specified by:
    
    relativize in interface Path
  - resolve
```
public TPath resolve(Path other)
```
    Specified by:
    
    resolve in interface Path
  - resolve
```
public TPath resolve(String other)
```
    Specified by:
    
    resolve in interface Path
  - resolve
```
private TPath resolve(URI m)
```
  - resolveSibling
```
public TPath resolveSibling(Path other)
```
    Specified by:
    
    resolveSibling in interface Path
  - resolveSibling
```
public TPath resolveSibling(String other)
```
    Specified by:
    
    resolveSibling in interface Path
  - setDefaultArchiveDetector
```
public static void setDefaultArchiveDetector(TArchiveDetector detector)
```
    Equivalent to TConfig.get().setArchiveDetector(detector).
  - startsWith
```
public boolean startsWith(Path that)
```
    Specified by:
    
    startsWith in interface Path
  - startsWith
```
public boolean startsWith(String other)
```
    Specified by:
    
    startsWith in interface Path
  - subpath
```
public TPath subpath(int beginIndex,
            int endIndex)
```
    Specified by:
    
    subpath in interface Path
  - toAbsolutePath
```
public TPath toAbsolutePath()
```
    Specified by:
    
    toAbsolutePath in interface Path
  - toFile
```
public TFile toFile()
```
    Returns a new TFile object for this path. If this path was constructed by the file constructor, then the returned new TFile object compares equal with that file object, even if it was a plain File object.
    
    Specified by:
    
    toFile in interface Path
    
    Returns:
    A TFile object for this path.
    
    Throws:
    
    UnsupportedOperationException - if this path is not file based, i.e. if the scheme component of the URI of this path is not file.
  - toRealPath
```
public TPath toRealPath(LinkOption... options)
                 throws IOException
```
    Specified by:
    
    toRealPath in interface Path
    
    Throws:
    
    IOException
  - toString
```
public String toString()
```
    Specified by:
    
    toString in interface Path
    
    Overrides:
    
    toString in class Object
  - toString0
```
private String toString0()
```
  - toUri
```
public URI toUri()
```
    Specified by:
    
    toUri in interface Path

Class TPath

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

address

COMPARATOR

detector

elements

fileSystem

hashCode

name

string

Constructor Detail

TPath

Examples

TPath

Examples

TPath

Examples

TPath

TPath

Examples

TPath

Method Detail

address

checkAccess

compareTo

createDirectory

cutLeadingSeparators

cutTrailingSeparators

delete

endsWith

endsWith

equals

getAddress

getArchiveDetector

getDefaultArchiveDetector

getElements

getElements0

getEntry

getEntryName

getFileAttributeView

getFileName

getFileSystem

getFileSystem0

getInputPreferences

getInputSocket

getMountPoint

getName

getName

getNameCount

getNonArchivePath

getOutputPreferences

getOutputSocket

getParent

getRoot

hashCode

invariants

isAbsolute

isArchive

isEntry

iterator

mapInput

mapInput

mapOutput

mapOutput

name

name

newByteChannel

newDirectoryStream

newInputStream

newOutputStream

normalize

prefixLength

readAttributes

register

register