TFileSystem (TrueZIP Path 7.3.2 API)

java.lang.Object
- java.nio.file.FileSystem
- - de.schlichtherle.truezip.nio.file.TFileSystem

All Implemented Interfaces:

Closeable, AutoCloseable
```
@ThreadSafe
@DefaultAnnotation(value=edu.umd.cs.findbugs.annotations.NonNull.class)
public final class TFileSystem
extends FileSystem
```
A FileSystem implementation based on the TrueZIP Kernel module.

Since:

TrueZIP 7.2

Author:

Christian Schlichtherle

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private class TFileSystem.FsEntryAttributes

private class TFileSystem.FsEntryAttributeView

Nested Classes
Modifier and Type	Class and Description
`private class`	`TFileSystem.FsEntryAttributes`
`private class`	`TFileSystem.FsEntryAttributeView`

Field Summary

Fields
Modifier and Type Field and Description

private FsController<?> controller

private static FsManager manager

private TFileSystemProvider provider

Fields
Modifier and Type	Field and Description
`private FsController<?>`	`controller`
`private static FsManager`	`manager`
`private TFileSystemProvider`	`provider`

Constructor Summary

Constructors
Constructor and Description

TFileSystem(TPath path)

Constructors
Constructor and Description
`TFileSystem(TPath path)`

Method Summary

Methods
Modifier and Type	Method and Description
`(package private) void`	`checkAccess(TPath path, AccessMode... modes)`
`void`	`close()` Commits all unsynchronized changes to the contents of this federated file system (i.e. prospective archive files) and all its member federated file systems to their respective parent system, releases the associated resources (i.e. target archive files) for access by third parties (e.g. other processes), cleans up any temporary allocated resources (e.g. temporary files) and purges any cached data.
`(package private) void`	`createDirectory(TPath path, FileAttribute<?>... attrs)`
`(package private) void`	`delete(TPath path)`
`private FsController<?>`	`getController()`
`(package private) FsEntry`	`getEntry(TPath path)`
`(package private) <V extends FileAttributeView> V`	`getFileAttributeView(TPath path, Class<V> type, LinkOption... options)`
`Iterable<FileStore>`	`getFileStores()`
`(package private) InputSocket<?>`	`getInputSocket(TPath path, BitField<FsInputOption> options)`
`(package private) FsMountPoint`	`getMountPoint()`
`(package private) OutputSocket<?>`	`getOutputSocket(TPath path, BitField<FsOutputOption> options, Entry template)`
`TPath`	`getPath(String first, String... more)` Constructs a new path from the given sub path strings.
`PathMatcher`	`getPathMatcher(String syntaxAndPattern)`
`Iterable<Path>`	`getRootDirectories()`
`String`	`getSeparator()` Returns `File.separator`.
`UserPrincipalLookupService`	`getUserPrincipalLookupService()`
`private boolean`	`invariants()`
`static boolean`	`isLenient()` Equivalent to `TConfig.get().isLenient()`.
`boolean`	`isOpen()` Returns `true`.
`boolean`	`isReadOnly()` Returns `false`.
`(package private) SeekableByteChannel`	`newByteChannel(TPath path, Set<? extends OpenOption> options, FileAttribute<?>... attrs)`
`(package private) DirectoryStream<Path>`	`newDirectoryStream(TPath path, DirectoryStream.Filter<? super Path> filter)`
`(package private) InputStream`	`newInputStream(TPath path, OpenOption... options)`
`(package private) OutputStream`	`newOutputStream(TPath path, OpenOption... options)`
`WatchService`	`newWatchService()`
`TFileSystemProvider`	`provider()`
`(package private) <A extends BasicFileAttributes> A`	`readAttributes(TPath path, Class<A> type, LinkOption... options)`
`static void`	`setLenient(boolean lenient)` Equivalent to `TConfig.get().setLenient(lenient)`.
`Set<String>`	`supportedFileAttributeViews()`
`void`	`sync(BitField<FsSyncOption> options)` Commits all unsynchronized changes to the contents of this federated file system (i.e. prospective archive file) and all its member federated file systems to their respective parent file system, releases the associated resources (i.e. target archive files) for access by third parties (e.g. other processes), cleans up any temporary allocated resources (e.g. temporary files) and purges any cached data.

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

- Field Detail
  - controller
```
private final FsController<?> controller
```
  - manager
```
private static final FsManager manager
```
  - provider
```
private final TFileSystemProvider provider
```
- Constructor Detail
  - TFileSystem
```
TFileSystem(TPath path)
```
- Method Detail
  - checkAccess
```
void checkAccess(TPath path,
               AccessMode... modes)
           throws IOException
```
    Throws:
    
    IOException
  - close
```
public void close()
           throws FsSyncException
```
    Commits all unsynchronized changes to the contents of this federated file system (i.e. prospective archive files) and all its member federated file systems to their respective parent system, releases the associated resources (i.e. target archive files) for access by third parties (e.g. other processes), cleans up any temporary allocated resources (e.g. temporary files) and purges any cached data. Note that temporary files may get used even if the archive files where accessed read-only.
    This method is equivalent to calling sync(FsSyncOptions.UMOUNT).
    Note that the file system stays open (!) after this call and can get used subsequently.
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in class FileSystem
    
    Throws:
    
    FsSyncWarningException - if only warning conditions occur. This implies that the respective parent file system has been updated with constraints, such as a failure to set the last modification time of the entry for the federated file system (i.e. prospective archive file) in its parent file system.
    
    FsSyncException - if any error conditions occur. This implies loss of data!
    See Also:
    sync(BitField)
  - createDirectory
```
void createDirectory(TPath path,
                   FileAttribute<?>... attrs)
               throws IOException
```
    Throws:
    
    IOException
  - delete
```
void delete(TPath path)
      throws IOException
```
    Throws:
    
    IOException
  - getController
```
private FsController<?> getController()
```
  - getEntry
```
FsEntry getEntry(TPath path)
           throws IOException
```
    Throws:
    
    IOException
  - getFileAttributeView
```
@Nullable
<V extends FileAttributeView> V getFileAttributeView(TPath path,
                                                            Class<V> type,
                                                            LinkOption... options)
```
  - getFileStores
```
public Iterable<FileStore> getFileStores()
```
    Specified by:
    
    getFileStores in class FileSystem
    
    Throws:
    
    UnsupportedOperationException - always
  - getInputSocket
```
InputSocket<?> getInputSocket(TPath path,
                            BitField<FsInputOption> options)
```
  - getMountPoint
```
FsMountPoint getMountPoint()
```
  - getOutputSocket
```
OutputSocket<?> getOutputSocket(TPath path,
                              BitField<FsOutputOption> options,
                              @CheckForNull
                              Entry template)
```
  - getPath
```
public TPath getPath(String first,
            String... more)
```
    Constructs a new path from the given sub path strings.
    This method scans the path name resulting from the segment parameters to detect prospective archive files using the default archive detector.
    The supported path name separators are "File.separator" and "/". Any leading and trailing separators in the resulting path name get discarded.
    
    Specified by:
    
    getPath in class FileSystem
    
    Parameters:
    first - the first sub path string.
    more - optional sub path strings.
  - getPathMatcher
```
public PathMatcher getPathMatcher(String syntaxAndPattern)
```
    Specified by:
    
    getPathMatcher in class FileSystem
    
    Throws:
    
    UnsupportedOperationException - always
  - getRootDirectories
```
public Iterable<Path> getRootDirectories()
```
    Specified by:
    
    getRootDirectories in class FileSystem
  - getSeparator
```
public String getSeparator()
```
    Returns File.separator.
    
    Specified by:
    
    getSeparator in class FileSystem
    
    Returns:
    File.separator.
  - getUserPrincipalLookupService
```
public UserPrincipalLookupService getUserPrincipalLookupService()
```
    Specified by:
    
    getUserPrincipalLookupService in class FileSystem
    
    Throws:
    
    UnsupportedOperationException - always
  - invariants
```
private boolean invariants()
```
  - isLenient
```
public static boolean isLenient()
```
    Equivalent to TConfig.get().isLenient().
  - isOpen
```
public boolean isOpen()
```
    Returns true.
    
    Specified by:
    
    isOpen in class FileSystem
    
    Returns:
    true.
  - isReadOnly
```
public boolean isReadOnly()
```
    Returns false.
    
    Specified by:
    
    isReadOnly in class FileSystem
    
    Returns:
    false.
  - newByteChannel
```
SeekableByteChannel newByteChannel(TPath path,
                                 Set<? extends OpenOption> options,
                                 FileAttribute<?>... attrs)
                             throws IOException
```
    Throws:
    
    IOException
  - newDirectoryStream
```
DirectoryStream<Path> newDirectoryStream(TPath path,
                                       DirectoryStream.Filter<? super Path> filter)
                                   throws IOException
```
    Throws:
    
    IOException
  - newInputStream
```
InputStream newInputStream(TPath path,
                         OpenOption... options)
                     throws IOException
```
    Throws:
    
    IOException
  - newOutputStream
```
OutputStream newOutputStream(TPath path,
                           OpenOption... options)
                       throws IOException
```
    Throws:
    
    IOException
  - newWatchService
```
public WatchService newWatchService()
                             throws IOException
```
    Specified by:
    
    newWatchService in class FileSystem
    
    Throws:
    
    UnsupportedOperationException - always
    
    IOException
  - provider
```
public TFileSystemProvider provider()
```
    Specified by:
    
    provider in class FileSystem
  - readAttributes
```
<A extends BasicFileAttributes> A readAttributes(TPath path,
                                               Class<A> type,
                                               LinkOption... options)
                                       throws IOException
```
    Throws:
    
    IOException
  - setLenient
```
public static void setLenient(boolean lenient)
```
    Equivalent to TConfig.get().setLenient(lenient).
  - supportedFileAttributeViews
```
public Set<String> supportedFileAttributeViews()
```
    Specified by:
    
    supportedFileAttributeViews in class FileSystem
  - sync
```
public void sync(BitField<FsSyncOption> options)
          throws FsSyncException
```
    Commits all unsynchronized changes to the contents of this federated file system (i.e. prospective archive file) and all its member federated file systems to their respective parent file system, releases the associated resources (i.e. target archive files) for access by third parties (e.g. other processes), cleans up any temporary allocated resources (e.g. temporary files) and purges any cached data. Note that temporary files may get used even if the archive files where accessed read-only.
    If a client application needs to sync an individual archive file, the following idiom could be used:
```
if (file.isArchive() && file.getEnclArchive() == null) // filter top level federated file system
   if (file.isDirectory()) // ignore false positives
     TFile.sync(file); // sync federated file system and all its members
 
```
    Again, this will also sync all federated file systems which are located within the file system referred to by file.
    Parameters:
    options - a bit field of synchronization options.
    
    Throws:
    
    IllegalArgumentException - if archive is not a top level federated file system or the combination of synchronization options is illegal, e.g. if FsSyncOption.FORCE_CLOSE_INPUT is cleared and FsSyncOption.FORCE_CLOSE_OUTPUT is set or if the synchronization option FsSyncOption.ABORT_CHANGES is set.
    
    FsSyncWarningException - if only warning conditions occur. This implies that the respective parent file system has been updated with constraints, such as a failure to set the last modification time of the entry for the federated file system (i.e. archive file) in its parent file system.
    
    FsSyncException - if any error conditions occur. This implies loss of data!
    See Also:
    sync(BitField)

Class TFileSystem

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

controller

manager

provider

Constructor Detail

TFileSystem

Method Detail

checkAccess

close

createDirectory

delete

getController

getEntry

getFileAttributeView

getFileStores

getInputSocket

getMountPoint

getOutputSocket

getPath

getPathMatcher

getRootDirectories

getSeparator

getUserPrincipalLookupService

invariants

isLenient

isOpen

isReadOnly

newByteChannel

newDirectoryStream

newInputStream

newOutputStream

newWatchService

provider

readAttributes

setLenient

supportedFileAttributeViews

sync