Class TemporaryBuffer

java.lang.Object
java.io.OutputStream
org.eclipse.jgit.util.TemporaryBuffer
All Implemented Interfaces:
Closeable, Flushable, AutoCloseable
Direct Known Subclasses:
SmartOutputStream, TemporaryBuffer.Heap, TemporaryBuffer.LocalFile, TransportHttp.Service.HttpOutputStream

public abstract class TemporaryBuffer extends OutputStream
A fully buffered output stream.

Subclasses determine the behavior when the in-memory buffer capacity has been exceeded and additional bytes are still being received for output.

  • Field Details

    • DEFAULT_IN_CORE_LIMIT

      protected static final int DEFAULT_IN_CORE_LIMIT
      Default limit for in-core storage.
      See Also:
    • blocks

      Chain of data, if we are still completely in-core; otherwise null.
    • inCoreLimit

      private int inCoreLimit
      Maximum number of bytes we will permit storing in memory.

      When this limit is reached the data will be shifted to a file on disk, preventing the JVM heap from growing out of control.

    • initialBlocks

      private int initialBlocks
      Initial size of block list.
    • overflow

      private OutputStream overflow
      If inCoreLimit has been reached, remainder goes here.
  • Constructor Details

    • TemporaryBuffer

      protected TemporaryBuffer(int limit)
      Create a new empty temporary buffer.
      Parameters:
      limit - maximum number of bytes to store in memory before entering the overflow output path; also used as the estimated size.
    • TemporaryBuffer

      protected TemporaryBuffer(int estimatedSize, int limit)
      Create a new empty temporary buffer.
      Parameters:
      estimatedSize - estimated size of storage used, to size the initial list of block pointers.
      limit - maximum number of bytes to store in memory before entering the overflow output path.
      Since:
      4.0
  • Method Details

    • write

      public void write(int b) throws IOException
      Specified by:
      write in class OutputStream
      Throws:
      IOException
    • write

      public void write(byte[] b, int off, int len) throws IOException
      Overrides:
      write in class OutputStream
      Throws:
      IOException
    • doFlush

      protected void doFlush() throws IOException
      Dumps the entire buffer into the overflow stream, and flushes it.
      Throws:
      IOException - the overflow stream cannot be started, or the buffer contents cannot be written to it, or it failed to flush.
    • copy

      public void copy(InputStream in) throws IOException
      Copy all bytes remaining on the input stream into this buffer.
      Parameters:
      in - the stream to read from, until EOF is reached.
      Throws:
      IOException - an error occurred reading from the input stream, or while writing to a local temporary file.
    • length

      public long length()
      Obtain the length (in bytes) of the buffer.

      The length is only accurate after close() has been invoked.

      Returns:
      total length of the buffer, in bytes.
    • inCoreLength

      private long inCoreLength()
    • toByteArray

      public byte[] toByteArray() throws IOException
      Convert this buffer's contents into a contiguous byte array.

      The buffer is only complete after close() has been invoked.

      Returns:
      the complete byte array; length matches length().
      Throws:
      IOException - an error occurred reading from a local temporary file
    • toByteArray

      public byte[] toByteArray(int limit) throws IOException
      Convert this buffer's contents into a contiguous byte array. If this size of the buffer exceeds the limit only return the first limit bytes

      The buffer is only complete after close() has been invoked.

      Parameters:
      limit - the maximum number of bytes to be returned
      Returns:
      the byte array limited to limit bytes.
      Throws:
      IOException - an error occurred reading from a local temporary file
      Since:
      4.2
    • writeTo

      public void writeTo(OutputStream os, ProgressMonitor pm) throws IOException
      Send this buffer to an output stream.

      This method may only be invoked after close() has completed normally, to ensure all data is completely transferred.

      Parameters:
      os - stream to send this buffer's complete content to.
      pm - if not null progress updates are sent here. Caller should initialize the task and the number of work units to length()/1024.
      Throws:
      IOException - an error occurred reading from a temporary file on the local system, or writing to the output stream.
    • openInputStream

      public InputStream openInputStream() throws IOException
      Open an input stream to read from the buffered data.

      This method may only be invoked after close() has completed normally, to ensure all data is completely transferred.

      Returns:
      a stream to read from the buffer. The caller must close the stream when it is no longer useful.
      Throws:
      IOException - an error occurred opening the temporary file.
    • openInputStreamWithAutoDestroy

      public InputStream openInputStreamWithAutoDestroy() throws IOException
      Same as openInputStream() but handling destruction of any associated resources automatically when closing the returned stream.
      Returns:
      an InputStream which will automatically destroy any associated temporary file on close()
      Throws:
      IOException - in case of an error.
      Since:
      4.11
    • reset

      public void reset()
      Reset this buffer for reuse, purging all buffered content.
    • overflow

      protected abstract OutputStream overflow() throws IOException
      Open the overflow output stream, so the remaining output can be stored.
      Returns:
      the output stream to receive the buffered content, followed by the remaining output.
      Throws:
      IOException - the buffer cannot create the overflow stream.
    • last

      private TemporaryBuffer.Block last()
    • reachedInCoreLimit

      private boolean reachedInCoreLimit() throws IOException
      Throws:
      IOException
    • switchToOverflow

      private void switchToOverflow() throws IOException
      Throws:
      IOException
    • close

      public void close() throws IOException
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable
      Overrides:
      close in class OutputStream
      Throws:
      IOException
    • destroy

      public void destroy()
      Clear this buffer so it has no data, and cannot be used again.