/**
* Updates this {@code MessageDigestSpi} using the given {@code input}.
*
* @param input
* the {@code ByteBuffer}.
*/
protected internal virtual void engineUpdate(java.nio.ByteBuffer input)
{
if (!input.hasRemaining())
{
return;
}
byte[] tmp;
if (input.hasArray())
{
tmp = (byte[])input.array();
int offset = input.arrayOffset();
int position = input.position();
int limit = input.limit();
engineUpdate(tmp, offset + position, limit - position);
input.position(limit);
}
else
{
tmp = new byte[input.limit() - input.position()];
input.get(tmp);
engineUpdate(tmp, 0, tmp.Length);
}
}
/*
* Reads at most {@code length} characters from this reader and stores them
* at position {@code offset} in the character array {@code buf}. Returns
* the number of characters actually read or -1 if the end of the reader has
* been reached. The bytes are either obtained from converting bytes in this
* reader's buffer or by first filling the buffer from the source
* InputStream and then reading from the buffer.
*
* @param buf
* the array to store the characters read.
* @param offset
* the initial position in {@code buf} to store the characters
* read from this reader.
* @param length
* the maximum number of characters to read.
* @return the number of characters read or -1 if the end of the reader has
* been reached.
* @throws IndexOutOfBoundsException
* if {@code offset < 0} or {@code length < 0}, or if
* {@code offset + length} is greater than the length of
* {@code buf}.
* @throws IOException
* if this reader is closed or some other I/O error occurs.
*/
public override int read(char[] buf, int offset, int length)
{// throws IOException {
lock (lockJ)
{
if (!isOpen())
{
// luni.BA=InputStreamReader is closed.
throw new IOException("InputStreamReader is closed."); //$NON-NLS-1$
}
if (offset < 0 || offset > buf.Length - length || length < 0)
{
throw new java.lang.IndexOutOfBoundsException();
}
if (length == 0)
{
return(0);
}
java.nio.CharBuffer outJ = java.nio.CharBuffer.wrap(buf, offset, length);
java.nio.charset.CoderResult result = java.nio.charset.CoderResult.UNDERFLOW;
// bytes.remaining() indicates number of bytes in buffer
// when 1-st time entered, it'll be equal to zero
bool needInput = !bytes.hasRemaining();
while (outJ.hasRemaining())
{
// fill the buffer if needed
if (needInput)
{
try
{
if ((inJ.available() == 0) &&
(outJ.position() > offset))
{
// we could return the result without blocking read
break;
}
}
catch (IOException e)
{
// available didn't work so just try the read
}
int to_read = bytes.capacity() - bytes.limit();
int off = bytes.arrayOffset() + bytes.limit();
int was_red = inJ.read((byte[])bytes.array(), off, to_read);
if (was_red == -1)
{
endOfInput = true;
break;
}
else if (was_red == 0)
{
break;
}
bytes.limit(bytes.limit() + was_red);
needInput = false;
}
// decode bytes
result = decoder.decode(bytes, outJ, false);
if (result.isUnderflow())
{
// compact the buffer if no space left
if (bytes.limit() == bytes.capacity())
{
bytes.compact();
bytes.limit(bytes.position());
bytes.position(0);
}
needInput = true;
}
else
{
break;
}
}
if (result == java.nio.charset.CoderResult.UNDERFLOW && endOfInput)
{
result = decoder.decode(bytes, outJ, true);
decoder.flush(outJ);
decoder.reset();
}
if (result.isMalformed())
{
throw new java.nio.charset.MalformedInputException(result.length());
}
else if (result.isUnmappable())
{
throw new java.nio.charset.UnmappableCharacterException(result.length());
}
return(outJ.position() - offset == 0 ? -1 : outJ.position() - offset);
}
}
