FsCachingController (TrueZIP Kernel 7.1.3 API)

java.lang.Object
- de.schlichtherle.truezip.fs.FsController<M>
- - de.schlichtherle.truezip.fs.FsDecoratingController<FsConcurrentModel,FsController<? extends FsConcurrentModel>>
  - - de.schlichtherle.truezip.fs.FsCachingController

```
@NotThreadSafe
@DefaultAnnotation(value=edu.umd.cs.findbugs.annotations.NonNull.class)
public final class FsCachingController
extends FsDecoratingController<FsConcurrentModel,FsController<? extends FsConcurrentModel>>
```
A content caching file system controller implements a combined caching and buffering strategy for entry data. Decorating a concurrent file system controller with this class has the following effects:
- Caching and buffering needs to be activated by using the method input socket with the input option FsInputOption.CACHE or the method output socket with the output option FsOutputOption.CACHE.
- Unless a write operation succeeds, upon each read operation the entry data gets copied from the backing store for buffering purposes only.
- Upon a successful write operation, the entry data gets cached for subsequent read operations until the file system gets synced.
- Entry data written to the cache is not written to the backing store until the file system gets synced - this is a write back strategy.
- As a side effect, caching decouples the underlying storage from its clients, allowing it to create, read, update or delete the entry data while some clients are still busy on reading or writing the copied entry data.
Author:

Christian Schlichtherle

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`FsCachingController.CacheEntry` Hides backing store entries.
`private class`	`FsCachingController.EntryCache` A cache for the contents of an individual file system entry.
`private class`	`FsCachingController.Input`
`private class`	`FsCachingController.Output`

Field Summary

Fields
Modifier and Type Field and Description

private Map<FsEntryName,FsCachingController.EntryCache> caches

private IOPool<?> pool

private static IOCache.Strategy STRATEGY
- Fields inherited from class de.schlichtherle.truezip.fs.FsDecoratingController
  delegate

Fields
Modifier and Type	Field and Description
`private Map<FsEntryName,FsCachingController.EntryCache>`	`caches`
`private IOPool<?>`	`pool`
`private static IOCache.Strategy`	`STRATEGY`

Constructor Summary

Constructors
Constructor and Description
`FsCachingController(FsController<? extends FsConcurrentModel> controller, IOPool<?> pool)` Constructs a new content caching file system controller.

Method Summary

Methods
Modifier and Type	Method and Description
`private <X extends IOException> void`	`beforeSync(BitField<FsSyncOption> options, ExceptionHandler<? super FsSyncException,X> handler)`
`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.
`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.
`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.
`<X extends IOException> void`	`sync(BitField<FsSyncOption> options, ExceptionHandler<? super FsSyncException,X> handler)` Commits all unsynchronized changes to the contents of this file system to its parent file system, releases the associated resources (e.g. 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.
`void`	`unlink(FsEntryName name)`

Methods inherited from class de.schlichtherle.truezip.fs.FsDecoratingController
getClosedIcon, getEntry, getModel, getOpenIcon, getParent, isReadable, isReadOnly, isWritable, setReadOnly, setTime, toString

Methods inherited from class de.schlichtherle.truezip.fs.FsController
equals, hashCode, sync

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

- Field Detail
  - STRATEGY
```
private static final IOCache.Strategy STRATEGY
```
  - pool
```
private final IOPool<?> pool
```
  - caches
```
private final Map<FsEntryName,FsCachingController.EntryCache> caches
```
- Constructor Detail
  - FsCachingController
```
public FsCachingController(FsController<? extends FsConcurrentModel> controller,
                   IOPool<?> pool)
```
    Constructs a new content caching file system controller.
    
    Parameters:
    controller - the decorated file system controller.
    pool - the pool of temporary entries to hold the copied entry data.
- Method Detail
  - getInputSocket
```
public 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.
    
    Overrides:
    
    getInputSocket in class FsDecoratingController<FsConcurrentModel,FsController<? extends FsConcurrentModel>>
    
    Parameters:
    name - the file system entry name.
    options - the input options.
    
    Returns:
    An InputSocket.
  - getOutputSocket
```
public OutputSocket<?> getOutputSocket(FsEntryName name,
                              BitField<FsOutputOption> options,
                              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.
    
    Overrides:
    
    getOutputSocket in class FsDecoratingController<FsConcurrentModel,FsController<? extends 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.
  - mknod
```
public void mknod(FsEntryName name,
         Entry.Type type,
         BitField<FsOutputOption> options,
         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.
    Overrides:
    
    mknod in class FsDecoratingController<FsConcurrentModel,FsController<? extends 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
```
    Overrides:
    
    unlink in class FsDecoratingController<FsConcurrentModel,FsController<? extends FsConcurrentModel>>
    
    Throws:
    
    IOException
  - sync
```
public <X extends IOException> void sync(BitField<FsSyncOption> options,
                                ExceptionHandler<? super FsSyncException,X> handler)
          throws X extends IOException
```
    Description copied from class: FsController
    
    Commits all unsynchronized changes to the contents of this file system to its parent file system, releases the associated resources (e.g. 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 resources may get allocated even if the federated file systems were accessed read-only. If this is not a federated file system, i.e. if its not a member of a parent file system, then nothing happens. Otherwise, the state of this file system controller is reset.
    
    Overrides:
    
    sync in class FsDecoratingController<FsConcurrentModel,FsController<? extends FsConcurrentModel>>
    
    Type Parameters:
    X - The type of the IOException to throw at the discretion of the exception handler.
    Parameters:
    options - a bit field of synchronization options.
    handler - the exception handling strategy for consuming input FsSyncExceptions and/or assembling output IOExceptions.
    
    Throws:
    
    X extends IOException
  - beforeSync
```
private <X extends IOException> void beforeSync(BitField<FsSyncOption> options,
                                      ExceptionHandler<? super FsSyncException,X> handler)
                 throws X extends IOException
```
    Throws:
    
    X extends IOException

Class FsCachingController

Nested Class Summary

Field Summary

Fields inherited from class de.schlichtherle.truezip.fs.FsDecoratingController

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Field Detail

STRATEGY

pool

caches

Constructor Detail

FsCachingController

Method Detail

getInputSocket

getOutputSocket

mknod

unlink

sync

beforeSync