/// <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); } }
/// <summary> /// Decodes bytes starting at the current position of the given input buffer, /// and writes the equivalent character sequence into the given output buffer /// from its current position. /// </summary> /// <remarks> /// Decodes bytes starting at the current position of the given input buffer, /// and writes the equivalent character sequence into the given output buffer /// from its current position. /// <p> /// The buffers' position will be changed with the reading and writing /// operation, but their limits and marks will be kept intact. /// <p> /// A <code>CoderResult</code> instance will be returned according to /// following rules: /// <ul> /// <li> /// <see cref="CoderResult.OVERFLOW">CoderResult.OVERFLOW</see> /// indicates that /// even though not all of the input has been processed, the buffer the /// output is being written to has reached its capacity. In the event of this /// code being returned this method should be called once more with an /// <code>out</code> argument that has not already been filled.</li> /// <li> /// <see cref="CoderResult.UNDERFLOW">CoderResult.UNDERFLOW</see> /// indicates that /// as many bytes as possible in the input buffer have been decoded. If there /// is no further input and no remaining bytes in the input buffer then this /// operation may be regarded as complete. Otherwise, this method should be /// called once more with additional input.</li> /// <li>A /// <see cref="CoderResult.malformedForLength(int)">malformed input</see> /// result /// indicates that some malformed input error has been encountered, and the /// erroneous bytes start at the input buffer's position and their number can /// be got by result's /// <see cref="CoderResult.length()">length</see> /// . This kind of /// result can be returned only if the malformed action is /// <see cref="CodingErrorAction.REPORT">CodingErrorAction.REPORT</see> /// . </li> /// <li>A /// <see cref="CoderResult.unmappableForLength(int)">unmappable character</see> /// result indicates that some unmappable character error has been /// encountered, and the erroneous bytes start at the input buffer's position /// and their number can be got by result's /// <see cref="CoderResult.length()">length</see> /// . This kind of result can be returned /// only if the unmappable character action is /// <see cref="CodingErrorAction.REPORT">CodingErrorAction.REPORT</see> /// . </li> /// </ul> /// <p> /// The <code>endOfInput</code> parameter indicates that the invoker cannot /// provide further input. This parameter is true if and only if the bytes in /// current input buffer are all inputs for this decoding operation. Note /// that it is common and won't cause an error if the invoker sets false and /// then can't provide more input, while it may cause an error if the invoker /// always sets true in several consecutive invocations. This would make the /// remaining input to be treated as malformed input. /// <p> /// This method invokes the /// <see cref="decodeLoop(java.nio.ByteBuffer, java.nio.CharBuffer)">decodeLoop</see> /// method to /// implement the basic decode logic for a specific charset. /// </remarks> /// <param name="in">the input buffer.</param> /// <param name="out">the output buffer.</param> /// <param name="endOfInput">true if all the input characters have been provided.</param> /// <returns> /// a <code>CoderResult</code> instance which indicates the reason /// of termination. /// </returns> /// <exception cref="System.InvalidOperationException"> /// if decoding has started or no more input is needed in this /// decoding progress. /// </exception> /// <exception cref="CoderMalfunctionError"> /// if the /// <see cref="decodeLoop(java.nio.ByteBuffer, java.nio.CharBuffer)">decodeLoop</see> /// method threw an <code>BufferUnderflowException</code> or /// <code>BufferOverflowException</code>. /// </exception> public java.nio.charset.CoderResult decode(java.nio.ByteBuffer @in, java.nio.CharBuffer @out, bool endOfInput) { if ((status == FLUSH) || (!endOfInput && status == END)) { throw new System.InvalidOperationException(); } java.nio.charset.CoderResult result = null; // begin to decode while (true) { java.nio.charset.CodingErrorAction action = null; try { result = decodeLoop(@in, @out); } catch (java.nio.BufferOverflowException ex) { // unexpected exception throw new java.nio.charset.CoderMalfunctionError(ex); } catch (java.nio.BufferUnderflowException ex) { // unexpected exception throw new java.nio.charset.CoderMalfunctionError(ex); } if (result.isUnderflow()) { int remaining = @in.remaining(); status = endOfInput ? END : ONGOING; if (endOfInput && remaining > 0) { result = java.nio.charset.CoderResult.malformedForLength(remaining); } else { return(result); } } if (result.isOverflow()) { return(result); } // set coding error handle action action = _malformedInputAction; if (result.isUnmappable()) { action = _unmappableCharacterAction; } // If the action is IGNORE or REPLACE, we should continue decoding. if (action == java.nio.charset.CodingErrorAction.REPLACE) { if (@out.remaining() < replacementChars.Length) { return(java.nio.charset.CoderResult.OVERFLOW); } @out.put(replacementChars); } else { if (action != java.nio.charset.CodingErrorAction.IGNORE) { return(result); } } @in.position(@in.position() + result.length()); } }