Java CoderResult.isMalformed方法代碼示例

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包/類
/**
 * Compute lenght of this sequence - quite expensive operation, indeed.
 */
@Override
public int length() {
    if (length != -1) {
        return length;
    }
    long start = System.currentTimeMillis();
    int charactersRead = 0;
    long bytesRead = 0;
    MappedByteBuffer mappedByteBuffer = null;
    CharBuffer charBuffer = CharBuffer.allocate(SIZE_LIMIT);
    CharsetDecoder decoder = prepareDecoder(charset);
    decoder.onUnmappableCharacter(CodingErrorAction.IGNORE);

    try {
        while (bytesRead < fileSize) {
            mappedByteBuffer = fileChannel.map(
                    FileChannel.MapMode.READ_ONLY, bytesRead,
                    Math.min(SIZE_LIMIT, fileSize - bytesRead));
            CoderResult result;
            do {
                charBuffer.clear();
                result = decoder.decode(
                        mappedByteBuffer, charBuffer,
                        bytesRead + SIZE_LIMIT >= fileSize);
                if (result.isUnmappable() || result.isMalformed()
                        || result.isError()) {
                    throw new IOException("Error decoding file: "
                            + result.toString() + " ");
                }
                if (bytesRead + SIZE_LIMIT >= fileSize) {
                    LOG.info("Coding end");
                }
                charactersRead += charBuffer.position();
            } while (result.isOverflow());

            int readNow = mappedByteBuffer.position();
            bytesRead += readNow;
            unmap(mappedByteBuffer);
        }
        charBuffer.clear();
        boolean repeat;
        do {
            repeat = decoder.flush(charBuffer).isOverflow();
            charactersRead += charBuffer.position();
            charBuffer.clear();
        } while (repeat);
    } catch (IOException ex) {
        if (mappedByteBuffer != null) {
            unmap(mappedByteBuffer);
        }
        Exceptions.printStackTrace(ex);
    }
    length = charactersRead;
    LOG.log(Level.INFO, "Length computed in {0} ms.", //NOI18N
            System.currentTimeMillis() - start);
    return length;
}
 

import java.nio.charset.CoderResult; //導入方法依賴的package包/類
@Override
public char charAt(int index) {

    if (index < lastIndex) {
        returns++;
    }
    lastIndex = index;
    if (index > length()) {
        throw new IndexOutOfBoundsException();
    }
    if (isInBuffer(index)) {
        return getFromBuffer(index);
    } else {
        if (index < currentStart || currentStart == -1) {
            reset();
        }
        retrieves++;
        MappedByteBuffer mappedByteBuffer = null;
        try {
            while (readBytes < fileSize) {
                try {
                    mappedByteBuffer = fileChannel.map(
                            FileChannel.MapMode.READ_ONLY,
                            readBytes,
                            Math.min(SIZE_LIMIT, fileSize - readBytes));
                    maps++;
                    CoderResult result;
                    do {
                        currentStart = currentStart == -1 ? 0
                                : currentStart + currentBuffer.limit();
                        currentBuffer.clear();
                        result = currentDecoder.decode(mappedByteBuffer,
                                currentBuffer,
                                readBytes + SIZE_LIMIT >= fileSize);
                        currentBuffer.flip();
                        int readChars = currentBuffer.limit();
                        if (currentStart + readChars > index) {
                            return getFromBuffer(index);
                        }
                        if (result.isUnmappable() || result.isMalformed()
                                || result.isError()) {
                            throw new IOException("Error decoding file: "
                                    + result.toString() + " ");
                        }
                    } while (result.isOverflow());
                } finally {
                    if (mappedByteBuffer != null) {
                        int readNow = mappedByteBuffer.position();
                        readBytes += readNow;
                        unmap(mappedByteBuffer);
                    }
                }
            }
            boolean repeat;
            do {
                repeat = currentDecoder.flush(currentBuffer).isOverflow();
                int size = currentBuffer.position();
                if (size + currentStart > index) {
                    currentBuffer.flip();
                    return currentBuffer.get(index - currentStart);
                }
                currentBuffer.clear();
                currentStart += size;
            } while (repeat);
        } catch (IOException ex) {
            if (mappedByteBuffer != null) {
                unmap(mappedByteBuffer);
            }
            Exceptions.printStackTrace(ex);
        }
    }

    throw new IllegalStateException(
            "Cannot get character.");   //NOI18N
}
 

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包/類
/**
 * 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.limit(bc.getBuffer().length);
        bb.position(bc.getEnd());
    }
    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.limit(cc.getEnd());
        cb.position(cc.getStart());
    }
    CoderResult result = null;
    // Parse leftover if any are present
    if (leftovers.position() > 0) {
        int pos = bb.position();
        // Loop until one char is encoded or there is a encoder error
        do {
            leftovers.put((char) cc.substract());
            leftovers.flip();
            result = encoder.encode(leftovers, bb, false);
            leftovers.position(leftovers.limit());
            leftovers.limit(leftovers.array().length);
        } while (result.isUnderflow() && (bb.position() == pos));
        if (result.isError() || result.isMalformed()) {
            result.throwException();
        }
        cb.position(cc.getStart());
        leftovers.position(0);
    }
    // Do the decoding and get the results into the byte chunk and the char
    // chunk
    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());
        // Put leftovers in the leftovers char buffer
        if (cc.getLength() > 0) {
            leftovers.limit(leftovers.array().length);
            leftovers.position(cc.getLength());
            cc.substract(leftovers.array(), 0, cc.getLength());
        }
    }
}
 

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包/類
@SuppressWarnings("cast")
public CharBuffer decode(ByteBuffer inbuf, boolean ignoreEncodingErrors) {
    String encName = getEncodingName();
    CharsetDecoder decoder;
    try {
        decoder = getDecoder(encName, ignoreEncodingErrors);
    } catch (IllegalCharsetNameException | UnsupportedCharsetException e) {
        log.error(Errors.UnsupportedEncoding(encName));
        return (CharBuffer)CharBuffer.allocate(1).flip();
    }

    // slightly overestimate the buffer size to avoid reallocation.
    float factor =
        decoder.averageCharsPerByte() * 0.8f +
        decoder.maxCharsPerByte() * 0.2f;
    CharBuffer dest = CharBuffer.
        allocate(10 + (int)(inbuf.remaining()*factor));

    while (true) {
        CoderResult result = decoder.decode(inbuf, dest, true);
        dest.flip();

        if (result.isUnderflow()) { // done reading
            // make sure there is at least one extra character
            if (dest.limit() == dest.capacity()) {
                dest = CharBuffer.allocate(dest.capacity()+1).put(dest);
                dest.flip();
            }
            return dest;
        } else if (result.isOverflow()) { // buffer too small; expand
            int newCapacity =
                10 + dest.capacity() +
                (int)(inbuf.remaining()*decoder.maxCharsPerByte());
            dest = CharBuffer.allocate(newCapacity).put(dest);
        } else if (result.isMalformed() || result.isUnmappable()) {
            // bad character in input
            StringBuilder unmappable = new StringBuilder();
            int len = result.length();

            for (int i = 0; i < len; i++) {
                unmappable.append(String.format("%02X", inbuf.get()));
            }

            String charsetName = charset == null ? encName : charset.name();

            log.error(dest.limit(),
                      Errors.IllegalCharForEncoding(unmappable.toString(), charsetName));

            // undo the flip() to prepare the output buffer
            // for more translation
            dest.position(dest.limit());
            dest.limit(dest.capacity());
            dest.put((char)0xfffd); // backward compatible
        } else {
            throw new AssertionError(result);
        }
    }
    // unreached
}
 

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包/類
/**
 * 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.limit(bc.getBuffer().length);
		bb.position(bc.getEnd());
	}
	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.limit(cc.getEnd());
		cb.position(cc.getStart());
	}
	CoderResult result = null;
	// Parse leftover if any are present
	if (leftovers.position() > 0) {
		int pos = bb.position();
		// Loop until one char is encoded or there is a encoder error
		do {
			leftovers.put((char) cc.substract());
			leftovers.flip();
			result = encoder.encode(leftovers, bb, false);
			leftovers.position(leftovers.limit());
			leftovers.limit(leftovers.array().length);
		} while (result.isUnderflow() && (bb.position() == pos));
		if (result.isError() || result.isMalformed()) {
			result.throwException();
		}
		cb.position(cc.getStart());
		leftovers.position(0);
	}
	// Do the decoding and get the results into the byte chunk and the char
	// chunk
	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());
		// Put leftovers in the leftovers char buffer
		if (cc.getLength() > 0) {
			leftovers.limit(leftovers.array().length);
			leftovers.position(cc.getLength());
			cc.substract(leftovers.array(), 0, cc.getLength());
		}
	}
}