IOCache (TrueZIP Kernel 7.4.1 API)

java.lang.Object
- de.schlichtherle.truezip.socket.IOCache

All Implemented Interfaces:

Closeable, Flushable, AutoCloseable
```
@ThreadSafe
@DefaultAnnotation(value=edu.umd.cs.findbugs.annotations.NonNull.class)
public final class IOCache
extends Object
implements Flushable, Closeable
```
Provides temporary caching services for input and output sockets with the following features:
- Upon the first read operation, the entry data will be read from the backing store and temporarily stored in the cache. Subsequent or concurrent read operations will be served from the cache without re-reading the entry data from the backing store again until the cache gets cleared.
- At the discretion of the IOCache.Strategy, entry data written to the cache may not be written to the backing store until the cache gets flushed.
- After a write operation, the entry data will be stored in the cache for subsequent read operations until the cache gets cleared.
- 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 cached entry data.
- When a cache gets picked up by the finalizer thread of the JVM, it gets cleared (this class is not a persistence service).
Author:

Christian Schlichtherle

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private class`	`IOCache.Buffer`
`private static class`	`IOCache.BufferSocketFactory`
`private static class`	`IOCache.CacheEntry` Hides backing store entries.
`private class`	`IOCache.Input`
`private class`	`IOCache.InputBufferPool`
`private static class`	`IOCache.Lock`
`private class`	`IOCache.Output`
`private class`	`IOCache.OutputBufferPool`
`static class`	`IOCache.Strategy` Provides different cache strategies.
`private class`	`IOCache.WriteBackOutputBufferPool`
`private class`	`IOCache.WriteThroughOutputBufferPool`

Field Summary

Fields
Modifier and Type	Field and Description
`private IOCache.Buffer`	`buffer`
`private static IOCache.BufferSocketFactory`	`FACTORY`
`private InputSocket<?>`	`input`
`private IOCache.InputBufferPool`	`inputBufferPool`
`private IOCache.Lock`	`lock`
`private OutputSocket<?>`	`output`
`private IOCache.OutputBufferPool`	`outputBufferPool`
`private IOPool<?>`	`pool`
`private IOCache.Strategy`	`strategy`

Constructor Summary

Constructors
Modifier	Constructor and Description
`private`	`IOCache(IOCache.Strategy strategy, IOPool<?> pool)` Constructs a new cache which applies the given caching strategy and uses the given pool to allocate and release temporary I/O entries.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`clear()` Discards the entry data in this buffer.
`void`	`close()` `Flushes` and finally `clears` this cache.
`IOCache`	`configure(InputSocket<?> input)` Configures the input socket for reading the entry data from the backing store.
`IOCache`	`configure(OutputSocket<?> output)` Configures the output socket for writing the entry data to the backing store.
`void`	`flush()` Writes the cached entry data to the backing store unless already done.
`private IOCache.Buffer`	`getBuffer()`
`Entry`	`getEntry()`
`private IOCache.InputBufferPool`	`getInputBufferPool()`
`InputSocket<?>`	`getInputSocket()` Returns an input socket for reading the cached entry data.
`private IOCache.OutputBufferPool`	`getOutputBufferPool()`
`OutputSocket<?>`	`getOutputSocket()` Returns an output socket for writing the cached entry data.
`private void`	`setBuffer(IOCache.Buffer newBuffer)`

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

- Field Detail
  - buffer
```
@CheckForNull
private volatile IOCache.Buffer buffer
```
  - FACTORY
```
private static final IOCache.BufferSocketFactory FACTORY
```
  - input
```
@Nullable
private volatile InputSocket<?> input
```
  - inputBufferPool
```
@CheckForNull
private volatile IOCache.InputBufferPool inputBufferPool
```
  - lock
```
private final IOCache.Lock lock
```
  - output
```
@Nullable
private volatile OutputSocket<?> output
```
  - outputBufferPool
```
@CheckForNull
private volatile IOCache.OutputBufferPool outputBufferPool
```
  - pool
```
private final IOPool<?> pool
```
  - strategy
```
private final IOCache.Strategy strategy
```
- Constructor Detail
  - IOCache
```
private IOCache(IOCache.Strategy strategy,
       IOPool<?> pool)
```
    Constructs a new cache which applies the given caching strategy and uses the given pool to allocate and release temporary I/O entries.
    Note that you need to call configure(InputSocket) before you can do any input. Likewise, you need to call configure(OutputSocket) before you can do any output.
    
    Parameters:
    strategy - the caching strategy.
    pool - the pool for allocating and releasing temporary I/O entries.
- Method Detail
  - clear
```
public void clear()
           throws IOException
```
    Discards the entry data in this buffer.
    
    Throws:
    
    IOException
  - close
```
public void close()
           throws IOException
```
    Flushes and finally clears this cache.
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Throws:
    
    IOException
  - configure
```
public IOCache configure(InputSocket<?> input)
```
    Configures the input socket for reading the entry data from the backing store. This method needs to be called before any input can be done - otherwise a NullPointerException will be thrown on the first read attempt. Note that calling this method does not clear this cache.
    
    Parameters:
    input - an input socket for reading the entry data from the backing store.
    
    Returns:
    this
  - configure
```
public IOCache configure(OutputSocket<?> output)
```
    Configures the output socket for writing the entry data to the backing store. This method needs to be called before any output can be done - otherwise a NullPointerException will be thrown on the first write attempt. Note that calling this method does not flush this cache.
    
    Parameters:
    output - an output socket for writing the entry data to the backing store.
    
    Returns:
    this
  - flush
```
public void flush()
           throws IOException
```
    Writes the cached entry data to the backing store unless already done. Whether or not this method needs to be called depends on the caching strategy. E.g. the caching strategy IOCache.Strategy.WRITE_THROUGH writes any changed entry data immediately, so calling this method has no effect.
    
    Specified by:
    
    flush in interface Flushable
    
    Throws:
    
    IOException
  - getBuffer
```
@CheckForNull
private IOCache.Buffer getBuffer()
```
  - getEntry
```
@Nullable
public Entry getEntry()
```
  - getInputBufferPool
```
private IOCache.InputBufferPool getInputBufferPool()
```
  - getInputSocket
```
public InputSocket<?> getInputSocket()
```
    Returns an input socket for reading the cached entry data.
    
    Returns:
    An input socket for reading the cached entry data.
  - getOutputBufferPool
```
private IOCache.OutputBufferPool getOutputBufferPool()
```
  - getOutputSocket
```
public OutputSocket<?> getOutputSocket()
```
    Returns an output socket for writing the cached entry data.
    
    Returns:
    An output socket for writing the cached entry data.
  - setBuffer
```
private void setBuffer(@CheckForNull
             IOCache.Buffer newBuffer)
                throws IOException
```
    Throws:
    
    IOException

Class IOCache

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

buffer

FACTORY

input

inputBufferPool

lock

output

outputBufferPool

pool

strategy

Constructor Detail

IOCache

Method Detail

clear

close

configure

configure

flush

getBuffer

getEntry

getInputBufferPool

getInputSocket

getOutputBufferPool

getOutputSocket

setBuffer