/// <summary>This is a facade method for the decoding operation.</summary> /// <remarks> /// This is a facade method for the decoding operation. /// <p> /// This method decodes the remaining byte sequence of the given byte buffer /// into a new character buffer. This method performs a complete decoding /// operation, resets at first, then decodes, and flushes at last. /// <p> /// This method should not be invoked while another /// <code>decode</code> /// operation /// is ongoing. /// </remarks> /// <param name="in">the input buffer.</param> /// <returns> /// a new <code>CharBuffer</code> containing the the characters /// produced by this decoding operation. The buffer's limit will be /// the position of the last character in the buffer, and the /// position will be zero. /// </returns> /// <exception cref="System.InvalidOperationException">if another decoding operation is ongoing. /// </exception> /// <exception cref="MalformedInputException"> /// if an illegal input byte sequence for this charset was /// 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 byte sequence for this /// charset was encountered, and the action for unmappable /// character error is /// <see cref="CodingErrorAction.REPORT">CodingErrorAction.REPORT</see> /// . /// Unmappable means the byte sequence at the input buffer's /// current position cannot be mapped to a Unicode character /// sequence. /// </exception> /// <exception cref="CharacterCodingException">if another exception happened during the decode operation. /// </exception> /// <exception cref="java.nio.charset.CharacterCodingException"></exception> public java.nio.CharBuffer decode(java.nio.ByteBuffer @in) { reset(); int length = (int)(@in.remaining() * _averageCharsPerByte); java.nio.CharBuffer output = java.nio.CharBuffer.allocate(length); java.nio.charset.CoderResult result = null; while (true) { result = decode(@in, output, false); checkCoderResult(result); if (result.isUnderflow()) { break; } else { if (result.isOverflow()) { output = allocateMore(output); } } } result = decode(@in, output, true); checkCoderResult(result); while (true) { result = flush(output); checkCoderResult(result); if (result.isOverflow()) { output = allocateMore(output); } else { break; } } output.flip(); status = FLUSH; return(output); }
/// <exception cref="System.IO.IOException"></exception> private void drainEncoder() { // Strictly speaking, I think it's part of the CharsetEncoder contract that you call // encode with endOfInput true before flushing. Our ICU-based implementations don't // actually need this, and you'd hope that any reasonable implementation wouldn't either. // CharsetEncoder.encode doesn't actually pass the boolean through to encodeLoop anyway! java.nio.CharBuffer chars = java.nio.CharBuffer.allocate(0); while (true) { java.nio.charset.CoderResult result = encoder.encode(chars, bytes, true); if (result.isError()) { result.throwException(); } else { if (result.isOverflow()) { flushBytes(false); continue; } } break; } // Some encoders (such as ISO-2022-JP) have stuff to write out after all the // characters (such as shifting back into a default state). In our implementation, // this is actually the first time ICU is told that we've run out of input. java.nio.charset.CoderResult result_1 = encoder.flush(bytes); while (!result_1.isUnderflow()) { if (result_1.isOverflow()) { flushBytes(false); result_1 = encoder.flush(bytes); } else { result_1.throwException(); } } }
/// <exception cref="System.IO.IOException"></exception> private void convert(java.nio.CharBuffer chars) { while (true) { java.nio.charset.CoderResult result = encoder.encode(chars, bytes, false); if (result.isOverflow()) { // Make room and try again. flushBytes(false); continue; } else { if (result.isError()) { result.throwException(); } } break; } }
public virtual void flush() { //Log.i("PackageManager", "flush mPos=" + mPos); if (mPos > 0) { if (mOutputStream != null) { java.nio.CharBuffer charBuffer = java.nio.CharBuffer.wrap(mText, 0, mPos); java.nio.charset.CoderResult result = mCharset.encode(charBuffer, mBytes, true); while (true) { if (result.isError()) { throw new System.IO.IOException(result.ToString()); } else { if (result.isOverflow()) { flushBytes(); result = mCharset.encode(charBuffer, mBytes, true); continue; } } break; } flushBytes(); mOutputStream.flush(); } else { mWriter.write(mText, 0, mPos); mWriter.flush(); } mPos = 0; } }
/// <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()); } }