Java CoderResult.isError方法代码示例

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
public void flush() throws IOException {
    if (pos > 0) {
        if (out != null) {
            CharBuffer charBuffer = CharBuffer.wrap(text, 0, pos);
            CoderResult result = charset.encode(charBuffer, bytes, true);
            while (true) {
                if (result.isError()) {
                    throw new IOException(result.toString());
                } else if (result.isOverflow()) {
                    flushBytes();
                    result = charset.encode(charBuffer, bytes, true);
                    continue;
                }
                break;
            }
            flushBytes();
            out.flush();
        } else {
            writer.write(text, 0, pos);
            writer.flush();
        }
        pos = 0;
    }
}
 

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包/类
static String decodePassword(byte[] bytes) throws CharacterCodingException {
    CharsetDecoder decoder = Charset.forName("UTF-8").newDecoder(); // NOI18N
    ByteBuffer input = ByteBuffer.wrap(bytes);
    int outputLength = (int)(bytes.length * (double)decoder.maxCharsPerByte());
    if (outputLength == 0) {
        return ""; // NOI18N
    }
    char[] chars = new char[outputLength];
    CharBuffer output = CharBuffer.wrap(chars);
    CoderResult result = decoder.decode(input, output, true);
    if (!result.isError() && !result.isOverflow()) {
        result = decoder.flush(output);
    }
    if (result.isError() || result.isOverflow()) {
        throw new CharacterCodingException();
    } else {
        return new String(chars, 0, output.position());
    }
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
/**
 * Decode the buffer using the CharsetDecoder.
 * @param byteBuf
 * @return false if failed because the charbuffer was not big enough
 * @throws RuntimeException if it fails for encoding errors
 */
private boolean decodeUT8(ByteBuffer byteBuf) {
  // We give it all of the input data in call.
  boolean endOfInput = true;
  decoder.reset();
  charBuffer.rewind();
  // Convert utf-8 bytes to sequence of chars
  CoderResult result = decoder.decode(byteBuf, charBuffer, endOfInput);
  if (result.isOverflow()) {
    // Not enough space in the charBuffer.
    return false;
  } else if (result.isError()) {
    // Any other error
    try {
      result.throwException();
    } catch (CharacterCodingException e) {
      throw new RuntimeException(e);
    }
  }
  return true;
}
 

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 void write() {
    buffer.clear();
    CoderResult cr = encoder.encode(message, buffer, true);
    if (cr.isError()) {
        throw new IllegalArgumentException(cr.toString());
    }
    isDone = !cr.isOverflow();
    buffer.flip();
    endpoint.startMessage(Constants.OPCODE_TEXT, buffer,
            isDone && isLast, this);
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
private void handleEncodingResult(final CoderResult result) throws IOException {
    if (result.isError()) {
        result.throwException();
    }
    this.bbuf.flip();
    while (this.bbuf.hasRemaining()) {
        write(this.bbuf.get());
    }
    this.bbuf.compact();
}
 

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包/类
private void checkError(CoderResult result)
        throws CharacterCodingException {
    if (result.isError()) {
        result.throwException();
    }
}
 

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包/类
@Override
public int read(byte[] b, int off, int len) throws IOException {
  // Obey InputStream contract.
  checkPositionIndexes(off, off + len, b.length);
  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包/类
private boolean processDataControl() throws IOException {
	TransformationResult tr = transformation.getMoreData(opCode, fin, rsv, controlBufferBinary);
	if (TransformationResult.UNDERFLOW.equals(tr)) {
		return false;
	}
	// Control messages have fixed message size so
	// TransformationResult.OVERFLOW is not possible here

	controlBufferBinary.flip();
	if (opCode == Constants.OPCODE_CLOSE) {
		open = false;
		String reason = null;
		int code = CloseCodes.NORMAL_CLOSURE.getCode();
		if (controlBufferBinary.remaining() == 1) {
			controlBufferBinary.clear();
			// Payload must be zero or greater than 2
			throw new WsIOException(
					new CloseReason(CloseCodes.PROTOCOL_ERROR, sm.getString("wsFrame.oneByteCloseCode")));
		}
		if (controlBufferBinary.remaining() > 1) {
			code = controlBufferBinary.getShort();
			if (controlBufferBinary.remaining() > 0) {
				CoderResult cr = utf8DecoderControl.decode(controlBufferBinary, controlBufferText, true);
				if (cr.isError()) {
					controlBufferBinary.clear();
					controlBufferText.clear();
					throw new WsIOException(
							new CloseReason(CloseCodes.PROTOCOL_ERROR, sm.getString("wsFrame.invalidUtf8Close")));
				}
				// There will be no overflow as the output buffer is big
				// enough. There will be no underflow as all the data is
				// passed to the decoder in a single call.
				controlBufferText.flip();
				reason = controlBufferText.toString();
			}
		}
		wsSession.onClose(new CloseReason(Util.getCloseCode(code), reason));
	} else if (opCode == Constants.OPCODE_PING) {
		if (wsSession.isOpen()) {
			wsSession.getBasicRemote().sendPong(controlBufferBinary);
		}
	} else if (opCode == Constants.OPCODE_PONG) {
		MessageHandler.Whole<PongMessage> mhPong = wsSession.getPongMessageHandler();
		if (mhPong != null) {
			try {
				mhPong.onMessage(new WsPongMessage(controlBufferBinary));
			} catch (Throwable t) {
				handleThrowableOnSend(t);
			} finally {
				controlBufferBinary.clear();
			}
		}
	} else {
		// Should have caught this earlier but just in case...
		controlBufferBinary.clear();
		throw new WsIOException(new CloseReason(CloseCodes.PROTOCOL_ERROR,
				sm.getString("wsFrame.invalidOpCode", Integer.valueOf(opCode))));
	}
	controlBufferBinary.clear();
	newFrame();
	return true;
}
 

import java.nio.charset.CoderResult; //导入方法依赖的package包/类
/**
 * Convert the given bytes to characters.
 * 
 * @param bc byte input
 * @param cc char output
 */
public void convert(ByteChunk bc, CharChunk cc) 
    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.position(bc.getStart());
        bb.limit(bc.getEnd());
    }
    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.position(cc.getEnd());
        cb.limit(cc.getBuffer().length);
    }
    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, false);
            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, false);
    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.position(bc.getLength());
            leftovers.limit(leftovers.array().length);
            bc.substract(leftovers.array(), 0, bc.getLength());
        }
    }
}
 

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包/类
private boolean processDataControl() throws IOException {
    TransformationResult tr = transformation.getMoreData(opCode, fin, rsv, controlBufferBinary);
    if (TransformationResult.UNDERFLOW.equals(tr)) {
        return false;
    }
    // Control messages have fixed message size so
    // TransformationResult.OVERFLOW is not possible here

    controlBufferBinary.flip();
    if (opCode == Constants.OPCODE_CLOSE) {
        open = false;
        String reason = null;
        int code = CloseCodes.NORMAL_CLOSURE.getCode();
        if (controlBufferBinary.remaining() == 1) {
            controlBufferBinary.clear();
            // Payload must be zero or greater than 2
            throw new WsIOException(new CloseReason(
                    CloseCodes.PROTOCOL_ERROR,
                    sm.getString("wsFrame.oneByteCloseCode")));
        }
        if (controlBufferBinary.remaining() > 1) {
            code = controlBufferBinary.getShort();
            if (controlBufferBinary.remaining() > 0) {
                CoderResult cr = utf8DecoderControl.decode(
                        controlBufferBinary, controlBufferText, true);
                if (cr.isError()) {
                    controlBufferBinary.clear();
                    controlBufferText.clear();
                    throw new WsIOException(new CloseReason(
                            CloseCodes.PROTOCOL_ERROR,
                            sm.getString("wsFrame.invalidUtf8Close")));
                }
                // There will be no overflow as the output buffer is big
                // enough. There will be no underflow as all the data is
                // passed to the decoder in a single call.
                controlBufferText.flip();
                reason = controlBufferText.toString();
            }
        }
        wsSession.onClose(new CloseReason(Util.getCloseCode(code), reason));
    } else if (opCode == Constants.OPCODE_PING) {
        if (wsSession.isOpen()) {
            wsSession.getBasicRemote().sendPong(controlBufferBinary);
        }
    } else if (opCode == Constants.OPCODE_PONG) {
        MessageHandler.Whole<PongMessage> mhPong =
                wsSession.getPongMessageHandler();
        if (mhPong != null) {
            try {
                mhPong.onMessage(new WsPongMessage(controlBufferBinary));
            } catch (Throwable t) {
                handleThrowableOnSend(t);
            } finally {
                controlBufferBinary.clear();
            }
        }
    } else {
        // Should have caught this earlier but just in case...
        controlBufferBinary.clear();
        throw new WsIOException(new CloseReason(
                CloseCodes.PROTOCOL_ERROR,
                sm.getString("wsFrame.invalidOpCode",
                        Integer.valueOf(opCode))));
    }
    controlBufferBinary.clear();
    newFrame();
    return true;
}