icu4jni/charset/CharsetDecoderICU.java

/**
*******************************************************************************
* 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 com.ibm.icu4jni.common.ErrorCode;
// BEGIN android-removed
// import com.ibm.icu4jni.converters.NativeConverter;
// END android-removed


import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import java.nio.ByteBuffer;

public final class CharsetDecoderICU extends CharsetDecoder{


    private static final int INPUT_OFFSET   = 0,
                             OUTPUT_OFFSET  = 1,
                             INVALID_BYTES  = 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  byte[] input = null;
    private  char[] output= null;

    // BEGIN android-added
    private byte[] allocatedInput = null;
    private char[] 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 onUnmappableInput = NativeConverter.STOP_CALLBACK;;
    private int onMalformedInput = NativeConverter.STOP_CALLBACK;;
    private int savedInputHeldLen;

    /**
     * Constructs a new decoder for the given charset
     * @param cs for which the decoder is created
     * @param cHandle the address of ICU converter
     * @exception RuntimeException
     * @stable ICU 2.4
     */
    public CharsetDecoderICU(Charset cs,long cHandle){
         super(cs,
               NativeConverter.getAveCharsPerByte(cHandle),
               NativeConverter.getMaxCharsPerByte(cHandle)
               );

         char[] sub = replacement().toCharArray();
         ec = NativeConverter.setCallbackDecode(cHandle,
                                                onMalformedInput,
                                                onUnmappableInput,
                                                sub, sub.length);
         if(ErrorCode.isFailure(ec)){
            throw ErrorCode.getException(ec);
         }
         // store the converter handle
         converterHandle=cHandle;

    }

    /**
     * Sets this decoders replacement string. Substitutes the string in input if an
     * umappable or illegal sequence is encountered
     * @param newReplacement to replace the error bytes with
     * @stable ICU 2.4
     */
    protected void implReplaceWith(String newReplacement) {
        if(converterHandle > 0){
            if( newReplacement.length() > NativeConverter.getMaxBytesPerChar(converterHandle)) {
                    throw new IllegalArgumentException();
            }
            ec =NativeConverter.setSubstitutionChars(converterHandle,
                                                    newReplacement.toCharArray(),
                                                    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 final void implOnMalformedInput(CodingErrorAction newAction) {
        if(newAction.equals(CodingErrorAction.IGNORE)){
            onMalformedInput = NativeConverter.SKIP_CALLBACK;
        }else if(newAction.equals(CodingErrorAction.REPLACE)){
            onMalformedInput = NativeConverter.SUBSTITUTE_CALLBACK;
        }else if(newAction.equals(CodingErrorAction.REPORT)){
            onMalformedInput = NativeConverter.STOP_CALLBACK;
        }
        char[] sub = replacement().toCharArray();
        //System.out.println(" setting callbacks mfi " + onMalformedInput +" umi " + onUnmappableInput);
        ec = NativeConverter.setCallbackDecode(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 final void implOnUnmappableCharacter(CodingErrorAction newAction) {
        if(newAction.equals(CodingErrorAction.IGNORE)){
            onUnmappableInput = NativeConverter.SKIP_CALLBACK;
        }else if(newAction.equals(CodingErrorAction.REPLACE)){
            onUnmappableInput = NativeConverter.SUBSTITUTE_CALLBACK;
        }else if(newAction.equals(CodingErrorAction.REPORT)){
            onUnmappableInput = NativeConverter.STOP_CALLBACK;
        }
        char[] sub = replacement().toCharArray();
        ec = NativeConverter.setCallbackDecode(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 final CoderResult implFlush(CharBuffer out) {
       try{

           data[OUTPUT_OFFSET] = getArray(out);

            ec=NativeConverter.flushByteToChar(
                                            converterHandle,  /* Handle to ICU Converter */
                                            output,           /* input array of chars */
                                            outEnd,           /* input 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{
            /* save the flushed data */
            setPosition(out);
            implReset();
       }
    }

    /**
     * Resets the to Unicode mode of converter
     * @stable ICU 2.4
     */
    protected void implReset() {
        NativeConverter.resetByteToChar(converterHandle);
        data[INPUT_OFFSET] = 0;
        data[OUTPUT_OFFSET] = 0;
        data[INVALID_BYTES] = 0;
        data[INPUT_HELD] = 0;
        savedInputHeldLen = 0;
        output = null;
        input = null;
    }

    /**
     * Decodes one or more bytes. The default behaviour of the converter
     * is stop and report if an error in input stream is encountered.
     * To set different behaviour use @see CharsetDecoder.onMalformedInput()
     * This  method allows a buffer by buffer conversion of a data stream.
     * The state of the conversion is saved between calls to convert.
     * Among other things, this means multibyte input sequences can be
     * split between calls. If a call to convert results in an Error, the
     * conversion may be continued by calling convert again with suitably
     * modified parameters.All conversions should be finished with a call to
     * the flush method.
     * @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 decodeLoop(ByteBuffer in,CharBuffer out){

        if(!in.hasRemaining()){
            return CoderResult.UNDERFLOW;
        }

        data[INPUT_OFFSET] = getArray(in);
        data[OUTPUT_OFFSET]= getArray(out);
        data[INPUT_HELD] = 0;

        try{
            /* do the conversion */
            ec=NativeConverter.decode(
                                converterHandle,  /* Handle to ICU Converter */
                                input,            /* input array of bytes */
                                inEnd,            /* last index+1 to be converted */
                                output,           /* input array of chars */
                                outEnd,           /* input index+1 to be written */
                                data,             /* contains data, inOff,outOff */
                                false             /* donot flush the data */
                                );


            /* return an error*/
            if(ec == ErrorCode.U_BUFFER_OVERFLOW_ERROR){
                return CoderResult.OVERFLOW;
            }else if(ec==ErrorCode.U_INVALID_CHAR_FOUND){
                return CoderResult.malformedForLength(data[INVALID_BYTES]);
            }else if(ec==ErrorCode.U_ILLEGAL_CHAR_FOUND){
                return CoderResult.malformedForLength(data[INVALID_BYTES]);
            }
            /* decoding action succeded */
            return CoderResult.UNDERFLOW;
        }finally{
            setPosition(in);
            setPosition(out);
        }
    }

    /**
     * Releases the system resources by cleanly closing ICU converter opened
     * @stable ICU 2.4
     */
    protected void finalize()throws Throwable{
        NativeConverter.closeConverter(converterHandle);
        super.finalize();
        converterHandle = 0;
    }

    //------------------------------------------
    // private utility methods
    //------------------------------------------

    private final int getArray(CharBuffer 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 char[outEnd];
            }
            output = allocatedOutput;
            // END android-added
            //since the new
            // buffer start position
            // is 0
            return 0;
        }

    }
    private  final int getArray(ByteBuffer 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 byte[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(CharBuffer out){
        if(out.hasArray()){
            // 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(ByteBuffer in){

        // ok was there input held in the previous invocation of decodeLoop
        // that resulted in output in this invocation?
        // BEGIN android-changed
        in.position(in.position() + data[INPUT_OFFSET] + savedInputHeldLen - data[INPUT_HELD]);
        savedInputHeldLen = data[INPUT_HELD];
        // release reference to input array, which may not be ours
        input = null;
        // END android-changed
    }
}