Java CoderResult.throwException方法代码示例

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
private void doWriteText(CharBuffer buffer, boolean finalFragment)
        throws IOException {
    CharsetEncoder encoder = B2CConverter.UTF_8.newEncoder();
    do {
        CoderResult cr = encoder.encode(buffer, bb, true);
        if (cr.isError()) {
            cr.throwException();
        }
        bb.flip();
        if (buffer.hasRemaining()) {
            doWriteBytes(bb, false);
        } else {
            doWriteBytes(bb, finalFragment);
        }
    } while (buffer.hasRemaining());

    // Reset - bb will be cleared in doWriteBytes()
    cb.clear();
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
public static void decode(CharsetDecoder charsetDecoder, ByteBuffer byteBuf, CharBuffer charByte) {
    try {
        CoderResult cr = charsetDecoder.decode(byteBuf, charByte, true);

        if (!cr.isUnderflow()) {
            cr.throwException();
        }

        cr = charsetDecoder.flush(charByte);

        if (!cr.isUnderflow()) {
            cr.throwException();
        }
    } catch (CharacterCodingException x) {
        // Substitution is always enabled,
        // so this shouldn't happen
        throw new JSONException(x.getMessage(), x);
    }
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
public byte[] encode(char[] chars, int off, int len, byte[] bytes) {
    ByteBuffer byteBuf = ByteBuffer.wrap(bytes);
    try {
        CoderResult cr = this.encoder.encode(CharBuffer.wrap(chars, off, len), byteBuf, true);
        if (!cr.isUnderflow()) {
            cr.throwException();
        }
        cr = this.encoder.flush(byteBuf);
        if (!cr.isUnderflow()) {
            cr.throwException();
        }
        int bytesLength = byteBuf.position();
        byte[] copy = new byte[bytesLength];
        System.arraycopy(bytes, 0, copy, 0, bytesLength);
        return copy;
    } catch (CharacterCodingException x) {
        throw new JSONException(x.getMessage(), x);
    }
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
private void doWriteText(CharBuffer buffer, boolean finalFragment) throws IOException {
	CharsetEncoder encoder = B2CConverter.UTF_8.newEncoder();
	do {
		CoderResult cr = encoder.encode(buffer, bb, true);
		if (cr.isError()) {
			cr.throwException();
		}
		bb.flip();
		if (buffer.hasRemaining()) {
			doWriteBytes(bb, false);
		} else {
			doWriteBytes(bb, finalFragment);
		}
	} while (buffer.hasRemaining());

	// Reset - bb will be cleared in doWriteBytes()
	cb.clear();
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
@Benchmark
public byte[] byCharsetEncoder_US_ASCII() {
    try {
        CharsetEncoder encoder = asciiencode.get();
        CharBuffer buffer  = charbuffergenerator.get();
        buffer.clear();
        buffer.append(STR);
        buffer.flip();

        ByteBuffer outbuffer = bytebuffergenerator.get();
        outbuffer.clear();

        CoderResult result = encoder.encode(buffer, outbuffer, false);
        if (result.isError()) {
            result.throwException();
        }
        byte[] b = new byte[STR.length()];
        outbuffer.flip();
        outbuffer.get(b);
        return b;
    } catch (CharacterCodingException e) {
        throw new RuntimeException(e);
    }
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
static byte[] encode(Charset cs, char[] ca, int off, int len) {
    CharsetEncoder ce = cs.newEncoder();
    int en = scale(len, ce.maxBytesPerChar());
    byte[] ba = new byte[en];
    if (len == 0)
        return ba;
    boolean isTrusted = false;
    if (System.getSecurityManager() != null) {
        if (!(isTrusted = (cs.getClass().getClassLoader0() == null))) {
            ca =  Arrays.copyOfRange(ca, off, off + len);
            off = 0;
        }
    }
    ce.onMalformedInput(CodingErrorAction.REPLACE)
      .onUnmappableCharacter(CodingErrorAction.REPLACE)
      .reset();
    if (ce instanceof ArrayEncoder) {
        int blen = ((ArrayEncoder)ce).encode(ca, off, len, ba);
        return safeTrim(ba, blen, cs, isTrusted);
    } else {
        ByteBuffer bb = ByteBuffer.wrap(ba);
        CharBuffer cb = CharBuffer.wrap(ca, off, len);
        try {
            CoderResult cr = ce.encode(cb, bb, true);
            if (!cr.isUnderflow())
                cr.throwException();
            cr = ce.flush(bb);
            if (!cr.isUnderflow())
                cr.throwException();
        } catch (CharacterCodingException x) {
            throw new Error(x);
        }
        return safeTrim(ba, bb.position(), cs, isTrusted);
    }
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
private int handleDecodingResult(
        final CoderResult result,
        final ru.radiomayak.http.util.CharArrayBuffer charbuffer,
        final ByteBuffer bbuf) throws IOException {
    if (result.isError()) {
        result.throwException();
    }
    this.cbuf.flip();
    final int len = this.cbuf.remaining();
    while (this.cbuf.hasRemaining()) {
        charbuffer.append(this.cbuf.get());
    }
    this.cbuf.compact();
    return len;
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
/**
 * Convert the given characters to bytes. 
 * 
 * @param cc char input
 * @param bc byte output
 */
public void convert(CharChunk cc, ByteChunk bc) 
throws IOException {
    if ((bb == null) || (bb.array() != bc.getBuffer())) {
        // Create a new byte buffer if anything changed
        bb = ByteBuffer.wrap(bc.getBuffer(), bc.getEnd(), 
                bc.getBuffer().length - bc.getEnd());
    } else {
        // Initialize the byte buffer
        bb.position(bc.getEnd());
        bb.limit(bc.getBuffer().length);
    }
    if ((cb == null) || (cb.array() != cc.getBuffer())) {
        // Create a new char buffer if anything changed
        cb = CharBuffer.wrap(cc.getBuffer(), cc.getStart(), 
                cc.getLength());
    } else {
        // Initialize the char buffer
        cb.position(cc.getStart());
        cb.limit(cc.getEnd());
    }
    // Do the decoding and get the results into the byte chunk and the char chunk
    CoderResult result = encoder.encode(cb, bb, false);
    if (result.isError() || result.isMalformed()) {
        result.throwException();
    } else if (result.isOverflow()) {
        // Propagate current positions to the byte chunk and char chunk
        bc.setEnd(bb.position());
        cc.setOffset(cb.position());
    } else if (result.isUnderflow()) {
        // Propagate current positions to the byte chunk and char chunk
        bc.setEnd(bb.position());
        cc.setOffset(cb.position());
    }
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
public static void decode(CharsetDecoder charsetDecoder, ByteBuffer byteBuf, CharBuffer charByte) {
    try {
        CoderResult cr = charsetDecoder.decode(byteBuf, charByte, true);
        if (!cr.isUnderflow()) {
            cr.throwException();
        }
        cr = charsetDecoder.flush(charByte);
        if (!cr.isUnderflow()) {
            cr.throwException();
        }
    } catch (CharacterCodingException x) {
        throw new JSONException(x.getMessage(), x);
    }
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
private int handleDecodingResult(
        final CoderResult result,
        final CharArrayBuffer charbuffer,
        final ByteBuffer bbuf) throws IOException {
    if (result.isError()) {
        result.throwException();
    }
    this.cbuf.flip();
    final int len = this.cbuf.remaining();
    while (this.cbuf.hasRemaining()) {
        charbuffer.append(this.cbuf.get());
    }
    this.cbuf.compact();
    return len;
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
static char[] decode(Charset cs, byte[] ba, int off, int len) {
    // (1)We never cache the "external" cs, the only benefit of creating
    // an additional StringDe/Encoder object to wrap it is to share the
    // de/encode() method. These SD/E objects are short-lifed, the young-gen
    // gc should be able to take care of them well. But the best approash
    // is still not to generate them if not really necessary.
    // (2)The defensive copy of the input byte/char[] has a big performance
    // impact, as well as the outgoing result byte/char[]. Need to do the
    // optimization check of (sm==null && classLoader0==null) for both.
    // (3)getClass().getClassLoader0() is expensive
    // (4)There might be a timing gap in isTrusted setting. getClassLoader0()
    // is only chcked (and then isTrusted gets set) when (SM==null). It is
    // possible that the SM==null for now but then SM is NOT null later
    // when safeTrim() is invoked...the "safe" way to do is to redundant
    // check (... && (isTrusted || SM == null || getClassLoader0())) in trim
    // but it then can be argued that the SM is null when the opertaion
    // is started...
    CharsetDecoder cd = cs.newDecoder();
    int en = scale(len, cd.maxCharsPerByte());
    char[] ca = new char[en];
    if (len == 0)
        return ca;
    boolean isTrusted = false;
    if (System.getSecurityManager() != null) {
        if (!(isTrusted = (cs.getClass().getClassLoader0() == null))) {
            ba =  Arrays.copyOfRange(ba, off, off + len);
            off = 0;
        }
    }
    cd.onMalformedInput(CodingErrorAction.REPLACE)
      .onUnmappableCharacter(CodingErrorAction.REPLACE)
      .reset();
    if (cd instanceof ArrayDecoder) {
        int clen = ((ArrayDecoder)cd).decode(ba, off, len, ca);
        return safeTrim(ca, clen, cs, isTrusted);
    } else {
        ByteBuffer bb = ByteBuffer.wrap(ba, off, len);
        CharBuffer cb = CharBuffer.wrap(ca);
        try {
            CoderResult cr = cd.decode(bb, cb, true);
            if (!cr.isUnderflow())
                cr.throwException();
            cr = cd.flush(cb);
            if (!cr.isUnderflow())
                cr.throwException();
        } catch (CharacterCodingException x) {
            // Substitution is always enabled,
            // so this shouldn't happen
            throw new Error(x);
        }
        return safeTrim(ca, cb.position(), cs, isTrusted);
    }
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
private void checkError(CoderResult result)
        throws CharacterCodingException {
    if (result.isError()) {
        result.throwException();
    }
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
@Override
public int read(byte[] b, int off, int len) throws IOException {
    // Obey InputStream contract.
    if (len == 0) {
        return 0;
    }

    // The rest of this method implements the process described by the CharsetEncoder javadoc.
    int totalBytesRead = 0;
    boolean doneEncoding = endOfInput;

    DRAINING:
    while (true) {
        // We stay in draining mode until there are no bytes left in the output buffer. Then we go
        // back to encoding/flushing.
        if (draining) {
            totalBytesRead += drain(b, off + totalBytesRead, len - totalBytesRead);
            if (totalBytesRead == len || doneFlushing) {
                return (totalBytesRead > 0) ? totalBytesRead : -1;
            }
            draining = false;
            byteBuffer.clear();
        }

        while (true) {
            // We call encode until there is no more input. The last call to encode will have endOfInput
            // == true. Then there is a final call to flush.
            CoderResult result;
            if (doneFlushing) {
                result = CoderResult.UNDERFLOW;
            } else if (doneEncoding) {
                result = encoder.flush(byteBuffer);
            } else {
                result = encoder.encode(charBuffer, byteBuffer, endOfInput);
            }

            if (result.isOverflow()) {
                // Not enough room in output buffer--drain it, creating a bigger buffer if necessary.
                startDraining(true);
                continue DRAINING;
            } else if (result.isUnderflow()) {
                // If encoder underflows, it means either:
                // a) the final flush() succeeded; next drain (then done)
                // b) we encoded all of the input; next flush
                // c) we ran of out input to encode; next read more input
                if (doneEncoding) { // (a)
                    doneFlushing = true;
                    startDraining(false);
                    continue DRAINING;
                } else if (endOfInput) { // (b)
                    doneEncoding = true;
                } else { // (c)
                    readMoreChars();
                }
            } else if (result.isError()) {
                // Only reach here if a CharsetEncoder with non-REPLACE settings is used.
                result.throwException();
                return 0; // Not called.
            }
        }
    }
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
/**
 * Convert the given bytes to characters.
 * 
 * @param bc byte input
 * @param cc char output
 * @param endOfInput    Is this all of the available data
 */
public void convert(ByteChunk bc, CharChunk cc, boolean endOfInput)
        throws IOException {
    if ((bb == null) || (bb.array() != bc.getBuffer())) {
        // Create a new byte buffer if anything changed
        bb = ByteBuffer.wrap(bc.getBuffer(), bc.getStart(), bc.getLength());
    } else {
        // Initialize the byte buffer
        bb.limit(bc.getEnd());
        bb.position(bc.getStart());
    }
    if ((cb == null) || (cb.array() != cc.getBuffer())) {
        // Create a new char buffer if anything changed
        cb = CharBuffer.wrap(cc.getBuffer(), cc.getEnd(), 
                cc.getBuffer().length - cc.getEnd());
    } else {
        // Initialize the char buffer
        cb.limit(cc.getBuffer().length);
        cb.position(cc.getEnd());
    }
    CoderResult result = null;
    // Parse leftover if any are present
    if (leftovers.position() > 0) {
        int pos = cb.position();
        // Loop until one char is decoded or there is a decoder error
        do {
            leftovers.put(bc.substractB());
            leftovers.flip();
            result = decoder.decode(leftovers, cb, endOfInput);
            leftovers.position(leftovers.limit());
            leftovers.limit(leftovers.array().length);
        } while (result.isUnderflow() && (cb.position() == pos));
        if (result.isError() || result.isMalformed()) {
            result.throwException();
        }
        bb.position(bc.getStart());
        leftovers.position(0);
    }
    // Do the decoding and get the results into the byte chunk and the char
    // chunk
    result = decoder.decode(bb, cb, endOfInput);
    if (result.isError() || result.isMalformed()) {
        result.throwException();
    } else if (result.isOverflow()) {
        // Propagate current positions to the byte chunk and char chunk, if
        // this continues the char buffer will get resized
        bc.setOffset(bb.position());
        cc.setEnd(cb.position());
    } else if (result.isUnderflow()) {
        // Propagate current positions to the byte chunk and char chunk
        bc.setOffset(bb.position());
        cc.setEnd(cb.position());
        // Put leftovers in the leftovers byte buffer
        if (bc.getLength() > 0) {
            leftovers.limit(leftovers.array().length);
            leftovers.position(bc.getLength());
            bc.substract(leftovers.array(), 0, bc.getLength());
        }
    }
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public IoBuffer putString(CharSequence val, CharsetEncoder encoder) throws CharacterCodingException {
    if (val.length() == 0) {
        return this;
    }

    CharBuffer in = CharBuffer.wrap(val);
    encoder.reset();

    int expandedState = 0;

    for (;;) {
        CoderResult cr;
        if (in.hasRemaining()) {
            cr = encoder.encode(in, buf(), true);
        } else {
            cr = encoder.flush(buf());
        }

        if (cr.isUnderflow()) {
            break;
        }
        if (cr.isOverflow()) {
            if (isAutoExpand()) {
                switch (expandedState) {
                case 0:
                    autoExpand((int) Math.ceil(in.remaining() * encoder.averageBytesPerChar()));
                    expandedState++;
                    break;
                case 1:
                    autoExpand((int) Math.ceil(in.remaining() * encoder.maxBytesPerChar()));
                    expandedState++;
                    break;
                default:
                    throw new RuntimeException("Expanded by "
                            + (int) Math.ceil(in.remaining() * encoder.maxBytesPerChar())
                            + " but that wasn't enough for '" + val + "'");
                }
                continue;
            }
        } else {
            expandedState = 0;
        }
        cr.throwException();
    }
    return this;
}