/*
Derby - Class org.apache.derby.impl.jdbc.LOBInputStream
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*/
package org.apache.derby.impl.jdbc;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import org.apache.derby.iapi.error.StandardException;
import org.apache.derby.iapi.reference.MessageId;
import org.apache.derby.iapi.reference.SQLState;
import org.apache.derby.iapi.services.i18n.MessageService;
import org.apache.derby.shared.common.sanity.SanityManager;
import org.apache.derby.iapi.types.PositionedStream;
import org.apache.derby.iapi.error.ExceptionUtil;
/**
* This input stream is built on top of {@link LOBStreamControl}.
*
* All the read methods are routed to {@link LOBStreamControl}.
*/
public class LOBInputStream
extends InputStream
implements PositionedStream {
private boolean closed;
private final LOBStreamControl control;
private long pos;
private long updateCount;
LOBInputStream(LOBStreamControl control, long position) {
closed = false;
this.control = control;
pos = position;
updateCount = control.getUpdateCount ();
}
/**
* Reads up to len bytes of data from the input stream into
* an array of bytes. An attempt is made to read as many as
* len bytes, but a smaller number may be read.
* The number of bytes actually read is returned as an integer.
*
*
This method blocks until input data is available, end of file is
* detected, or an exception is thrown.
*
*
If b is null, a
* NullPointerException is thrown.
*
*
If off is negative, or len is negative, or
* off+len is greater than the length of the array
* b, then an IndexOutOfBoundsException is
* thrown.
*
*
If len is zero, then no bytes are read and
* 0 is returned; otherwise, there is an attempt to read at
* least one byte. If no byte is available because the stream is at end of
* file, the value -1 is returned; otherwise, at least one
* byte is read and stored into b.
*
*
The first byte read is stored into element b[off], the
* next one into b[off+1], and so on. The number of bytes read
* is, at most, equal to len. Let k be the number of
* bytes actually read; these bytes will be stored in elements
* b[off] through b[off+k-1],
* leaving elements b[off+k] through
* b[off+len-1] unaffected.
*
*
In every case, elements b[0] through
* b[off] and elements b[off+len] through
* b[b.length-1] are unaffected.
*
*
If the first byte cannot be read for any reason other than end of
* file, then an IOException is thrown. In particular, an
* IOException is thrown if the input stream has been closed.
*
*
The read(b, off, len) method
* for class InputStream simply calls the method
* read() repeatedly. If the first such call results in an
* IOException, that exception is returned from the call to
* the read(b, off, len) method. If
* any subsequent call to read() results in a
* IOException, the exception is caught and treated as if it
* were end of file; the bytes read up to that point are stored into
* b and the number of bytes read before the exception
* occurred is returned. Subclasses are encouraged to provide a more
* efficient implementation of this method.
*
* @param b the buffer into which the data is read.
* @param off the start offset in array b
* at which the data is written.
* @param len the maximum number of bytes to read.
* @return the total number of bytes read into the buffer, or
* -1 if there is no more data because the end of
* the stream has been reached.
* @exception IOException if an I/O error occurs.
* @exception NullPointerException if b is null.
* @see java.io.InputStream#read()
*/
public int read(byte[] b, int off, int len) throws IOException {
if (closed)
throw new IOException (
MessageService.getTextMessage(MessageId.OBJECT_CLOSED));
try {
int ret = control.read(b, off, len, pos);
if (ret != -1) {
pos += ret;
return ret;
}
return -1;
} catch (StandardException se) {
String state = se.getSQLState();
if (state.equals(ExceptionUtil.getSQLStateFromIdentifier(
SQLState.BLOB_POSITION_TOO_LARGE))) {
return -1;
} else if (state.equals(ExceptionUtil.getSQLStateFromIdentifier(
SQLState.BLOB_INVALID_OFFSET))) {
throw new ArrayIndexOutOfBoundsException(se.getMessage());
} else {
throw Util.newIOException(se);
}
}
}
/**
* Closes this input stream and releases any system resources associated
* with the stream.
*
*
The close method of InputStream does
* nothing.
*
* @exception IOException if an I/O error occurs.
*/
public void close() throws IOException {
closed = true;
}
/**
* Reads the next byte of data from the input stream. The value byte is
* returned as an int in the range 0 to
* 255. If no byte is available because the end of the stream
* has been reached, the value -1 is returned. This method
* blocks until input data is available, the end of the stream is detected,
* or an exception is thrown.
*
*
A subclass must provide an implementation of this method.
*
* @return the next byte of data, or -1 if the end of the
* stream is reached.
* @exception IOException if an I/O error occurs.
*/
public int read() throws IOException {
if (closed)
throw new IOException (
MessageService.getTextMessage(MessageId.OBJECT_CLOSED));
try {
int ret = control.read(pos);
if (ret != -1)
pos += 1;
return ret;
} catch (StandardException se) {
throw Util.newIOException(se);
}
}
/**
* Checks if underlying StreamControl has been updated.
* @return if stream is modified since created
*/
boolean isObsolete () {
return updateCount != control.getUpdateCount();
}
/**
* Reinitializes the stream and sets the current pointer to zero.
*/
void reInitialize () {
updateCount = control.getUpdateCount();
pos = 0;
}
/**
* Returns size of stream in bytes.
* @return size of stream.
*/
long length () throws IOException {
return control.getLength();
}
// Implementation of the PositionedStream interface:
// - asInputStream
// - getPosition
// - reposition
public InputStream asInputStream() {
return this;
}
/**
* Returns the current byte position.
*
* @return The current byte position.
*/
public long getPosition() {
return pos;
}
/**
* Repositions the stream to the requested byte position.
*
* @param requestedPos the requested position, starting at {@code 0}
* @throws EOFException if the requested position is larger than the length
* @throws IOException if obtaining the stream length fails
*/
public void reposition(long requestedPos)
throws IOException{
if (SanityManager.DEBUG) {
if (requestedPos < 0) {
SanityManager.THROWASSERT("Negative position: " + requestedPos);
}
}
if (requestedPos > length()) {
pos = 0;
throw new EOFException();
}
pos = requestedPos;
}
}
Ads help maintain this website.