/*
* Microsoft JDBC Driver for SQL Server
*
* Copyright(c) Microsoft Corporation All rights reserved.
*
* This program is made available under the terms of the MIT License. See the LICENSE file in the project root for more information.
*/
package com.microsoft.sqlserver.jdbc;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.text.MessageFormat;
/**
* InputStream adapter for Readers.
*
* This class implements an InputStream whose bytes are encoded character values that are read on demand from a wrapped Reader using the suplied
* Charset.
*
* Character values pass through through the following in their transformation to bytes: Reader .. CharBuffer .. Charset (CharsetEncoder) ..
* ByteBuffer .. InputStream
*
* To minimize memory usage, the CharBuffer and ByteBuffer instances used by this class are created on demand when InputStream read methods are
* called.
*/
class ReaderInputStream extends InputStream {
// The Reader that this ReaderInputStream adapts.
private final Reader reader;
// The character set used to encode character values as
// they are read from the stream.
private final Charset charset;
// Length of the Reader, if known, in characters
private final long readerLength;
// Count of characters read from the reader across all calls to encodeChars()
private long readerCharsRead = 0;
// Flag indicating whether the stream has reached the end of its data
private boolean atEndOfStream = false;
// Internal character buffer used to transfer character values
// between the Reader and the Charset encoder.
private CharBuffer rawChars = null;
private static final int MAX_CHAR_BUFFER_SIZE = DataTypes.SHORT_VARTYPE_MAX_CHARS;
// Most recent set of bytes that were encoded from rawChars.
// This value is null initially and when the end of stream is reached.
private static final ByteBuffer EMPTY_BUFFER = ByteBuffer.allocate(0);
private ByteBuffer encodedChars = EMPTY_BUFFER;
ReaderInputStream(Reader reader,
Charset charset,
long readerLength) {
assert reader != null;
assert charset != null;
assert DataTypes.UNKNOWN_STREAM_LENGTH == readerLength || readerLength >= 0;
this.reader = reader;
this.charset = charset;
this.readerLength = readerLength;
}
/**
* Returns the number of bytes that can be read (or skipped over) from this input stream without blocking by the next caller of a method for this
* input stream.
*
* @return - the number of bytes that can be read from this input stream without blocking
* @throws IOException
* - if an I/O error occurs
*/
public int available() throws IOException {
assert null != reader;
assert null != encodedChars;
// If we know the reader to be empty, then take the short cut
if (0 == readerLength)
return 0;
// If there are encoded characters remaining in the buffer then that's our best guess.
if (encodedChars.remaining() > 0)
return encodedChars.remaining();
// If there are no encoded characters left in the buffer (or the buffer hasn't yet been populated)
// then ask the Reader whether a call to its read() method would block. If reading wouldn't block,
// then there's at least 1 byte that can be encoded, possibly more.
if (reader.ready())
return 1;
// If there are no encoded characters, and reading characters from the underlying Reader object
// would block, then nothing (more) can be read from this stream without blocking.
return 0;
}
private final byte[] oneByte = new byte[1];
public int read() throws IOException {
return (-1 == readInternal(oneByte, 0, oneByte.length)) ? -1 : oneByte[0];
}
public int read(byte[] b) throws IOException {
return readInternal(b, 0, b.length);
}
public int read(byte[] b,
int off,
int len) throws IOException {
return readInternal(b, off, len);
}
private int readInternal(byte[] b,
int off,
int len) throws IOException {
assert null != b;
assert 0 <= off && off <= b.length;
assert 0 <= len && len <= b.length;
assert off <= b.length - len;
if (0 == len)
return 0;
int bytesRead = 0;
while (bytesRead < len && encodeChars()) {
// Read the lesser of the number of bytes remaining
// in the encoded character buffer and the number
// of bytes remaining for this read request.
int bytesToRead = encodedChars.remaining();
if (bytesToRead > len - bytesRead)
bytesToRead = len - bytesRead;
// We should actually be attempting to read something here,
// or we'll be in an infinite loop...
assert bytesToRead > 0;
encodedChars.get(b, off + bytesRead, bytesToRead);
bytesRead += bytesToRead;
}
// Return number of bytes read, which may be less than
// the number of bytes requested, or -1 at end of stream.
return (0 == bytesRead && atEndOfStream) ? -1 : bytesRead;
}
/**
* Determines whether encoded characters are available, encoding them on demand by reading them from the reader as necessary.
*
* @return true when encoded characters are available
* @return false when no more encoded characters are available (i.e. end of stream)
* @exception IOException
* if an I/O error occurs reading from the reader or encoding the characters
*/
private boolean encodeChars() throws IOException {
// Once at the end of the stream, no more characters can be encoded.
if (atEndOfStream)
return false;
// Not at end of stream; check whether there are any encoded characters
// remaining in the byte buffer. If there are, don't encode any more
// characters this time.
if (encodedChars.hasRemaining())
return true;
// Encoded byte buffer is either exhausted or has never been filled
// (i.e. first time through). In that case, we need to repopulate
// the encoded character buffer by encoding raw characters.
//
// To do that, there needs to be raw characters available to encode.
// If there are no raw characters available (because the raw character
// buffer has been exhausted or never filled), then try to read in
// raw characters from the reader.
if (null == rawChars || !rawChars.hasRemaining()) {
if (null == rawChars) {
assert MAX_CHAR_BUFFER_SIZE <= Integer.MAX_VALUE;
rawChars = CharBuffer.allocate((DataTypes.UNKNOWN_STREAM_LENGTH == readerLength || readerLength > MAX_CHAR_BUFFER_SIZE)
? MAX_CHAR_BUFFER_SIZE : Math.max((int) readerLength, 1));
}
else {
// Flip the buffer to be ready for put (reader read) operations.
rawChars.clear();
}
// Try to fill up the raw character buffer by reading available characters
// from the reader into it.
//
// This loop continues until one of the following conditions is satisfied:
// - the raw character buffer has been filled,
// - the reader reaches end-of-stream
// - the reader throws any kind of Exception (driver throws an IOException)
// - the reader violates its interface contract (driver throws an IOException)
while (rawChars.hasRemaining()) {
int lastPosition = rawChars.position();
int charsRead = 0;
// Try reading from the app-supplied Reader
try {
charsRead = reader.read(rawChars);
}
// Catch any kind of exception and translate it to an IOException.
// The app-supplied reader cannot be trusted just to throw IOExceptions...
catch (Exception e) {
String detailMessage = e.getMessage();
if (null == detailMessage)
detailMessage = SQLServerException.getErrString("R_streamReadReturnedInvalidValue");
IOException ioException = new IOException(detailMessage);
ioException.initCause(e);
throw ioException;
}
if (charsRead < -1 || 0 == charsRead)
throw new IOException(SQLServerException.getErrString("R_streamReadReturnedInvalidValue"));
if (-1 == charsRead) {
// If the reader violates its interface contract then throw an exception.
if (rawChars.position() != lastPosition)
throw new IOException(SQLServerException.getErrString("R_streamReadReturnedInvalidValue"));
// Check that the reader has returned exactly the amount of data we expect
if (DataTypes.UNKNOWN_STREAM_LENGTH != readerLength && 0 != readerLength - readerCharsRead) {
MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_mismatchedStreamLength"));
throw new IOException(form.format(new Object[] {readerLength, readerCharsRead}));
}
// If there are no characters left to encode then we're done.
if (0 == rawChars.position()) {
rawChars = null;
atEndOfStream = true;
return false;
}
// Otherwise, we've filled the buffer as much as we can.
break;
}
assert charsRead > 0;
// If the reader violates its interface contract then throw an exception.
if (charsRead != rawChars.position() - lastPosition)
throw new IOException(SQLServerException.getErrString("R_streamReadReturnedInvalidValue"));
// Check that the reader isn't trying to return more data than we expect
if (DataTypes.UNKNOWN_STREAM_LENGTH != readerLength && charsRead > readerLength - readerCharsRead) {
MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_mismatchedStreamLength"));
throw new IOException(form.format(new Object[] {readerLength, readerCharsRead}));
}
readerCharsRead += charsRead;
}
// The raw character buffer may now have characters available for encoding.
// Flip the buffer back to be ready for get (charset encode) operations.
rawChars.flip();
}
// If the raw character buffer remains empty, despite our efforts to (re)populate it,
// then no characters can be encoded at this time. This can happen if the reader reports
// that no characters were ready to be read.
if (!rawChars.hasRemaining())
return false;
// Raw characters are now available to be encoded, so encode them.
encodedChars = charset.encode(rawChars);
return true;
}
}