/*

 * Copyright 2000-2006 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

#warn This file is preprocessed before being compiled

package java.nio.charset;

import java.nio.Buffer;

import java.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.BufferOverflowException;

import java.nio.BufferUnderflowException;

import java.lang.ref.WeakReference;

import java.nio.charset.CoderMalfunctionError;                  // javadoc

/**

 * An engine that can transform a sequence of $itypesPhrase$ into a sequence of

 * $otypesPhrase$.

 *

 * <a name="steps">

 *

 * <p> The input $itype$ sequence is provided in a $itype$ buffer or a series

 * of such buffers.  The output $otype$ sequence is written to a $otype$ buffer

 * or a series of such buffers.  $A$ $coder$ should always be used by making

 * the following sequence of method invocations, hereinafter referred to as $a$

 * <i>$coding$ operation</i>:

 *

 * <ol>

 *

 *   <li><p> Reset the $coder$ via the {@link #reset reset} method, unless it

 *   has not been used before; </p></li>

 *

 *   <li><p> Invoke the {@link #$code$ $code$} method zero or more times, as

 *   long as additional input may be available, passing <tt>false</tt> for the

 *   <tt>endOfInput</tt> argument and filling the input buffer and flushing the

 *   output buffer between invocations; </p></li>

 *

 *   <li><p> Invoke the {@link #$code$ $code$} method one final time, passing

 *   <tt>true</tt> for the <tt>endOfInput</tt> argument; and then </p></li>

 *

 *   <li><p> Invoke the {@link #flush flush} method so that the $coder$ can

 *   flush any internal state to the output buffer. </p></li>

 *

 * </ol>

 *

 * Each invocation of the {@link #$code$ $code$} method will $code$ as many

 * $itype$s as possible from the input buffer, writing the resulting $otype$s

 * to the output buffer.  The {@link #$code$ $code$} method returns when more

 * input is required, when there is not enough room in the output buffer, or

 * when $a$ $coding$ error has occurred.  In each case a {@link CoderResult}

 * object is returned to describe the reason for termination.  An invoker can

 * examine this object and fill the input buffer, flush the output buffer, or

 * attempt to recover from $a$ $coding$ error, as appropriate, and try again.

 *

 * <a name="ce">

 *

 * <p> There are two general types of $coding$ errors.  If the input $itype$

 * sequence is $notLegal$ then the input is considered <i>malformed</i>.  If

 * the input $itype$ sequence is legal but cannot be mapped to a valid

 * $outSequence$ then an <i>unmappable character</i> has been encountered.

 *

 * <a name="cae">

 *

 * <p> How $a$ $coding$ error is handled depends upon the action requested for

 * that type of error, which is described by an instance of the {@link

 * CodingErrorAction} class.  The possible error actions are to {@link

 * CodingErrorAction#IGNORE </code>ignore<code>} the erroneous input, {@link

 * CodingErrorAction#REPORT </code>report<code>} the error to the invoker via

 * the returned {@link CoderResult} object, or {@link CodingErrorAction#REPLACE

 * </code>replace<code>} the erroneous input with the current value of the

 * replacement $replTypeName$.  The replacement

 *

#if[encoder]

 * is initially set to the $coder$'s default replacement, which often

 * (but not always) has the initial value $defaultReplName$;

#end[encoder]

#if[decoder]

 * has the initial value $defaultReplName$;

#end[decoder]

 *

 * its value may be changed via the {@link #replaceWith($replFQType$)

 * replaceWith} method.

 *

 * <p> The default action for malformed-input and unmappable-character errors

 * is to {@link CodingErrorAction#REPORT </code>report<code>} them.  The

 * malformed-input error action may be changed via the {@link

 * #onMalformedInput(CodingErrorAction) onMalformedInput} method; the

 * unmappable-character action may be changed via the {@link

 * #onUnmappableCharacter(CodingErrorAction) onUnmappableCharacter} method.

 *

 * <p> This class is designed to handle many of the details of the $coding$

 * process, including the implementation of error actions.  $A$ $coder$ for a

 * specific charset, which is a concrete subclass of this class, need only

 * implement the abstract {@link #$code$Loop $code$Loop} method, which

 * encapsulates the basic $coding$ loop.  A subclass that maintains internal

 * state should, additionally, override the {@link #implFlush implFlush} and

 * {@link #implReset implReset} methods.

 *

 * <p> Instances of this class are not safe for use by multiple concurrent

 * threads.  </p>

 *

 *

 * @author Mark Reinhold

 * @author JSR-51 Expert Group

 * @since 1.4

 *

 * @see ByteBuffer

 * @see CharBuffer

 * @see Charset

 * @see Charset$OtherCoder$

 */

public abstract class Charset$Coder$ {

    private final Charset charset;

    private final float average$ItypesPerOtype$;

    private final float max$ItypesPerOtype$;

    private $replType$ replacement;

    private CodingErrorAction malformedInputAction

        = CodingErrorAction.REPORT;

    private CodingErrorAction unmappableCharacterAction

        = CodingErrorAction.REPORT;

    // Internal states

    //

    private static final int ST_RESET   = 0;

    private static final int ST_CODING  = 1;

    private static final int ST_END     = 2;

    private static final int ST_FLUSHED = 3;

    private int state = ST_RESET;

    private static String stateNames[]

        = { "RESET", "CODING", "CODING_END", "FLUSHED" };

    /**

     * Initializes a new $coder$.  The new $coder$ will have the given

     * $otypes-per-itype$ and replacement values. </p>

     *

     * @param  average$ItypesPerOtype$

     *         A positive float value indicating the expected number of

     *         $otype$s that will be produced for each input $itype$

     *

     * @param  max$ItypesPerOtype$

     *         A positive float value indicating the maximum number of

     *         $otype$s that will be produced for each input $itype$

     *

     * @param  replacement

     *         The initial replacement; must not be <tt>null</tt>, must have

     *         non-zero length, must not be longer than max$ItypesPerOtype$,

     *         and must be {@link #isLegalReplacement </code>legal<code>}

     *

     * @throws  IllegalArgumentException

     *          If the preconditions on the parameters do not hold

     */

    {#if[encoder]?protected:private}

    Charset$Coder$(Charset cs,

                   float average$ItypesPerOtype$,

                   float max$ItypesPerOtype$,

                   $replType$ replacement)

    {

        this.charset = cs;

        if (average$ItypesPerOtype$ <= 0.0f)

            throw new IllegalArgumentException("Non-positive "

                                               + "average$ItypesPerOtype$");

        if (max$ItypesPerOtype$ <= 0.0f)

            throw new IllegalArgumentException("Non-positive "

                                               + "max$ItypesPerOtype$");

        if (!Charset.atBugLevel("1.4")) {

            if (average$ItypesPerOtype$ > max$ItypesPerOtype$)

                throw new IllegalArgumentException("average$ItypesPerOtype$"

                                                   + " exceeds "

                                                   + "max$ItypesPerOtype$");

        }

        this.replacement = replacement;

        this.average$ItypesPerOtype$ = average$ItypesPerOtype$;

        this.max$ItypesPerOtype$ = max$ItypesPerOtype$;

        replaceWith(replacement);

    }

    /**

     * Initializes a new $coder$.  The new $coder$ will have the given

     * $otypes-per-itype$ values and its replacement will be the

     * $replTypeName$ $defaultReplName$. </p>

     *

     * @param  average$ItypesPerOtype$

     *         A positive float value indicating the expected number of

     *         $otype$s that will be produced for each input $itype$

     *

     * @param  max$ItypesPerOtype$

     *         A positive float value indicating the maximum number of

     *         $otype$s that will be produced for each input $itype$

     *

     * @throws  IllegalArgumentException

     *          If the preconditions on the parameters do not hold

     */

    protected Charset$Coder$(Charset cs,

                             float average$ItypesPerOtype$,

                             float max$ItypesPerOtype$)

    {

        this(cs,

             average$ItypesPerOtype$, max$ItypesPerOtype$,

             $defaultRepl$);

    }

    /**

     * Returns the charset that created this $coder$.  </p>

     *

     * @return  This $coder$'s charset

     */

    public final Charset charset() {

        return charset;

    }

    /**

     * Returns this $coder$'s replacement value. </p>

     *

     * @return  This $coder$'s current replacement,

     *          which is never <tt>null</tt> and is never empty

     */

    public final $replType$ replacement() {

        return replacement;

    }

    /**

     * Changes this $coder$'s replacement value.

     *

     * <p> This method invokes the {@link #implReplaceWith implReplaceWith}

     * method, passing the new replacement, after checking that the new

     * replacement is acceptable.  </p>

     *

     * @param  newReplacement

     *

#if[decoder]

     *         The new replacement; must not be <tt>null</tt>

     *         and must have non-zero length

#end[decoder]

#if[encoder]

     *         The new replacement; must not be <tt>null</tt>, must have

     *         non-zero length, must not be longer than the value returned by

     *         the {@link #max$ItypesPerOtype$() max$ItypesPerOtype$} method, and

     *         must be {@link #isLegalReplacement </code>legal<code>}

#end[encoder]

     *

     * @return  This $coder$

     *

     * @throws  IllegalArgumentException

     *          If the preconditions on the parameter do not hold

     */

    public final Charset$Coder$ replaceWith($replType$ newReplacement) {

        if (newReplacement == null)

            throw new IllegalArgumentException("Null replacement");

        int len = newReplacement.$replLength$;

        if (len == 0)

            throw new IllegalArgumentException("Empty replacement");

        if (len > max$ItypesPerOtype$)

            throw new IllegalArgumentException("Replacement too long");

#if[encoder]

        if (!isLegalReplacement(newReplacement))

            throw new IllegalArgumentException("Illegal replacement");

#end[encoder]

        this.replacement = newReplacement;

        implReplaceWith(newReplacement);

        return this;

    }

    /**

     * Reports a change to this $coder$'s replacement value.

     *

     * <p> The default implementation of this method does nothing.  This method

     * should be overridden by $coder$s that require notification of changes to

     * the replacement.  </p>

     *

     * @param  newReplacement

     */

    protected void implReplaceWith($replType$ newReplacement) {

    }

#if[encoder]

    private WeakReference cachedDecoder = null;

    /**

     * Tells whether or not the given byte array is a legal replacement value

     * for this encoder.

     *

     * <p> A replacement is legal if, and only if, it is a legal sequence of

     * bytes in this encoder's charset; that is, it must be possible to decode

     * the replacement into one or more sixteen-bit Unicode characters.

     *

     * <p> The default implementation of this method is not very efficient; it

     * should generally be overridden to improve performance.  </p>

     *

     * @param  repl  The byte array to be tested

     *

     * @return  <tt>true</tt> if, and only if, the given byte array

     *          is a legal replacement value for this encoder

     */

    public boolean isLegalReplacement(byte[] repl) {

        WeakReference wr = cachedDecoder;

        CharsetDecoder dec = null;

        if ((wr == null) || ((dec = (CharsetDecoder)wr.get()) == null)) {

            dec = charset().newDecoder();

            dec.onMalformedInput(CodingErrorAction.REPORT);

            dec.onUnmappableCharacter(CodingErrorAction.REPORT);

            cachedDecoder = new WeakReference(dec);

        } else {

            dec.reset();

        }

        ByteBuffer bb = ByteBuffer.wrap(repl);

        CharBuffer cb = CharBuffer.allocate((int)(bb.remaining()

                                                  * dec.maxCharsPerByte()));

        CoderResult cr = dec.decode(bb, cb, true);

        return !cr.isError();

    }

#end[encoder]

    /**

     * Returns this $coder$'s current action for malformed-input errors.  </p>

     *

     * @return The current malformed-input action, which is never <tt>null</tt>

     */

    public CodingErrorAction malformedInputAction() {

        return malformedInputAction;

    }

    /**

     * Changes this $coder$'s action for malformed-input errors.  </p>

     *

     * <p> This method invokes the {@link #implOnMalformedInput

     * implOnMalformedInput} method, passing the new action.  </p>

     *

     * @param  newAction  The new action; must not be <tt>null</tt>

     *

     * @return  This $coder$

     *

     * @throws IllegalArgumentException

     *         If the precondition on the parameter does not hold

     */

    public final Charset$Coder$ onMalformedInput(CodingErrorAction newAction) {

        if (newAction == null)

            throw new IllegalArgumentException("Null action");

        malformedInputAction = newAction;

        implOnMalformedInput(newAction);

        return this;

    }

    /**

     * Reports a change to this $coder$'s malformed-input action.

     *

     * <p> The default implementation of this method does nothing.  This method

     * should be overridden by $coder$s that require notification of changes to

     * the malformed-input action.  </p>

     */

    protected void implOnMalformedInput(CodingErrorAction newAction) { }

    /**

     * Returns this $coder$'s current action for unmappable-character errors.

     * </p>

     *

     * @return The current unmappable-character action, which is never

     *         <tt>null</tt>

     */

    public CodingErrorAction unmappableCharacterAction() {

        return unmappableCharacterAction;

    }

    /**

     * Changes this $coder$'s action for unmappable-character errors.

     *

     * <p> This method invokes the {@link #implOnUnmappableCharacter

     * implOnUnmappableCharacter} method, passing the new action.  </p>

     *

     * @param  newAction  The new action; must not be <tt>null</tt>

     *

     * @return  This $coder$

     *

     * @throws IllegalArgumentException

     *         If the precondition on the parameter does not hold

     */

    public final Charset$Coder$ onUnmappableCharacter(CodingErrorAction

                                                      newAction)

    {

        if (newAction == null)

            throw new IllegalArgumentException("Null action");

        unmappableCharacterAction = newAction;

        implOnUnmappableCharacter(newAction);

        return this;

    }

    /**

     * Reports a change to this $coder$'s unmappable-character action.

     *

     * <p> The default implementation of this method does nothing.  This method

     * should be overridden by $coder$s that require notification of changes to

     * the unmappable-character action.  </p>

     */

    protected void implOnUnmappableCharacter(CodingErrorAction newAction) { }

    /**

     * Returns the average number of $otype$s that will be produced for each

     * $itype$ of input.  This heuristic value may be used to estimate the size

     * of the output buffer required for a given input sequence. </p>

     *

     * @return  The average number of $otype$s produced

     *          per $itype$ of input

     */

    public final float average$ItypesPerOtype$() {

        return average$ItypesPerOtype$;

    }

    /**

     * Returns the maximum number of $otype$s that will be produced for each

     * $itype$ of input.  This value may be used to compute the worst-case size

     * of the output buffer required for a given input sequence. </p>

     *

     * @return  The maximum number of $otype$s that will be produced per

     *          $itype$ of input

     */

    public final float max$ItypesPerOtype$() {

        return max$ItypesPerOtype$;

    }

    /**

     * $Code$s as many $itype$s as possible from the given input buffer,

     * writing the results to the given output buffer.

     *

     * <p> The buffers are read from, and written to, starting at their current

     * positions.  At most {@link Buffer#remaining in.remaining()} $itype$s

     * will be read and at most {@link Buffer#remaining out.remaining()}

     * $otype$s will be written.  The buffers' positions will be advanced to

     * reflect the $itype$s read and the $otype$s written, but their marks and

     * limits will not be modified.

     *

     * <p> In addition to reading $itype$s from the input buffer and writing

     * $otype$s to the output buffer, this method returns a {@link CoderResult}

     * object to describe its reason for termination:

     *

     * <ul>

     *

     *   <li><p> {@link CoderResult#UNDERFLOW} indicates that as much of the

     *   input buffer as possible has been $code$d.  If there is no further

     *   input then the invoker can proceed to the next step of the

     *   <a href="#steps">$coding$ operation</a>.  Otherwise this method

     *   should be invoked again with further input.  </p></li>

     *

     *   <li><p> {@link CoderResult#OVERFLOW} indicates that there is

     *   insufficient space in the output buffer to $code$ any more $itype$s.

     *   This method should be invoked again with an output buffer that has

     *   more {@linkplain Buffer#remaining remaining} $otype$s. This is

     *   typically done by draining any $code$d $otype$s from the output

     *   buffer.  </p></li>

     *

     *   <li><p> A {@link CoderResult#malformedForLength

     *   </code>malformed-input<code>} result indicates that a malformed-input

     *   error has been detected.  The malformed $itype$s begin at the input

     *   buffer's (possibly incremented) position; the number of malformed

     *   $itype$s may be determined by invoking the result object's {@link

     *   CoderResult#length() length} method.  This case applies only if the

     *   {@link #onMalformedInput </code>malformed action<code>} of this $coder$

     *   is {@link CodingErrorAction#REPORT}; otherwise the malformed input

     *   will be ignored or replaced, as requested.  </p></li>

     *

     *   <li><p> An {@link CoderResult#unmappableForLength

     *   </code>unmappable-character<code>} result indicates that an

     *   unmappable-character error has been detected.  The $itype$s that

     *   $code$ the unmappable character begin at the input buffer's (possibly

     *   incremented) position; the number of such $itype$s may be determined

     *   by invoking the result object's {@link CoderResult#length() length}

     *   method.  This case applies only if the {@link #onUnmappableCharacter

     *   </code>unmappable action<code>} of this $coder$ is {@link

     *   CodingErrorAction#REPORT}; otherwise the unmappable character will be

     *   ignored or replaced, as requested.  </p></li>

     *

     * </ul>

     *

     * In any case, if this method is to be reinvoked in the same $coding$

     * operation then care should be taken to preserve any $itype$s remaining

     * in the input buffer so that they are available to the next invocation.

     *

     * <p> The <tt>endOfInput</tt> parameter advises this method as to whether

     * the invoker can provide further input beyond that contained in the given

     * input buffer.  If there is a possibility of providing additional input

     * then the invoker should pass <tt>false</tt> for this parameter; if there

     * is no possibility of providing further input then the invoker should

     * pass <tt>true</tt>.  It is not erroneous, and in fact it is quite

     * common, to pass <tt>false</tt> in one invocation and later discover that

     * no further input was actually available.  It is critical, however, that

     * the final invocation of this method in a sequence of invocations always

     * pass <tt>true</tt> so that any remaining un$code$d input will be treated

     * as being malformed.

     *

     * <p> This method works by invoking the {@link #$code$Loop $code$Loop}

     * method, interpreting its results, handling error conditions, and

     * reinvoking it as necessary.  </p>

     *

     *

     * @param  in

     *         The input $itype$ buffer

     *

     * @param  out

     *         The output $otype$ buffer

     *