org.apache.axiom.util.blob
Interface WritableBlob

All Superinterfaces:
Blob
All Known Implementing Classes:
MemoryBlob, OverflowBlob

public interface WritableBlob
extends Blob

A writable blob.

The behavior of the methods defined by this interface is described in terms of three logical states the blob can be in:

NEW
The blob has just been created and no data has been written to it yet.
UNCOMMITTED
Data is being written to the blob.
COMMITTED
All data has been written to the blob and the blob will no longer accept any new data.
Whether or not reading data from the blob if is in state NEW or UNCOMMITTED depends on the return value of isSupportingReadUncommitted().

Blobs are not thread safe.


Method Summary
 BlobOutputStream getOutputStream()
          Create an output stream to write data to the blob.
 boolean isSupportingReadUncommitted()
          Determine whether the blob supports reading in state NEW or UNCOMMITTED.
 long readFrom(InputStream in, long length)
          Read data from the given input stream and write it to the blob.
 long readFrom(InputStream in, long length, boolean commit)
          Read data from the given input stream and write it to the blob.
 void release()
          Release all resources held by this blob.
 
Methods inherited from interface org.apache.axiom.util.blob.Blob
getInputStream, getLength, writeTo
 

Method Detail

isSupportingReadUncommitted

boolean isSupportingReadUncommitted()
Determine whether the blob supports reading in state NEW or UNCOMMITTED. If this method returns false and the blob is in state NEW or UNCOMMITTED, any call to a method defined by the Blob superinterface will result in an IllegalStateException. If this method returns true, then any data written to the blob will be immediately available for reading. This is also true for an input stream obtained from Blob.getInputStream() before the data is written. This implies that it is possible for the input stream to first report the end of the stream and later allow reading additional data. Therefore, a pair of streams obtained from getOutputStream() and Blob.getInputStream() behaves differently than a PipedOutputStream and PipedInputStream pair, because in this situation PipedInputStream would block.

Returns:
true if the blob allows reading the data in state NEW or UNCOMMITTED; false if the blob allows read operations only in state COMMITTED

getOutputStream

BlobOutputStream getOutputStream()
Create an output stream to write data to the blob.

Precondition: The blob is in state NEW.

Postcondition: The blob is in state UNCOMMITTED.

Note that the pre- and postconditions imply that this method may be called at most once for a given blob instance.

Calls to methods of the returned output stream will modify the state of the blob according to the following rules:

Returns:
an output stream that can be used to write data to the blob
Throws:
IllegalStateException - if the blob is not in state NEW

readFrom

long readFrom(InputStream in,
              long length,
              boolean commit)
              throws StreamCopyException
Read data from the given input stream and write it to the blob.

A call to this method has the same effect as requesting an output stream using getOutputStream() and copying the data from the input stream to that output stream, but the implementation will achieve this result in a more efficient way.

Precondition: The blob is in state NEW or UNCOMMITTED.

Postcondition: The blob is in state UNCOMMITTED if commit is false. It is in state COMMITTED if commit is true.

The precondition implies that this method may be used after a call to getOutputStream(). In that case it is illegal to set commit to true (because this would invalidate the state of the output stream).

The method transfers data from the input stream to the blob until one of the following conditions is met:

Parameters:
in - An input stream to read data from. This method will not close the stream.
length - the number of bytes to transfer, or -1 if the method should transfer data until the end of the input stream is reached
commit - indicates whether the blob should be in state COMMITTED after the operation
Returns:
the number of bytes transferred
Throws:
StreamCopyException
IllegalStateException - if the blob is in state COMMITTED or if getOutputStream() has been called before and commit is true

readFrom

long readFrom(InputStream in,
              long length)
              throws StreamCopyException
Read data from the given input stream and write it to the blob.

This method is similar to readFrom(InputStream, long, boolean), except that the state of the blob after the invocation (i.e. the commit argument) is determined automatically:

Precondition (state)Postcondition (state)
NEWCOMMITTED
UNCOMMITTEDUNCOMMITTED
COMMITTEDillegal

There are thus two usage patterns for this method:

  1. The method is used to fill the blob with the data from an input stream, but no other data is written to the blob.
  2. The method is used in parallel with the output stream returned by getOutputStream(): some data is written using the output stream and some data is written using this method (for efficiency reasons).

Parameters:
in - An input stream to read data from. This method will not close the stream.
length - the number of bytes to transfer, or -1 if the method should transfer data until the end of the input stream is reached
Returns:
the number of bytes transferred
Throws:
StreamCopyException
IllegalStateException - if the blob is in state COMMITTED

release

void release()
Release all resources held by this blob.



Copyright © 2004-2012 The Apache Software Foundation. All Rights Reserved.