Uses of Class de.schlichtherle.truezip.fs.FsEntryName (TrueZIP Kernel 7.0-rc2 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

TrueZIP Kernel 7.0-rc2

PREV NEXT

FRAMES NO FRAMES

Uses of Class
de.schlichtherle.truezip.fs.FsEntryName

Packages that use FsEntryName
de.schlichtherle.truezip.fs	Provides access to (possibly federated virtual) file systems.
de.schlichtherle.truezip.fs.archive	Provides acces to archive files as if they were just directories.

Uses of FsEntryName in de.schlichtherle.truezip.fs

Fields in de.schlichtherle.truezip.fs declared as FsEntryName
`private FsEntryName`	`FsPath.entryName`
`(package private) FsEntryName`	`FsFederatingController.Input.name`
`(package private) FsEntryName`	`FsFederatingController.Output.name`
`(package private) FsEntryName`	`FsCachingController.Input.name`
`(package private) FsEntryName`	`FsCachingController.Output.name`
`private FsEntryName`	`FsCachingController.EntryCache.name`
`static FsEntryName`	`FsEntryName.ROOT` The file system entry name of the root directory, which is an empty URI.

Fields in de.schlichtherle.truezip.fs with type parameters of type FsEntryName
`private Map<FsEntryName,FsCachingController.EntryCache>`	`FsCachingController.caches`

Methods in de.schlichtherle.truezip.fs that return FsEntryName
`static FsEntryName`	`FsEntryName.create(String uri)` Equivalent to `create(uri, FsUriModifier.NULL)`.
`static FsEntryName`	`FsEntryName.create(String uri, FsUriModifier modifier)` Constructs a new file system entry name by constructing a new URI from the given string representation and parsing the result.
`static FsEntryName`	`FsEntryName.create(URI uri)` Equivalent to `create(uri, FsUriModifier.NULL)`.
`static FsEntryName`	`FsEntryName.create(URI uri, FsUriModifier modifier)` Constructs a new file system entry name by parsing the given URI.
`FsEntryName`	`FsPath.getEntryName()` Returns the entry name.
`private FsEntryName`	`FsFederatingController.resolveParent(FsEntryName name)`

Methods in de.schlichtherle.truezip.fs with parameters of type FsEntryName
`FsEntry`	`FsFederatingController.getEntry(FsEntryName name)`
`FsEntry`	`FsDecoratingController.getEntry(FsEntryName name)`
`abstract FsEntry`	`FsController.getEntry(FsEntryName name)`
`FsEntry`	`FsConcurrentController.getEntry(FsEntryName name)`
`FsEntry`	`FsCachingController.getEntry(FsEntryName name)`
`InputSocket<?>`	`FsStatisticsController.getInputSocket(FsEntryName name, BitField<FsInputOption> options)`
`InputSocket<?>`	`FsFederatingController.getInputSocket(FsEntryName name, BitField<FsInputOption> options)`
`InputSocket<?>`	`FsDecoratingController.getInputSocket(FsEntryName name, BitField<FsInputOption> options)`
`abstract InputSocket<?>`	`FsController.getInputSocket(FsEntryName name, BitField<FsInputOption> options)` Returns an input socket for reading the contents of the entry addressed by the given name from the file system.
`InputSocket<?>`	`FsConcurrentController.getInputSocket(FsEntryName name, BitField<FsInputOption> options)`
`InputSocket<?>`	`FsCachingController.getInputSocket(FsEntryName name, BitField<FsInputOption> options)`
`OutputSocket<?>`	`FsStatisticsController.getOutputSocket(FsEntryName name, BitField<FsOutputOption> options, Entry template)`
`OutputSocket<?>`	`FsFederatingController.getOutputSocket(FsEntryName name, BitField<FsOutputOption> options, Entry template)`
`OutputSocket<?>`	`FsDecoratingController.getOutputSocket(FsEntryName name, BitField<FsOutputOption> options, Entry template)`
`abstract OutputSocket<?>`	`FsController.getOutputSocket(FsEntryName name, BitField<FsOutputOption> options, Entry template)` Returns an output socket for writing the contents of the entry addressed by the given name to the file system.
`OutputSocket<?>`	`FsConcurrentController.getOutputSocket(FsEntryName name, BitField<FsOutputOption> options, Entry template)`
`OutputSocket<?>`	`FsCachingController.getOutputSocket(FsEntryName name, BitField<FsOutputOption> options, Entry template)`
`boolean`	`FsFederatingController.isReadable(FsEntryName name)`
`boolean`	`FsDecoratingController.isReadable(FsEntryName name)`
`abstract boolean`	`FsController.isReadable(FsEntryName name)`
`boolean`	`FsConcurrentController.isReadable(FsEntryName name)`
`boolean`	`FsFederatingController.isWritable(FsEntryName name)`
`boolean`	`FsDecoratingController.isWritable(FsEntryName name)`
`abstract boolean`	`FsController.isWritable(FsEntryName name)`
`boolean`	`FsConcurrentController.isWritable(FsEntryName name)`
`void`	`FsFederatingController.mknod(FsEntryName name, Entry.Type type, BitField<FsOutputOption> options, Entry template)`
`void`	`FsDecoratingController.mknod(FsEntryName name, Entry.Type type, BitField<FsOutputOption> options, Entry template)`
`abstract void`	`FsController.mknod(FsEntryName name, Entry.Type type, BitField<FsOutputOption> options, Entry template)` Creates or replaces and finally links a chain of one or more entries for the given entry `name` into the file system.
`void`	`FsConcurrentController.mknod(FsEntryName name, Entry.Type type, BitField<FsOutputOption> options, Entry template)`
`void`	`FsCachingController.mknod(FsEntryName name, Entry.Type type, BitField<FsOutputOption> options, Entry template)`
`FsPath`	`FsPath.resolve(FsEntryName entryName)` Resolves the given entry name against this path.
`FsPath`	`FsMountPoint.resolve(FsEntryName entryName)` Resolves the given entry name against this mount point.
`private FsEntryName`	`FsFederatingController.resolveParent(FsEntryName name)`
`void`	`FsFederatingController.setReadOnly(FsEntryName name)`
`void`	`FsDecoratingController.setReadOnly(FsEntryName name)`
`abstract void`	`FsController.setReadOnly(FsEntryName name)`
`void`	`FsConcurrentController.setReadOnly(FsEntryName name)`
`boolean`	`FsFederatingController.setTime(FsEntryName name, BitField<Entry.Access> types, long value)`
`boolean`	`FsDecoratingController.setTime(FsEntryName name, BitField<Entry.Access> types, long value)`
`abstract boolean`	`FsController.setTime(FsEntryName name, BitField<Entry.Access> types, long value)`
`boolean`	`FsConcurrentController.setTime(FsEntryName name, BitField<Entry.Access> types, long value)`
`void`	`FsFederatingController.unlink(FsEntryName name)`
`void`	`FsDecoratingController.unlink(FsEntryName name)`
`abstract void`	`FsController.unlink(FsEntryName name)`
`void`	`FsConcurrentController.unlink(FsEntryName name)`
`void`	`FsCachingController.unlink(FsEntryName name)`

Constructors in de.schlichtherle.truezip.fs with parameters of type FsEntryName
`FsCachingController.EntryCache(FsEntryName name)`
`FsCachingController.Input(FsEntryName name, BitField<FsInputOption> options)`
`FsCachingController.Output(FsEntryName name, BitField<FsOutputOption> options, Entry template)`
`FsEntryName(FsEntryName parent, FsEntryName member)` Constructs a new file system entry name by resolving the given member file system entry name against the given parent file system entry name.
`FsEntryNotFoundException(FsModel model, FsEntryName name, IOException cause)`
`FsEntryNotFoundException(FsModel model, FsEntryName name, String msg)`
`FsFederatingController.Input(FsEntryName name, BitField<FsInputOption> options)`
`FsFederatingController.Output(FsEntryName name, BitField<FsOutputOption> options, Entry template)`
`FsPath(FsMountPoint mountPoint, FsEntryName entryName)` Constructs a new path by synthesizing its URI from the given nullable mount point and entry name.
`FsStatisticsController.Input(FsEntryName name, BitField<FsInputOption> options)`
`FsStatisticsController.Output(FsEntryName name, BitField<FsOutputOption> options, Entry template)`

Uses of FsEntryName in de.schlichtherle.truezip.fs.archive

Fields in de.schlichtherle.truezip.fs.archive declared as FsEntryName
`(package private) FsEntryName`	`FsArchiveFileSystem.SegmentLink.name`
`(package private) FsEntryName`	`FsArchiveController.Input.name`
`(package private) FsEntryName`	`FsArchiveController.Output.name`
`private FsEntryName`	`FsDefaultArchiveController.parentName`

Methods in de.schlichtherle.truezip.fs.archive that return FsEntryName
`(package private) FsEntryName`	`FsArchiveFileSystem.Splitter.getParentName()`

Methods in de.schlichtherle.truezip.fs.archive with parameters of type FsEntryName

(package private) boolean FsDefaultArchiveController.autoSync(FsEntryName name, Entry.Access intention)

(package private) abstract boolean FsArchiveController.autoSync(FsEntryName name, Entry.Access intention)
Synchronizes the archive file only if the archive file has new data for the file system entry with the given path path.

static



<E extends FsArchiveEntry> 


FsArchiveFileSystemEntry<E>

FsArchiveFileSystemEntry.create(FsEntryName name,
       Entry.Type type,
       E entry)

Constructs a new archive file system entry which decorates the given archive entry.

private void FsArchiveFileSystem.fix(FsEntryName name)
Called from a constructor to fix the parent directories of the file system entry identified by name, ensuring that all parent directories of the file system entry exist and that they contain the respective base.

(package private) FsArchiveFileSystemEntry<E> FsArchiveFileSystem.ZipOrTarEntryTable.get(FsEntryName name, Entry.Type type)

(package private) FsArchiveFileSystemEntry<E> FsArchiveFileSystem.DefaultEntryTable.get(FsEntryName name, Entry.Type type)

(package private) abstract FsArchiveFileSystemEntry<E> FsArchiveFileSystem.MasterEntryTable.get(FsEntryName name, Entry.Type type)

(package private) FsArchiveFileSystemEntry<E> FsArchiveFileSystem.getEntry(FsEntryName name)

FsEntry FsArchiveController.getEntry(FsEntryName name)

InputSocket<?> FsArchiveController.getInputSocket(FsEntryName name, BitField<FsInputOption> options)

OutputSocket<?> FsArchiveController.getOutputSocket(FsEntryName name, BitField<FsOutputOption> options, Entry template)

boolean FsArchiveController.isReadable(FsEntryName name)

boolean FsArchiveFileSystem.isWritable(FsEntryName name)

boolean FsArchiveController.isWritable(FsEntryName name)

FsArchiveFileSystemOperation<E> FsReadOnlyArchiveFileSystem.mknod(FsEntryName name, Entry.Type type, BitField<FsOutputOption> options, Entry template)

FsArchiveFileSystemOperation<E> FsArchiveFileSystem.mknod(FsEntryName name, Entry.Type type, BitField<FsOutputOption> options, Entry template)
Begins a transaction to create or replace and finally link a chain of one or more archive entries for the given path into this archive file system.

void FsArchiveController.mknod(FsEntryName name, Entry.Type type, BitField<FsOutputOption> options, Entry template)

private FsArchiveFileSystemEntry<E> FsArchiveFileSystem.newEntryChecked(FsEntryName name, Entry.Type type, Entry template)
Returns a new file system entry for this (virtual) archive file system.

private FsArchiveFileSystemEntry<E> FsArchiveFileSystem.newEntryUnchecked(FsEntryName name, Entry.Type type, Entry template)
Like newEntryChecked(path, type, null), but wraps any CharConversionException in an AssertionError.

private FsArchiveFileSystem.SegmentLink<E>[] FsArchiveFileSystem.PathLink.newSegmentLinks(FsEntryName entryName, Entry.Type entryType, Entry template, int level)

(package private) void FsArchiveFileSystem.ZipOrTarEntryTable.remove(FsEntryName name, Entry.Type type)

(package private) void FsArchiveFileSystem.DefaultEntryTable.remove(FsEntryName name, Entry.Type type)

(package private) abstract void FsArchiveFileSystem.MasterEntryTable.remove(FsEntryName name, Entry.Type type)

void FsArchiveFileSystem.setReadOnly(FsEntryName name)

void FsArchiveController.setReadOnly(FsEntryName name)

boolean FsReadOnlyArchiveFileSystem.setTime(FsEntryName path, BitField<Entry.Access> types, long value)

boolean FsArchiveFileSystem.setTime(FsEntryName name, BitField<Entry.Access> types, long value)

boolean FsArchiveController.setTime(FsEntryName name, BitField<Entry.Access> types, long value)

(package private) void FsArchiveFileSystem.Splitter.split(FsEntryName name)

void FsReadOnlyArchiveFileSystem.unlink(FsEntryName path)

void FsDefaultArchiveController.unlink(FsEntryName name)

void FsArchiveFileSystem.unlink(FsEntryName name)
If this method returns, the file system entry identified by the given path has been successfully deleted from this archive file system.

void FsArchiveController.unlink(FsEntryName name)

Constructors in de.schlichtherle.truezip.fs.archive with parameters of type FsEntryName
`FsArchiveController.Input(FsEntryName name, BitField<FsInputOption> options)`
`FsArchiveController.Output(FsEntryName name, BitField<FsOutputOption> options, Entry template)`
`FsArchiveFileSystem.PathLink(FsEntryName name, Entry.Type type, boolean createParents, Entry template)`
`FsArchiveFileSystem.SegmentLink(FsEntryName name, String base, FsArchiveFileSystemEntry<E> entry)` Constructs a new `SegmentLink`.