abstract public int convert(byte[] input,
    int inStart,
    int inEnd,
    char[] output,
    int outStart,
    int outEnd) throws ConversionBufferFullException, MalformedInputException, UnknownCharacterException       Deprecated!
Converts an array of bytes containing characters in an external
encoding into an array of Unicode characters. 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 exception, 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.

 public char[] convertAll(byte[] input) throws MalformedInputException 
{
        reset();
        boolean savedSubMode = subMode;
        subMode = true;
        char[] output = new char[ getMaxCharsPerByte() * input.length ];
        try {
            int outputLength = convert( input, 0, input.length,
                                        output, 0, output.length );
            outputLength += flush( output, outputLength, output.length );
            char [] returnedOutput = new char[ outputLength ];
            System.arraycopy( output, 0, returnedOutput, 0, outputLength );
            return returnedOutput;
        }
        catch( ConversionBufferFullException e ) {
            //Not supposed to happen.  If it does, getMaxCharsPerByte() lied.
            throw new
                InternalError("this.getMaxCharsBerByte returned bad value");
        }
        catch( UnknownCharacterException e ) {
            // Not supposed to happen since we're in substitution mode.
            throw new InternalError();
        }
        finally {
            subMode = savedSubMode;
        }
}

Converts an array of bytes containing characters in an external encoding into an array of Unicode characters. Unlike convert, this method does not do incremental conversion. It assumes that the given input array contains all the characters to be converted. The state of the converter is reset at the beginning of this method and is left in the reset state on successful termination. The converter is not reset if an exception is thrown. This allows the caller to determine where the bad input was encountered by calling nextByteIndex.

This method uses substitution mode when performing the conversion. The method setSubstitutionChars may be used to determine what characters are substituted. Even though substitution mode is used, the state of the converter's substitution mode is not changed at the end of this method.

 abstract public int flush(char[] output,
    int outStart,
    int outEnd) throws ConversionBufferFullException, MalformedInputException       Deprecated!
Writes any remaining output to the output buffer and resets the
converter to its initial state.

 public int getBadInputLength() 
{
        return badInputLength;
}

Returns the length, in bytes, of the input which caused a MalformedInputException. Always refers to the last MalformedInputException thrown by the converter. If none have ever been thrown, returns 0.

 abstract public String getCharacterEncoding()       Deprecated!
Returns the character set id for the conversion

 public static ByteToCharConverter getConverter(String encoding) throws UnsupportedEncodingException 
{
        Object cvt;
        cvt = Converters.newConverter(Converters.BYTE_TO_CHAR, encoding);
        return (ByteToCharConverter)cvt;
}

Returns appropriate ByteToCharConverter subclass instance.

 public static ByteToCharConverter getDefault() 
{
                 
        Object cvt;
        cvt = Converters.newDefaultConverter(Converters.BYTE_TO_CHAR);
        return (ByteToCharConverter)cvt;
}

Create an instance of the default ByteToCharConverter subclass.

 public int getMaxCharsPerByte() 
{
        // Until UTF-16, this will do for every encoding
        return 1;
}

Returns the maximum number of characters needed to convert a byte. Useful for calculating the maximum output buffer size needed for a particular input buffer.

 public int nextByteIndex() 
{
        return byteOff;
}

Returns the index of the byte just past the last byte successfully converted by the previous call to convert.

 public int nextCharIndex() 
{
        return charOff;
}

Returns the index of the character just past the last character written by the previous call to convert.

 abstract public  void reset()       Deprecated!
Resets converter to its initial state.

 public  void setSubstitutionChars(char[] c) throws IllegalArgumentException 
{
        if( c.length  > getMaxCharsPerByte() ) {
            throw new IllegalArgumentException();
        }
        subChars = new char[ c.length ];
        System.arraycopy( c, 0, subChars, 0, c.length );
}

sets the substitution character to use

 public  void setSubstitutionMode(boolean doSub) 
{
        subMode = doSub;
}

Sets converter into substitution mode. In substitution mode, the converter will replace untranslatable characters in the source encoding with the substitution character set by setSubstitionChars. When not in substitution mode, the converter will throw an UnknownCharacterException when it encounters untranslatable input.

 public String toString() 
{
        return "ByteToCharConverter: " + getCharacterEncoding();
}

returns a string representation of the character conversion