FsArchiveController (TrueZIP Kernel 7.1.3 API)

java.lang.Object
- de.schlichtherle.truezip.fs.FsController<FsConcurrentModel>
- - de.schlichtherle.truezip.fs.archive.FsArchiveController<E>

Type Parameters:
E - The type of the archive entries.

Direct Known Subclasses:

FsFileSystemArchiveController
```
@NotThreadSafe
@DefaultAnnotation(value=edu.umd.cs.findbugs.annotations.NonNull.class)
public abstract class FsArchiveController<E extends FsArchiveEntry>
extends FsController<FsConcurrentModel>
```
An abstract archive controller which is the super class for any archive controller, providing all the essential services required for accessing an archive file. It encapsulates all the code which is not depending on a particular archive update strategy and the corresponding state of the controller.
Each instance of this class manages an archive file - the target file - in order to allow random access to it as if it were a regular directory in its parent file system.
Note that in general all of the methods in this class are reentrant on exceptions. This is important because client applications may repeatedly call them. Of course, depending on the calling context, some or all of the archive file's data may be lost in this case.

Author:

Christian Schlichtherle

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private class`	`FsArchiveController.Input`
`private class`	`FsArchiveController.Output`
`private static class`	`FsArchiveController.ProxyEntry`

Field Summary

Fields
Modifier and Type	Field and Description
`private static BitField<FsOutputOption>`	`AUTO_MOUNT_OPTIONS`
`private static Logger`	`logger`
`private FsConcurrentModel`	`model`
`private static BitField<FsSyncOption>`	`UNLINK_SYNC_OPTIONS`

Constructor Summary

Constructors
Modifier Constructor and Description

protected FsArchiveController(FsConcurrentModel model)
Constructs a new basic archive controller.

Constructors
Modifier	Constructor and Description
`protected`	`FsArchiveController(FsConcurrentModel model)` Constructs a new basic archive controller.

Method Summary

Methods
Modifier and Type	Method and Description
`(package private) FsArchiveFileSystem<E>`	`autoMount()`
`(package private) abstract FsArchiveFileSystem<E>`	`autoMount(boolean autoCreate, BitField<FsOutputOption> options)` Returns the (virtual) archive file system mounted from the target archive file.
`(package private) abstract boolean`	`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.
`FsEntry`	`getEntry(FsEntryName name)` Returns a file system entry or `null` if no file system entry exists for the given name.
`InputSocket<?>`	`getInputSocket(FsEntryName name, BitField<FsInputOption> options)` Returns an input socket for reading the contents of the file system entry addressed by the given name from the file system.
`(package private) abstract InputSocket<?>`	`getInputSocket(String name)`
`FsConcurrentModel`	`getModel()` Returns the file system model.
`(package private) abstract OutputSocket<?>`	`getOutputSocket(E entry)`
`OutputSocket<?>`	`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.
`boolean`	`isReadable(FsEntryName name)`
`boolean`	`isReadOnly()`
`boolean`	`isWritable(FsEntryName name)`
`void`	`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`	`setReadOnly(FsEntryName name)`
`boolean`	`setTime(FsEntryName name, BitField<Entry.Access> types, long value)` Makes an attempt to set the last access time of all types in the given bit field for the file system entry with the given name.
`void`	`unlink(FsEntryName name)`

Methods inherited from class de.schlichtherle.truezip.fs.FsController
equals, getClosedIcon, getOpenIcon, getParent, hashCode, sync, sync, toString

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

- Field Detail
  - logger
```
private static final Logger logger
```
  - AUTO_MOUNT_OPTIONS
```
private static final BitField<FsOutputOption> AUTO_MOUNT_OPTIONS
```
  - UNLINK_SYNC_OPTIONS
```
private static final BitField<FsSyncOption> UNLINK_SYNC_OPTIONS
```
  - model
```
private final FsConcurrentModel model
```
- Constructor Detail
  - FsArchiveController
```
protected FsArchiveController(FsConcurrentModel model)
```
    Constructs a new basic archive controller.
    
    Parameters:
    model - the non-null archive model.
- Method Detail
  - getModel
```
public final FsConcurrentModel getModel()
```
    Description copied from class: FsController
    
    Returns the file system model.
    
    Specified by:
    
    getModel in class FsController<FsConcurrentModel>
    
    Returns:
    The file system model.
  - autoMount
```
final FsArchiveFileSystem<E> autoMount()
                                                       throws IOException
```
    Throws:
    
    IOException
  - autoMount
```
abstract FsArchiveFileSystem<E> autoMount(boolean autoCreate,
                               BitField<FsOutputOption> options)
                                                          throws IOException
```
    Returns the (virtual) archive file system mounted from the target archive file. This method is reentrant with respect to any exceptions it may throw.
    Warning: Either the read or the write lock of this controller must be acquired while this method is called! If only a read lock is acquired, but a write lock is required, this method will temporarily release all locks, so any preconditions must be checked again upon return to protect against concurrent modifications!
    
    Parameters:
    autoCreate - If the archive file does not exist and this is true, a new file system with only a (virtual) root directory is created with its last modification time set to the system's current time.
    
    Returns:
    A valid archive file system - null is never returned.
    
    Throws:
    
    IOException
  - isReadOnly
```
public final boolean isReadOnly()
                         throws IOException
```
    Specified by:
    
    isReadOnly in class FsController<FsConcurrentModel>
    
    Throws:
    
    IOException
  - getEntry
```
public final FsEntry getEntry(FsEntryName name)
                       throws IOException
```
    Description copied from class: FsController
    
    Returns a file system entry or null if no file system entry exists for the given name. Modifying the returned object graph is either not supported (i.e. throws an UnsupportedOperationException) or does not show any effect on the file system.
    
    Specified by:
    
    getEntry in class FsController<FsConcurrentModel>
    
    Parameters:
    name - the name of the file system entry to look up.
    
    Returns:
    A file system entry or null if no file system entry exists for the given name.
    
    Throws:
    
    IOException - on any I/O error.
  - isReadable
```
public final boolean isReadable(FsEntryName name)
                         throws IOException
```
    Specified by:
    
    isReadable in class FsController<FsConcurrentModel>
    
    Throws:
    
    IOException
  - isWritable
```
public final boolean isWritable(FsEntryName name)
                         throws IOException
```
    Specified by:
    
    isWritable in class FsController<FsConcurrentModel>
    
    Throws:
    
    IOException
  - setReadOnly
```
public final void setReadOnly(FsEntryName name)
                       throws IOException
```
    Specified by:
    
    setReadOnly in class FsController<FsConcurrentModel>
    
    Throws:
    
    IOException
  - setTime
```
public final boolean setTime(FsEntryName name,
              BitField<Entry.Access> types,
              long value)
                      throws IOException
```
    Description copied from class: FsController
    
    Makes an attempt to set the last access time of all types in the given bit field for the file system entry with the given name. If false is returned or an IOException is thrown, then still some of the last access times may have been set. In other words, this is not an atomic operation if multiple access types are given. To make this operation atomic, set the last access time for a single type only.
    
    Specified by:
    
    setTime in class FsController<FsConcurrentModel>
    
    Parameters:
    name - the file system entry name.
    types - the access types
    value - the last access time.
    
    Returns:
    true if and only if setting the access time for all types in types succeeded.
    
    Throws:
    
    IOException - on any I/O error.
  - getInputSocket
```
public final InputSocket<?> getInputSocket(FsEntryName name,
                            BitField<FsInputOption> options)
```
    Description copied from class: FsController
    
    Returns an input socket for reading the contents of the file system entry addressed by the given name from the file system.
    
    Specified by:
    
    getInputSocket in class FsController<FsConcurrentModel>
    
    Parameters:
    name - the file system entry name.
    options - the input options.
    
    Returns:
    An InputSocket.
  - getInputSocket
```
abstract InputSocket<?> getInputSocket(String name)
                                throws IOException
```
    Throws:
    
    IOException
  - getOutputSocket
```
public final OutputSocket<?> getOutputSocket(FsEntryName name,
                              BitField<FsOutputOption> options,
                              @CheckForNull
                              Entry template)
```
    Description copied from class: FsController
    
    Returns an output socket for writing the contents of the entry addressed by the given name to the file system. If template is not null, then the output entry shall have as many of its properties copied as reasonable, e.g. the last modification time.
    
    Specified by:
    
    getOutputSocket in class FsController<FsConcurrentModel>
    
    Parameters:
    name - a file system entry name.
    options - a bit field of output options.
    template - a nullable template for the properties of the output entry.
    
    Returns:
    An OutputSocket.
  - getOutputSocket
```
abstract OutputSocket<?> getOutputSocket(E entry)
                                  throws IOException
```
    Throws:
    
    IOException
  - mknod
```
public final void mknod(FsEntryName name,
         Entry.Type type,
         BitField<FsOutputOption> options,
         @CheckForNull
         Entry template)
                 throws IOException
```
    Description copied from class: FsController
    
    Creates or replaces and finally links a chain of one or more entries for the given entry name into the file system.
    Specified by:
    
    mknod in class FsController<FsConcurrentModel>
    
    Parameters:
    name - the file system entry name.
    type - the file system entry type.
    options - the file system output options. If CREATE_PARENTS is set, any missing parent directories will be created and linked into this file system with its last modification time set to the system's current time.
    template - if not null, then the file system entry at the end of the chain shall inherit as much properties from this entry as possible - with the exception of its name and type.
    
    Throws:
    IOException - on any I/O error, including but not limited to these reasons:
    
    The file system is read only.
    name contains characters which are not supported by the file system.
    The entry already exists and either the option FsOutputOption.EXCLUSIVE is set or the entry is a directory.
    The entry exists as a different type.
    A parent entry exists but is not a directory.
    A parent entry is missing and createParents is false.
  - unlink
```
public void unlink(FsEntryName name)
            throws IOException
```
    Specified by:
    
    unlink in class FsController<FsConcurrentModel>
    
    Throws:
    
    IOException
  - autoSync
```
abstract boolean autoSync(FsEntryName name,
               @CheckForNull
               Entry.Access intention)
                   throws FsSyncException,
                          FsException
```
    Synchronizes the archive file only if the archive file has new data for the file system entry with the given path path.
    Warning: As a side effect, all data structures may get reset (filesystem, entries, streams, etc.)! This method may require synchronization on the write lock!
    
    Parameters:
    name - the non-null entry name.
    intention - the intended operation on the entry. If null, a pure file system operation with no I/O is intended.
    
    Returns:
    Whether or not a synchronization has been performed.
    
    Throws:
    
    IOException - if any exceptional condition occurs throughout the synchronization of the target archive file.
    
    FsSyncException
    
    FsException
    See Also:
    FsController.sync(de.schlichtherle.truezip.util.BitField<de.schlichtherle.truezip.fs.FsSyncOption>)

Class FsArchiveController<E extends FsArchiveEntry>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class de.schlichtherle.truezip.fs.FsController

Methods inherited from class java.lang.Object

Field Detail

logger

AUTO_MOUNT_OPTIONS

UNLINK_SYNC_OPTIONS

model

Constructor Detail

FsArchiveController

Method Detail

getModel

autoMount

autoMount

isReadOnly

getEntry

isReadable

isWritable

setReadOnly

setTime

getInputSocket

getInputSocket

getOutputSocket

getOutputSocket

mknod

unlink

autoSync