protected CharsetEncoder(Charset cs,
    float averageBytesPerChar,
    float maxBytesPerChar) 
{
       
    this (cs, averageBytesPerChar, maxBytesPerChar, DEFAULT_REPLACEMENT);
}

 protected CharsetEncoder(Charset cs,
    float averageBytesPerChar,
    float maxBytesPerChar,
    byte[] replacement) 
{
    if (averageBytesPerChar < = 0.0f)
      throw new IllegalArgumentException ("Non-positive averageBytesPerChar");
    if (maxBytesPerChar < = 0.0f)
      throw new IllegalArgumentException ("Non-positive maxBytesPerChar");
    this.charset = cs;
    this.averageBytesPerChar
      = averageBytesPerChar;
    this.maxBytesPerChar
      = maxBytesPerChar;
    this.replacement = replacement;
    implReplaceWith (replacement);
}

 public final float averageBytesPerChar() 
{
    return averageBytesPerChar;
}

 public boolean canEncode(char c) 
{
    CharBuffer cb = CharBuffer.allocate (1).put (c);
    cb.flip ();
    return canEncode (cb);
}

 public boolean canEncode(CharSequence cs) 
{
    CharBuffer cb;
    if (cs instanceof CharBuffer)
      cb = ((CharBuffer) cs).duplicate ();
    else
      cb = CharBuffer.wrap (cs);
    return canEncode (cb);
}

 public final Charset charset() 
{
    return charset;
}

 public final ByteBuffer encode(CharBuffer in) throws CharacterCodingException 
{
    // XXX: Sun's Javadoc seems to contradict itself saying an
    // IllegalStateException is thrown "if a decoding operation is already
    // in progress" and also that "it resets this Encoder".
    // Should we check to see that the state is reset, or should we
    // call reset()?
    if (state != STATE_RESET)
      throw new IllegalStateException ();
    // REVIEW: Using max instead of average may allocate a very large
    // buffer.  Maybe we should do something more efficient?
    int remaining = in.remaining ();
    int n = (int) (remaining * maxBytesPerChar ());
    ByteBuffer out = ByteBuffer.allocate (n);
    if (remaining == 0)
      {
        state = STATE_FLUSHED;
        return out;
      }
    CoderResult cr = encode (in, out, true);
    if (cr.isError ())
      cr.throwException ();
    cr = flush (out);
    if (cr.isError ())
      cr.throwException ();
    out.flip ();
    // Unfortunately, resizing the actual bytebuffer array is required.
    byte[] resized = new byte[out.remaining()];
    out.get(resized);
    return ByteBuffer.wrap(resized);
}

 public final CoderResult encode(CharBuffer in,
    ByteBuffer out,
    boolean endOfInput) 
{
    int newState = endOfInput ? STATE_END : STATE_CODING;
    // XXX: Need to check for "previous step was an invocation [not] of
    // this method with a value of true for the endOfInput parameter but
    // a return value indicating an incomplete decoding operation"
    // XXX: We will not check the previous return value, just
    // that the previous call passed true for endOfInput
    if (state != STATE_RESET && state != STATE_CODING
        && !(endOfInput && state == STATE_END))
      throw new IllegalStateException ();
    state = newState;
    for (;;)
      {
        CoderResult cr;
        try
          {
            cr = encodeLoop (in, out);
          }
        catch (RuntimeException e)
          {
            throw new CoderMalfunctionError (e);
          }
        if (cr.isOverflow ())
          return cr;
        if (cr.isUnderflow ())
          {
            if (endOfInput && in.hasRemaining ())
              cr = CoderResult.malformedForLength (in.remaining ());
            else
              return cr;
          }
        CodingErrorAction action = cr.isMalformed ()
                                     ? malformedInputAction
                                     : unmappableCharacterAction;
        if (action == CodingErrorAction.REPORT)
          return cr;
        if (action == CodingErrorAction.REPLACE)
          {
            if (out.remaining () <  replacement.length)
              return CoderResult.OVERFLOW;
            out.put (replacement);
          }
        in.position (in.position () + cr.length ());
      }
}

 abstract protected CoderResult encodeLoop(CharBuffer in,
    ByteBuffer out)

 public final CoderResult flush(ByteBuffer out) 
{
    // It seems weird that you can flush after reset, but Sun's javadoc
    // says an IllegalStateException is thrown "If the previous step of the
    // current decoding operation was an invocation neither of the reset
    // method nor ... of the three-argument encode method with a value of
    // true for the endOfInput parameter."
    // Further note that flush() only requires that there not be
    // an IllegalStateException if the previous step was a call to
    // encode with true as the last argument.  It does not require
    // that the call succeeded.  encode() does require that it succeeded.
    // XXX: test this to see if reality matches javadoc
    if (state != STATE_RESET && state != STATE_END)
      throw new IllegalStateException ();
    state = STATE_FLUSHED;
    return implFlush (out);
}

 protected CoderResult implFlush(ByteBuffer out) 
{
    return CoderResult.UNDERFLOW;
}

 protected  void implOnMalformedInput(CodingErrorAction newAction) 
{
    // default implementation does nothing
}

 protected  void implOnUnmappableCharacter(CodingErrorAction newAction) 
{
    // default implementation does nothing
}

 protected  void implReplaceWith(byte[] newReplacement) 
{
    // default implementation does nothing
}

 protected  void implReset() 
{
    // default implementation does nothing
}

 public boolean isLegalReplacement(byte[] replacement) 
{
    // TODO: cache the decoder
    // error actions will be REPORT after construction
    CharsetDecoder decoder = charset.newDecoder ();
    ByteBuffer bb = ByteBuffer.wrap (replacement);
    CharBuffer cb
      = CharBuffer.allocate ((int) (replacement.length
                                    * decoder.maxCharsPerByte ()));
    return !decoder.decode (bb, cb, true).isError ();
}

 public CodingErrorAction malformedInputAction() 
{
    return malformedInputAction;
}

 public final float maxBytesPerChar() 
{
    return maxBytesPerChar;
}

 public final CharsetEncoder onMalformedInput(CodingErrorAction newAction) 
{
    if (newAction == null)
      throw new IllegalArgumentException ("Null action");
    malformedInputAction = newAction;
    implOnMalformedInput (newAction);
    return this;
}

 public final CharsetEncoder onUnmappableCharacter(CodingErrorAction newAction) 
{
    if (newAction == null)
      throw new IllegalArgumentException ("Null action");
    unmappableCharacterAction = newAction;
    implOnUnmappableCharacter (newAction);
    return this;
}

 public final CharsetEncoder replaceWith(byte[] newReplacement) 
{
    if (newReplacement == null)
      throw new IllegalArgumentException ("Null replacement");
    if (newReplacement.length == 0)
      throw new IllegalArgumentException ("Empty replacement");
    // XXX: what about maxBytesPerChar?
      if (!isLegalReplacement (newReplacement))
        throw new IllegalArgumentException ("Illegal replacement");
    this.replacement = newReplacement;
    implReplaceWith (newReplacement);
    return this;
}

 public final byte[] replacement() 
{
    return replacement;
}

 public final CharsetEncoder reset() 
{
    state = STATE_RESET;
    implReset ();
    return this;
}

 public CodingErrorAction unmappableCharacterAction() 
{
    return unmappableCharacterAction;
}