/// <exception cref="java.nio.charset.CharacterCodingException"></exception>
private void checkCoderResult(java.nio.charset.CoderResult result)
{
if (result.isMalformed() && _malformedInputAction == java.nio.charset.CodingErrorAction
.REPORT)
{
throw new java.nio.charset.MalformedInputException(result.length());
}
else
{
if (result.isUnmappable() && _unmappableCharacterAction == java.nio.charset.CodingErrorAction
.REPORT)
{
throw new java.nio.charset.UnmappableCharacterException(result.length());
}
}
}
/// <summary>This is a facade method for the encoding operation.</summary>
/// <remarks>
/// This is a facade method for the encoding operation.
/// <p>
/// This method encodes the remaining character sequence of the given
/// character buffer into a new byte buffer. This method performs a complete
/// encoding operation, resets at first, then encodes, and flushes at last.
/// <p>
/// This method should not be invoked if another encode operation is ongoing.
/// </remarks>
/// <param name="in">the input buffer.</param>
/// <returns>
/// a new <code>ByteBuffer</code> containing the bytes produced by
/// this encoding operation. The buffer's limit will be the position
/// of the last byte in the buffer, and the position will be zero.
/// </returns>
/// <exception cref="System.InvalidOperationException">if another encoding operation is ongoing.
/// </exception>
/// <exception cref="MalformedInputException">
/// if an illegal input character sequence for this charset is
/// encountered, and the action for malformed error is
/// <see cref="CodingErrorAction.REPORT">CodingErrorAction.REPORT</see>
/// </exception>
/// <exception cref="UnmappableCharacterException">
/// if a legal but unmappable input character sequence for this
/// charset is encountered, and the action for unmappable
/// character error is
/// <see cref="CodingErrorAction.REPORT">CodingErrorAction.REPORT</see>
/// .
/// Unmappable means the Unicode character sequence at the input
/// buffer's current position cannot be mapped to a equivalent
/// byte sequence.
/// </exception>
/// <exception cref="CharacterCodingException">if other exception happened during the encode operation.
/// </exception>
/// <exception cref="java.nio.charset.CharacterCodingException"></exception>
public java.nio.ByteBuffer encode(java.nio.CharBuffer @in)
{
if (@in.remaining() == 0)
{
return(java.nio.ByteBuffer.allocate(0));
}
reset();
int length = (int)(@in.remaining() * _averageBytesPerChar);
java.nio.ByteBuffer output = java.nio.ByteBuffer.allocate(length);
java.nio.charset.CoderResult result = null;
while (true)
{
result = encode(@in, output, false);
if (result == java.nio.charset.CoderResult.UNDERFLOW)
{
break;
}
else
{
if (result == java.nio.charset.CoderResult.OVERFLOW)
{
output = allocateMore(output);
continue;
}
}
checkCoderResult(result);
}
result = encode(@in, output, true);
checkCoderResult(result);
while (true)
{
result = flush(output);
if (result == java.nio.charset.CoderResult.UNDERFLOW)
{
output.flip();
break;
}
else
{
if (result == java.nio.charset.CoderResult.OVERFLOW)
{
output = allocateMore(output);
continue;
}
}
checkCoderResult(result);
output.flip();
if (result.isMalformed())
{
throw new java.nio.charset.MalformedInputException(result.length());
}
else
{
if (result.isUnmappable())
{
throw new java.nio.charset.UnmappableCharacterException(result.length());
}
}
break;
}
status = READY;
finished = true;
return(output);
}
public override int read(char[] buffer, int offset, int length)
{
lock (@lock)
{
if (!isOpen())
{
throw new System.IO.IOException("InputStreamReader is closed");
}
java.util.Arrays.checkOffsetAndCount(buffer.Length, offset, length);
if (length == 0)
{
return(0);
}
java.nio.CharBuffer @out = java.nio.CharBuffer.wrap(buffer, 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 (@out.hasRemaining())
{
// fill the buffer if needed
if (needInput)
{
try
{
if (@in.available() == 0 && @out.position() > offset)
{
// we could return the result without blocking read
break;
}
}
catch (System.IO.IOException)
{
}
// available didn't work so just try the read
int desiredByteCount = bytes.capacity() - bytes.limit();
int off = bytes.arrayOffset() + bytes.limit();
int actualByteCount = @in.read(((byte[])bytes.array()), off, desiredByteCount);
if (actualByteCount == -1)
{
endOfInput = true;
break;
}
else
{
if (actualByteCount == 0)
{
break;
}
}
bytes.limit(bytes.limit() + actualByteCount);
needInput = false;
}
// decode bytes
result = decoder.decode(bytes, @out, 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, @out, true);
decoder.flush(@out);
decoder.reset();
}
if (result.isMalformed() || result.isUnmappable())
{
result.throwException();
}
return(@out.position() - offset == 0 ? -1 : @out.position() - offset);
}
}