/**
*******************************************************************************
* Copyright (C) 1996-2006, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*
*******************************************************************************
*/
/**
* A JNI interface for ICU converters.
*
*
* @author Ram Viswanadha, IBM
*/
package com.ibm.icu4jni.charset;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import com.ibm.icu4jni.common.ErrorCode;
// BEGIN android-removed
// import com.ibm.icu4jni.converters.NativeConverter;
// END android-removed
public final class CharsetEncoderICU extends CharsetEncoder {
private static final int INPUT_OFFSET = 0,
OUTPUT_OFFSET = 1,
INVALID_CHARS = 2,
INPUT_HELD = 3,
LIMIT = 4;
/* data is 3 element array where
* data[INPUT_OFFSET] = on input contains the start of input and on output the number of input chars consumed
* data[OUTPUT_OFFSET] = on input contains the start of output and on output the number of output bytes written
* data[INVALID_CHARS] = number of invalid chars
* data[INPUT_HELD] = number of input chars held in the converter's state
*/
private int[] data = new int[LIMIT];
/* handle to the ICU converter that is opened */
private long converterHandle=0;
private char[] input = null;
private byte[] output = null;
// BEGIN android-added
private char[] allocatedInput = null;
private byte[] allocatedOutput = null;
// END android-added
// These instance variables are
// always assigned in the methods
// before being used. This class
// inhrently multithread unsafe
// so we dont have to worry about
// synchronization
private int inEnd;
private int outEnd;
private int ec;
private int savedInputHeldLen;
private int onUnmappableInput = NativeConverter.STOP_CALLBACK;;
private int onMalformedInput = NativeConverter.STOP_CALLBACK;;
/**
* Construcs a new encoder for the given charset
* @param cs for which the decoder is created
* @param cHandle the address of ICU converter
* @param replacement the substitution bytes
* @stable ICU 2.4
*/
public CharsetEncoderICU(Charset cs, long cHandle, byte[] replacement) {
super(
cs,
(float) NativeConverter.getAveBytesPerChar(cHandle),
(float) NativeConverter.getMaxBytesPerChar(cHandle),
replacement);
byte[] sub = replacement();
// The default callback action on unmappable input
// or malformed input is to ignore so we set ICU converter
// callback to stop and report the error
ec = NativeConverter.setCallbackEncode( cHandle,
onMalformedInput,
onUnmappableInput,
sub, sub.length);
converterHandle = cHandle;
if (ErrorCode.isFailure(ec)) {
throw ErrorCode.getException(ec);
}
}
/**
* Sets this encoders replacement string. Substitutes the string in output if an
* umappable or illegal sequence is encountered
* @param newReplacement to replace the error chars with
* @stable ICU 2.4
*/
protected void implReplaceWith(byte[] newReplacement) {
if (converterHandle != 0) {
if (newReplacement.length
> NativeConverter.getMaxBytesPerChar(converterHandle)) {
throw new IllegalArgumentException("Number of replacement Bytes are greater than max bytes per char");
}
ec = NativeConverter.setSubstitutionBytes(converterHandle,
newReplacement,
newReplacement.length);
if (ErrorCode.isFailure(ec)) {
throw ErrorCode.getException(ec);
}
}
}
/**
* Sets the action to be taken if an illegal sequence is encountered
* @param newAction action to be taken
* @exception IllegalArgumentException
* @stable ICU 2.4
*/
protected void implOnMalformedInput(CodingErrorAction newAction) {
onMalformedInput = NativeConverter.STOP_CALLBACK;
if (newAction.equals(CodingErrorAction.IGNORE)) {
onMalformedInput = NativeConverter.SKIP_CALLBACK;
} else if (newAction.equals(CodingErrorAction.REPLACE)) {
onMalformedInput = NativeConverter.SUBSTITUTE_CALLBACK;
}
byte[] sub = replacement();
ec = NativeConverter.setCallbackEncode(converterHandle, onMalformedInput, onUnmappableInput, sub, sub.length);
if (ErrorCode.isFailure(ec)) {
throw ErrorCode.getException(ec);
}
}
/**
* Sets the action to be taken if an illegal sequence is encountered
* @param newAction action to be taken
* @exception IllegalArgumentException
* @stable ICU 2.4
*/
protected void implOnUnmappableCharacter(CodingErrorAction newAction) {
onUnmappableInput = NativeConverter.STOP_CALLBACK;
if (newAction.equals(CodingErrorAction.IGNORE)) {
onUnmappableInput = NativeConverter.SKIP_CALLBACK;
} else if (newAction.equals(CodingErrorAction.REPLACE)) {
onUnmappableInput = NativeConverter.SUBSTITUTE_CALLBACK;
}
byte[] sub = replacement();
ec = NativeConverter.setCallbackEncode(converterHandle, onMalformedInput, onUnmappableInput, sub, sub.length);
if (ErrorCode.isFailure(ec)) {
throw ErrorCode.getException(ec);
}
}
/**
* Flushes any characters saved in the converter's internal buffer and
* resets the converter.
* @param out action to be taken
* @return result of flushing action and completes the decoding all input.
* Returns CoderResult.UNDERFLOW if the action succeeds.
* @stable ICU 2.4
*/
protected CoderResult implFlush(ByteBuffer out) {
try {
data[OUTPUT_OFFSET] = getArray(out);
ec = NativeConverter.flushCharToByte(converterHandle,/* Handle to ICU Converter */
output, /* output array of chars */
outEnd, /* output index+1 to be written */
data /* contains data, inOff,outOff */
);
/* If we don't have room for the output, throw an exception*/
if (ErrorCode.isFailure(ec)) {
if (ec == ErrorCode.U_BUFFER_OVERFLOW_ERROR) {
return CoderResult.OVERFLOW;
}else if (ec == ErrorCode.U_TRUNCATED_CHAR_FOUND) {//CSDL: add this truncated character error handling
if(data[INPUT_OFFSET]>0){
return CoderResult.malformedForLength(data[INPUT_OFFSET]);
}
}else {
ErrorCode.getException(ec);
}
}
return CoderResult.UNDERFLOW;
} finally {
setPosition(out);
implReset();
}
}
/**
* Resets the from Unicode mode of converter
* @stable ICU 2.4
*/
protected void implReset() {
NativeConverter.resetCharToByte(converterHandle);
data[INPUT_OFFSET] = 0;
data[OUTPUT_OFFSET] = 0;
data[INVALID_CHARS] = 0;
data[INPUT_HELD] = 0;
savedInputHeldLen = 0;
}
/**
* Encodes one or more chars. The default behaviour of the
* converter is stop and report if an error in input stream is encountered.
* To set different behaviour use @see CharsetEncoder.onMalformedInput()
* @param in buffer to decode
* @param out buffer to populate with decoded result
* @return result of decoding action. Returns CoderResult.UNDERFLOW if the decoding
* action succeeds or more input is needed for completing the decoding action.
* @stable ICU 2.4
*/
protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) {
if (!in.hasRemaining()) {
return CoderResult.UNDERFLOW;
}
data[INPUT_OFFSET] = getArray(in);
data[OUTPUT_OFFSET]= getArray(out);
data[INPUT_HELD] = 0;
// BEGIN android-added
data[INVALID_CHARS] = 0; // Make sure we don't see earlier errors.
// END android added
try {
/* do the conversion */
ec = NativeConverter.encode(converterHandle,/* Handle to ICU Converter */
input, /* input array of bytes */
inEnd, /* last index+1 to be converted */
output, /* output array of chars */
outEnd, /* output index+1 to be written */
data, /* contains data, inOff,outOff */
false /* donot flush the data */
);
if (ErrorCode.isFailure(ec)) {
/* If we don't have room for the output return error */
if (ec == ErrorCode.U_BUFFER_OVERFLOW_ERROR) {
return CoderResult.OVERFLOW;
} else if (ec == ErrorCode.U_INVALID_CHAR_FOUND) {
return CoderResult.unmappableForLength(data[INVALID_CHARS]);
} else if (ec == ErrorCode.U_ILLEGAL_CHAR_FOUND) {
// in.position(in.position() - 1);
return CoderResult.malformedForLength(data[INVALID_CHARS]);
}
}
return CoderResult.UNDERFLOW;
} finally {
/* save state */
setPosition(in);
setPosition(out);
}
}
/**
* Ascertains if a given Unicode character can
* be converted to the target encoding
*
* @param c the character to be converted
* @return true if a character can be converted
* @stable ICU 2.4
*
*/
public boolean canEncode(char c) {
return canEncode((int) c);
}
/**
* Ascertains if a given Unicode code point (32bit value for handling surrogates)
* can be converted to the target encoding. If the caller wants to test if a
* surrogate pair can be converted to target encoding then the
* responsibility of assembling the int value lies with the caller.
* For assembling a code point the caller can use UTF16 class of ICU4J and do something like:
* <pre>
* while(i<mySource.length){
* if(UTF16.isLeadSurrogate(mySource[i])&& i+1< mySource.length){
* if(UTF16.isTrailSurrogate(mySource[i+1])){
* int temp = UTF16.charAt(mySource,i,i+1,0);
* if(!((CharsetEncoderICU) myConv).canEncode(temp)){
* passed=false;
* }
* i++;
* i++;
* }
* }
* }
* </pre>
* or
* <pre>
* String src = new String(mySource);
* int i,codepoint;
* boolean passed = false;
* while(i<src.length()){
* codepoint = UTF16.charAt(src,i);
* i+= (codepoint>0xfff)? 2:1;
* if(!(CharsetEncoderICU) myConv).canEncode(codepoint)){
* passed = false;
* }
* }
* </pre>
*
* @param codepoint Unicode code point as int value
* @return true if a character can be converted
* @obsolete ICU 2.4
* @deprecated ICU 3.4
*/
public boolean canEncode(int codepoint) {
return NativeConverter.canEncode(converterHandle, codepoint);
}
/**
* Releases the system resources by cleanly closing ICU converter opened
* @exception Throwable exception thrown by super class' finalize method
* @stable ICU 2.4
*/
protected void finalize() throws Throwable {
NativeConverter.closeConverter(converterHandle);
super.finalize();
converterHandle=0;
}
//------------------------------------------
// private utility methods
//------------------------------------------
private final int getArray(ByteBuffer out) {
if(out.hasArray()){
// BEGIN android-changed: take arrayOffset into account
output = out.array();
outEnd = out.arrayOffset() + out.limit();
return out.arrayOffset() + out.position();
// END android-changed
}else{
outEnd = out.remaining();
// BEGIN android-added
if (allocatedOutput == null || (outEnd > allocatedOutput.length)) {
allocatedOutput = new byte[outEnd];
}
output = allocatedOutput;
// END android-added
//since the new
// buffer start position
// is 0
return 0;
}
}
private final int getArray(CharBuffer in) {
if(in.hasArray()){
// BEGIN android-changed: take arrayOffset into account
input = in.array();
inEnd = in.arrayOffset() + in.limit();
return in.arrayOffset() + in.position() + savedInputHeldLen;/*exclude the number fo bytes held in previous conversion*/
// END android-changed
}else{
inEnd = in.remaining();
// BEGIN android-added
if (allocatedInput == null || (inEnd > allocatedInput.length)) {
allocatedInput = new char[inEnd];
}
input = allocatedInput;
// END android-added
// save the current position
int pos = in.position();
in.get(input,0,inEnd);
// reset the position
in.position(pos);
// the start position
// of the new buffer
// is whatever is savedInputLen
return savedInputHeldLen;
}
}
private final void setPosition(ByteBuffer out) {
if (out.hasArray()) {
// in getArray method we accessed the
// array backing the buffer directly and wrote to
// it, so just just set the position and return.
// This is done to avoid the creation of temp array.
// BEGIN android-changed: take arrayOffset into account
out.position(out.position() + data[OUTPUT_OFFSET] - out.arrayOffset());
// END android-changed
} else {
out.put(output, 0, data[OUTPUT_OFFSET]);
}
// BEGIN android-added
// release reference to output array, which may not be ours
output = null;
// END android-added
}
private final void setPosition(CharBuffer in){
// BEGIN android-removed
// // was there input held in the previous invocation of encodeLoop
// // that resulted in output in this invocation?
// if(data[OUTPUT_OFFSET]>0 && savedInputHeldLen>0){
// int len = in.position() + data[INPUT_OFFSET] + savedInputHeldLen;
// in.position(len);
// savedInputHeldLen = data[INPUT_HELD];
// }else{
// in.position(in.position() + data[INPUT_OFFSET] + savedInputHeldLen);
// savedInputHeldLen = data[INPUT_HELD];
// in.position(in.position() - savedInputHeldLen);
// }
// END android-removed
// BEGIN android-added
// Slightly rewired original code to make it cleaner. Also
// added a fix for the problem where input charatcers got
// lost when invalid characters were encountered. Not sure
// what happens when data[INVALID_CHARS] is > 1, though,
// since we never saw that happening.
int len = in.position() + data[INPUT_OFFSET] + savedInputHeldLen;
len -= data[INVALID_CHARS]; // Otherwise position becomes wrong.
in.position(len);
savedInputHeldLen = data[INPUT_HELD];
// was there input held in the previous invocation of encodeLoop
// that resulted in output in this invocation?
if(!(data[OUTPUT_OFFSET]>0 && savedInputHeldLen>0)){
in.position(in.position() - savedInputHeldLen);
}
// END android-added
// BEGIN android-added
// release reference to input array, which may not be ours
input = null;
// END android-added
}
}