Class FileBuffer

java.lang.Object
org.simpleframework.common.buffer.FileBuffer
All Implemented Interfaces:
Buffer

class FileBuffer extends Object implements Buffer
The FileBuffer object is used to create a buffer which will write the appended data to an underlying file. This is typically used for buffers that are too large for to allocate in memory. Data appended to the buffer can be retrieved at a later stage by acquiring the InputStream for the underlying file. To ensure that excessive file system space is not occupied the buffer files are cleaned every five minutes.
See Also:
  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Class
    Description
    private class 
    The Range object is used to provide a stream that can read a range of bytes from a provided input stream.
    private class 
    The Segment object is used to create a segment of the parent buffer.
  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    private OutputStream
    This is the file output stream used for this buffer object.
    private boolean
    This is used to determine if this buffer has been closed.
    private long
    This is the number of bytes currently appended to the buffer.
    private File
    This is the path for the file that this buffer appends to.
    This represents the last file segment that has been created.
  • Constructor Summary

    Constructors
    Constructor
    Description
    Constructor for the FileBuffer object.
  • Method Summary

    Modifier and Type
    Method
    Description
    This is used to allocate a segment within this buffer.
    append(byte[] array)
    This is used to append the specified data to the underlying file.
    append(byte[] array, int off, int size)
    This is used to append the specified data to the underlying file.
    void
    This will clear all data from the buffer.
    void
    This method is used to ensure the buffer can be closed.
    private String
    convert(InputStream source, String charset, int count)
    This method is used to acquire the buffered bytes as a string.
    This method is used to acquire the buffered bytes as a string.
    encode(String charset)
    This method is used to acquire the buffered bytes as a string.
    long
    This is used to provide the number of bytes that have been written to the buffer.
    This method is used so that a buffer can be represented as a stream of bytes.
    private InputStream
    open(File file)
    This method is used so that a buffer can be represented as a stream of bytes.

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
  • Field Details

    • buffer

      private OutputStream buffer
      This is the file output stream used for this buffer object.
    • segment

      private FileBuffer.Segment segment
      This represents the last file segment that has been created.
    • file

      private File file
      This is the path for the file that this buffer appends to.
    • count

      private long count
      This is the number of bytes currently appended to the buffer.
    • closed

      private boolean closed
      This is used to determine if this buffer has been closed.
  • Constructor Details

    • FileBuffer

      public FileBuffer(File file) throws IOException
      Constructor for the FileBuffer object. This will create a buffer using the provided file. All data appended to this buffer will effectively written to the underlying file. If the appended data needs to be retrieved at a later stage then it can be acquired using the buffers input stream.
      Parameters:
      file - this is the file used for the file buffer
      Throws:
      IOException
  • Method Details

    • allocate

      public Buffer allocate() throws IOException
      This is used to allocate a segment within this buffer. If the buffer is closed this will throw an exception, if however the buffer is still open then a segment is created which will write all appended data to this buffer. However it can be treated as an independent source of data.
      Specified by:
      allocate in interface Buffer
      Returns:
      this returns a buffer which is a segment of this
      Throws:
      IOException
    • append

      public Buffer append(byte[] array) throws IOException
      This is used to append the specified data to the underlying file. All bytes appended to the file can be consumed at a later stage by acquiring the InputStream from this buffer. Also if require the data can be encoded as a string object in a required character set.
      Specified by:
      append in interface Buffer
      Parameters:
      array - this is the array to write the the file
      Returns:
      this returns this buffer for further operations
      Throws:
      IOException
    • append

      public Buffer append(byte[] array, int off, int size) throws IOException
      This is used to append the specified data to the underlying file. All bytes appended to the file can be consumed at a later stage by acquiring the InputStream from this buffer. Also if require the data can be encoded as a string object in a required character set.
      Specified by:
      append in interface Buffer
      Parameters:
      array - this is the array to write the the file
      off - this is the offset within the array to write
      size - this is the number of bytes to be appended
      Returns:
      this returns this buffer for further operations
      Throws:
      IOException
    • encode

      public String encode() throws IOException
      This method is used to acquire the buffered bytes as a string. This is useful if the contents need to be manipulated as a string or transferred into another encoding. If the UTF-8 content encoding is not supported the platform default is used, however this is unlikely as UTF-8 should be supported.
      Specified by:
      encode in interface Buffer
      Returns:
      this returns a UTF-8 encoding of the buffer contents
      Throws:
      IOException
    • encode

      public String encode(String charset) throws IOException
      This method is used to acquire the buffered bytes as a string. This is useful if the contents need to be manipulated as a string or transferred into another encoding. This will convert the bytes using the specified character encoding format.
      Specified by:
      encode in interface Buffer
      Parameters:
      charset - this is the charset to encode the data with
      Returns:
      this returns the encoding of the buffer contents
      Throws:
      IOException
    • convert

      private String convert(InputStream source, String charset, int count) throws IOException
      This method is used to acquire the buffered bytes as a string. This is useful if the contents need to be manipulated as a string or transferred into another encoding. This will convert the bytes using the specified character encoding format.
      Parameters:
      source - this is the source stream that is to be encoded
      charset - this is the charset to encode the data with
      count - this is the number of bytes to be encoded
      Returns:
      this returns the encoding of the buffer contents
      Throws:
      IOException
    • open

      public InputStream open() throws IOException
      This method is used so that a buffer can be represented as a stream of bytes. This provides a quick means to access the data that has been written to the buffer. It wraps the buffer within an input stream so that it can be read directly.
      Specified by:
      open in interface Buffer
      Returns:
      a stream that can be used to read the buffered bytes
      Throws:
      IOException
    • open

      private InputStream open(File file) throws IOException
      This method is used so that a buffer can be represented as a stream of bytes. This provides a quick means to access the data that has been written to the buffer. It wraps the buffer within an input stream so that it can be read directly.
      Parameters:
      file - this is the file used to create the input stream
      Returns:
      a stream that can be used to read the buffered bytes
      Throws:
      IOException
    • clear

      public void clear() throws IOException
      This will clear all data from the buffer. This simply sets the count to be zero, it will not clear the memory occupied by the instance as the internal buffer will remain. This allows the memory occupied to be reused as many times as is required.
      Specified by:
      clear in interface Buffer
      Throws:
      IOException
    • close

      public void close() throws IOException
      This method is used to ensure the buffer can be closed. Once the buffer is closed it is an immutable collection of bytes and can not longer be modified. This ensures that it can be passed by value without the risk of modification of the bytes.
      Specified by:
      close in interface Buffer
      Throws:
      IOException
    • length

      public long length()
      This is used to provide the number of bytes that have been written to the buffer. This increases as bytes are appended to the buffer. if the buffer is cleared this resets to zero.
      Specified by:
      length in interface Buffer
      Returns:
      this returns the number of bytes within the buffer