SequentialFile (ActiveMQ Artemis Journal 2.8.0 API)

All Known Implementing Classes:

AbstractSequentialFile, AIOSequentialFile, NIOSequentialFile
```
public interface SequentialFile
```

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`static long`	`appendTo(Path src, Path dst)`
`void`	`blockingWriteDirect(ByteBuffer bytes, boolean sync, boolean releaseBuffer)` Write directly to the file without using any intermediate buffer and wait completion. If `releaseBuffer` is `true` the provided `bytes` should be released through `SequentialFileFactory.releaseBuffer(ByteBuffer)`, if supported.
`int`	`calculateBlockStart(int position)`
`SequentialFile`	`cloneFile()`
`void`	`close()`
`default void`	`close(boolean waitSync)` When closing a file from a finalize block, you cant wait on syncs or anything like that.
`void`	`copyTo(SequentialFile newFileName)`
`void`	`delete()`
`boolean`	`exists()`
`void`	`fill(int size)`
`boolean`	`fits(int size)`
`String`	`getFileName()`
`File`	`getJavaFile()` Returns a native File of the file underlying this sequential file.
`boolean`	`isOpen()`
`void`	`open()`
`void`	`open(int maxIO, boolean useExecutor)` The maximum number of simultaneous writes accepted
`long`	`position()`
`void`	`position(long pos)`
`int`	`read(ByteBuffer bytes)`
`int`	`read(ByteBuffer bytes, IOCallback callback)`
`void`	`renameTo(String newFileName)`
`void`	`setTimedBuffer(TimedBuffer buffer)`
`long`	`size()`
`void`	`sync()`
`void`	`write(ActiveMQBuffer bytes, boolean sync)`
`void`	`write(ActiveMQBuffer bytes, boolean sync, IOCallback callback)`
`void`	`write(EncodingSupport bytes, boolean sync)`
`void`	`write(EncodingSupport bytes, boolean sync, IOCallback callback)`
`void`	`writeDirect(ByteBuffer bytes, boolean sync)` Write directly to the file without using intermediate any buffer
`void`	`writeDirect(ByteBuffer bytes, boolean sync, IOCallback callback)` Write directly to the file without using any buffer

- Method Detail
  - isOpen
```
boolean isOpen()
```
  - exists
```
boolean exists()
```
  - open
```
void open()
   throws Exception
```
    Throws:
    
    Exception
  - open
```
void open(int maxIO,
          boolean useExecutor)
   throws Exception
```
    The maximum number of simultaneous writes accepted
    
    Parameters:
    
    maxIO -
    
    Throws:
    
    Exception
  - fits
```
boolean fits(int size)
```
  - calculateBlockStart
```
int calculateBlockStart(int position)
                 throws Exception
```
    Throws:
    
    Exception
  - getFileName
```
String getFileName()
```
  - fill
```
void fill(int size)
   throws Exception
```
    Throws:
    
    Exception
  - delete
```
void delete()
     throws IOException,
            InterruptedException,
            ActiveMQException
```
    Throws:
    
    IOException
    
    InterruptedException
    
    ActiveMQException
  - write
```
void write(ActiveMQBuffer bytes,
           boolean sync,
           IOCallback callback)
    throws Exception
```
    Throws:
    
    Exception
  - write
```
void write(ActiveMQBuffer bytes,
           boolean sync)
    throws Exception
```
    Throws:
    
    Exception
  - write
```
void write(EncodingSupport bytes,
           boolean sync,
           IOCallback callback)
    throws Exception
```
    Throws:
    
    Exception
  - write
```
void write(EncodingSupport bytes,
           boolean sync)
    throws Exception
```
    Throws:
    
    Exception
  - writeDirect
```
void writeDirect(ByteBuffer bytes,
                 boolean sync,
                 IOCallback callback)
```
    Write directly to the file without using any buffer
    
    Parameters:
    
    bytes - the ByteBuffer must be compatible with the SequentialFile implementation (AIO or NIO). To be safe, use a buffer from the corresponding SequentialFileFactory.newBuffer(int).
  - writeDirect
```
void writeDirect(ByteBuffer bytes,
                 boolean sync)
          throws Exception
```
    Write directly to the file without using intermediate any buffer
    
    Parameters:
    
    bytes - the ByteBuffer must be compatible with the SequentialFile implementation (AIO or NIO). To be safe, use a buffer from the corresponding SequentialFileFactory.newBuffer(int).
    
    Throws:
    
    Exception
  - blockingWriteDirect
```
void blockingWriteDirect(ByteBuffer bytes,
                         boolean sync,
                         boolean releaseBuffer)
                  throws Exception
```
    Write directly to the file without using any intermediate buffer and wait completion.
    If releaseBuffer is true the provided bytes should be released through SequentialFileFactory.releaseBuffer(ByteBuffer), if supported.
    
    Parameters:
    
    bytes - the ByteBuffer must be compatible with the SequentialFile implementation (AIO or NIO). If releaseBuffer is true use a buffer from SequentialFileFactory.newBuffer(int), SequentialFileFactory.allocateDirectBuffer(int) otherwise.
    
    sync - if true will durable flush the written data on the file, false otherwise
    
    releaseBuffer - if true will release the buffer, false otherwise
    
    Throws:
    
    Exception
  - read
```
int read(ByteBuffer bytes,
         IOCallback callback)
  throws Exception
```
    Parameters:
    
    bytes - the ByteBuffer must be compatible with the SequentialFile implementation (AIO or NIO). To be safe, use a buffer from the corresponding SequentialFileFactory.newBuffer(int).
    
    Throws:
    
    Exception
  - read
```
int read(ByteBuffer bytes)
  throws Exception
```
    Parameters:
    
    bytes - the ByteBuffer must be compatible with the SequentialFile implementation (AIO or NIO). To be safe, use a buffer from the corresponding SequentialFileFactory.newBuffer(int).
    
    Throws:
    
    Exception
  - position
```
void position(long pos)
       throws IOException
```
    Throws:
    
    IOException
  - position
```
long position()
```
  - close
```
void close()
    throws Exception
```
    Throws:
    
    Exception
  - close
```
default void close(boolean waitSync)
            throws Exception
```
    When closing a file from a finalize block, you cant wait on syncs or anything like that. otherwise the VM may hung. Especially on the testsuite.
    
    Throws:
    
    Exception
  - sync
```
void sync()
   throws IOException
```
    Throws:
    
    IOException
  - size
```
long size()
   throws Exception
```
    Throws:
    
    Exception
  - renameTo
```
void renameTo(String newFileName)
       throws Exception
```
    Throws:
    
    Exception
  - cloneFile
```
SequentialFile cloneFile()
```
  - copyTo
```
void copyTo(SequentialFile newFileName)
     throws Exception
```
    Throws:
    
    Exception
  - setTimedBuffer
```
void setTimedBuffer(TimedBuffer buffer)
```
  - getJavaFile
```
File getJavaFile()
```
    Returns a native File of the file underlying this sequential file.
  - appendTo
```
static long appendTo(Path src,
                     Path dst)
              throws IOException
```
    Throws:
    
    IOException

Interface SequentialFile

Method Summary

Method Detail

isOpen

exists

open

open

fits

calculateBlockStart

getFileName

fill

delete

write

write

write

write

writeDirect

writeDirect

blockingWriteDirect

read

read

position

position

close

close

sync

size

renameTo

cloneFile

copyTo

setTimedBuffer

getJavaFile

appendTo