Java CoderResult类代码示例

import java.nio.charset.CoderResult; //导入依赖的package包/类
public void flush() throws IOException {
    //Log.i("PackageManager", "flush mPos=" + mPos);
    if (mPos > 0) {
        if (mOutputStream != null) {
            CharBuffer charBuffer = CharBuffer.wrap(mText, 0, mPos);
            CoderResult result = mCharset.encode(charBuffer, mBytes, true);
            while (true) {
                if (result.isError()) {
                    throw new 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;
    }
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
private CoderResult encodeBufferLoop(CharBuffer src,
                                     ByteBuffer dst)
{
    int mark = src.position();
    try {
        while (src.hasRemaining()) {
            char c = src.get();
            if (c <= '\u00FF') {
                if (!dst.hasRemaining())
                    return CoderResult.OVERFLOW;
                dst.put((byte)c);
                mark++;
                continue;
            }
            if (sgp.parse(c, src) < 0)
                return sgp.error();
            return sgp.unmappableResult();
        }
        return CoderResult.UNDERFLOW;
    } finally {
        src.position(mark);
    }
}
 

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包/类
private CoderResult decodeBufferLoop(ByteBuffer src, CharBuffer dst) {
    int mark = src.position();
    try {
        while (src.hasRemaining()) {
            int b = src.get();

            char c = decode(b);
            if (c == '\uFFFD')
                return CoderResult.unmappableForLength(1);
            if (!dst.hasRemaining())
                return CoderResult.OVERFLOW;
            mark++;
            dst.put(c);
        }
        return CoderResult.UNDERFLOW;
    } finally {
        src.position(mark);
    }
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
    if (buffer == null) {
        assert decoder != null;
        return decoder.decode(in, out, false);
    }
    if (cont) {
        return flushHead (in,out);
    }
    if (buffer.remaining() == 0) {
       return handleHead (in,out);
   }
   else if (buffer.remaining() < in.remaining()) {
       int limit = in.limit();
       in.limit(in.position()+buffer.remaining());
       buffer.put(in);
       in.limit(limit);
       return handleHead (in, out);
   }
   else {
       buffer.put(in);
       return CoderResult.UNDERFLOW;
   }
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
private void processInput(final boolean endOfInput) throws IOException {
    // Prepare decoderIn for reading
    decoderIn.flip();
    CoderResult coderResult;
    while (true) {
        coderResult = decoder.decode(decoderIn, decoderOut, endOfInput);
        if (coderResult.isOverflow()) {
            flushOutput();
        } else if (coderResult.isUnderflow()) {
            break;
        } else {
            // The decoder is configured to replace malformed input and unmappable characters,
            // so we should not get here.
            throw new IOException("Unexpected coder result"); //NOI18N
        }
    }
    // Discard the bytes that have been read
    decoderIn.compact();
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
@Override
protected CoderResult implFlush(ByteBuffer out) {
    CoderResult res;
    if (buffer != null) {
        res = handleHead(null, out);
        return res;
    }
    else if (remainder != null) {
        encoder.encode(remainder, out, true);
    }
    else {
        CharBuffer empty = (CharBuffer) CharBuffer.allocate(0).flip();
        encoder.encode(empty, out, true);
    }
    res = encoder.flush(out);
    return res;
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
private CoderResult decodeBufferLoop(ByteBuffer src,
                                     CharBuffer dst)
{
    int mark = src.position();
    try {
        while (src.hasRemaining()) {
            byte b = src.get();
            if (!dst.hasRemaining())
                return CoderResult.OVERFLOW;
            dst.put((char)(b & 0xff));
            mark++;
        }
        return CoderResult.UNDERFLOW;
    } finally {
        src.position(mark);
    }
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
/**
 * Decode the contents of the input ByteBuffer into a CharBuffer.
 * 
 * @param endOfInput indicates end of input
 * @throws IOException if an I/O error occurs
 */
private void processInput(boolean endOfInput) throws IOException {
    // Prepare decoderIn for reading
    decoderIn.flip();
    CoderResult coderResult;
    while (true) {
        coderResult = decoder.decode(decoderIn, decoderOut, endOfInput);
        if (coderResult.isOverflow()) {
            flushOutput();
        } else if (coderResult.isUnderflow()) {
            break;
        } else {
            // The decoder is configured to replace malformed input and unmappable characters,
            // so we should not get here.
            throw new IOException("Unexpected coder result");
        }
    }
    // Discard the bytes that have been read
    decoderIn.compact();
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
String toString(byte[] ba, int length) {
    CharsetDecoder cd = decoder().reset();
    int len = (int)(length * cd.maxCharsPerByte());
    char[] ca = new char[len];
    if (len == 0)
        return new String(ca);
    // UTF-8 only for now. Other ArrayDeocder only handles
    // CodingErrorAction.REPLACE mode. ZipCoder uses
    // REPORT mode.
    if (isUTF8 && cd instanceof ArrayDecoder) {
        int clen = ((ArrayDecoder)cd).decode(ba, 0, length, ca);
        if (clen == -1)    // malformed
            throw new IllegalArgumentException("MALFORMED");
        return new String(ca, 0, clen);
    }
    ByteBuffer bb = ByteBuffer.wrap(ba, 0, length);
    CharBuffer cb = CharBuffer.wrap(ca);
    CoderResult cr = cd.decode(bb, cb, true);
    if (!cr.isUnderflow())
        throw new IllegalArgumentException(cr.toString());
    cr = cd.flush(cb);
    if (!cr.isUnderflow())
        throw new IllegalArgumentException(cr.toString());
    return new String(ca, 0, cb.position());
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
private CoderResult encodeArrayLoop(CharBuffer src, ByteBuffer dst) {
    char[] sa = src.array();
    int sp = src.arrayOffset() + src.position();
    int sl = src.arrayOffset() + src.limit();

    byte[] da = dst.array();
    int dp = dst.arrayOffset() + dst.position();
    int dl = dst.arrayOffset() + dst.limit();
    int len  = Math.min(dl - dp, sl - sp);

    while (len-- > 0) {
        char c = sa[sp];
        int b = encode(c);
        if (b == UNMAPPABLE_ENCODING) {
            if (Character.isSurrogate(c)) {
                if (sgp == null)
                    sgp = new Surrogate.Parser();
                if (sgp.parse(c, sa, sp, sl) < 0) {
                    return withResult(sgp.error(), src, sp, dst, dp);
                }
                return withResult(sgp.unmappableResult(), src, sp, dst, dp);
            }
            return withResult(CoderResult.unmappableForLength(1),
                       src, sp, dst, dp);
        }
        da[dp++] = (byte)b;
        sp++;
    }
    return withResult(sp < sl ? CoderResult.OVERFLOW : CoderResult.UNDERFLOW,
                      src, sp, dst, dp);
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
/**
 * Generates one or two UTF-16 characters to represent the given UCS-4
 * character.
 *
 * @param  uc   The UCS-4 character
 * @param  len  The number of input bytes from which the UCS-4 value
 *              was constructed (used when creating result objects)
 * @param  dst  The destination buffer, to which one or two UTF-16
 *              characters will be written
 *
 * @return   Either a positive count of the number of UTF-16 characters
 *           written to the destination buffer, or -1, in which case
 *           error() will return a descriptive result object
 */
public int generate(int uc, int len, CharBuffer dst) {
    if (uc <= 0xffff) {
        if (is(uc)) {
            error = CoderResult.malformedForLength(len);
            return -1;
        }
        if (dst.remaining() < 1) {
            error = CoderResult.OVERFLOW;
            return -1;
        }
        dst.put((char)uc);
        error = null;
        return 1;
    }
    if (uc < UCS4_MIN) {
        error = CoderResult.malformedForLength(len);
        return -1;
    }
    if (uc <= UCS4_MAX) {
        if (dst.remaining() < 2) {
            error = CoderResult.OVERFLOW;
            return -1;
        }
        dst.put(high(uc));
        dst.put(low(uc));
        error = null;
        return 2;
    }
    error = CoderResult.unmappableForLength(len);
    return -1;
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
protected CoderResult encodeLoop(CharBuffer src,
                                 ByteBuffer dst)
{
    if (src.hasArray() && dst.hasArray())
        return encodeArrayLoop(src, dst);
    else
        return encodeBufferLoop(src, dst);
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
protected CoderResult encodeLoop(CharBuffer src, ByteBuffer dst)
{
    if (src.hasArray() && dst.hasArray())
        return encodeArrayLoop(src, dst);
    else
        return encodeBufferLoop(src, dst);
}
 

import java.nio.charset.CoderResult; //导入依赖的package包/类
private static CoderResult malformed(ByteBuffer src, int sp,
                                     CharBuffer dst, int dp,
                                     int nb)
{
    src.position(sp - src.arrayOffset());
    CoderResult cr = malformedN(src, nb);
    updatePositions(src, sp, dst, dp);
    return cr;
}