Source for java.nio.charset.CharsetEncoder

   1: /* CharsetEncoder.java -- 
   2:    Copyright (C) 2002 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: package java.nio.charset;
  39: 
  40: import java.nio.ByteBuffer;
  41: import java.nio.CharBuffer;
  42: 
  43: /**
  44:  * @author Jesse Rosenstock
  45:  * @since 1.4
  46:  */
  47: public abstract class CharsetEncoder
  48: {
  49:   private static final int STATE_RESET   = 0;
  50:   private static final int STATE_CODING  = 1;
  51:   private static final int STATE_END     = 2;
  52:   private static final int STATE_FLUSHED = 3;
  53:   
  54:   private static final byte[] DEFAULT_REPLACEMENT = {(byte)'?'};
  55: 
  56:   private final Charset charset;
  57:   private final float averageBytesPerChar;
  58:   private final float maxBytesPerChar;
  59:   private byte[] replacement;
  60: 
  61:   private int state = STATE_RESET;
  62: 
  63:   private CodingErrorAction malformedInputAction
  64:     = CodingErrorAction.REPORT;
  65:   private CodingErrorAction unmappableCharacterAction
  66:     = CodingErrorAction.REPORT;
  67: 
  68:   protected CharsetEncoder (Charset cs, float averageBytesPerChar,
  69:                             float maxBytesPerChar)
  70:   {
  71:     this (cs, averageBytesPerChar, maxBytesPerChar, DEFAULT_REPLACEMENT);
  72:   }
  73: 
  74:   protected CharsetEncoder (Charset cs, float averageBytesPerChar, 
  75:                             float maxBytesPerChar, byte[] replacement)
  76:   {
  77:     if (averageBytesPerChar <= 0.0f)
  78:       throw new IllegalArgumentException ("Non-positive averageBytesPerChar");
  79:     if (maxBytesPerChar <= 0.0f)
  80:       throw new IllegalArgumentException ("Non-positive maxBytesPerChar");
  81: 
  82:     this.charset = cs;
  83:     this.averageBytesPerChar
  84:       = averageBytesPerChar;
  85:     this.maxBytesPerChar
  86:       = maxBytesPerChar;
  87:     this.replacement = replacement;
  88:     implReplaceWith (replacement);
  89:   }
  90:  
  91:   public final float averageBytesPerChar ()
  92:   {
  93:     return averageBytesPerChar;
  94:   }
  95: 
  96:   public boolean canEncode (char c)
  97:   {
  98:     CharBuffer cb = CharBuffer.allocate (1).put (c);
  99:     cb.flip ();
 100:     return canEncode (cb);
 101:   }
 102: 
 103:   public boolean canEncode (CharSequence cs)
 104:   {
 105:     CharBuffer cb;
 106:     if (cs instanceof CharBuffer)
 107:       cb = ((CharBuffer) cs).duplicate ();
 108:     else
 109:       cb = CharBuffer.wrap (cs);
 110:     return canEncode (cb);
 111:   }
 112: 
 113:   private boolean canEncode (CharBuffer cb)
 114:   {
 115:     // It is an error if a coding operation is "in progress"
 116:     // I take that to mean the state is not reset or flushed.
 117:     // XXX: check "in progress" everywhere
 118:     if (state == STATE_FLUSHED)
 119:       reset ();
 120:     else if (state != STATE_RESET)
 121:       throw new IllegalStateException ();
 122: 
 123:     CodingErrorAction oldMalformedInputAction = malformedInputAction;
 124:     CodingErrorAction oldUnmappableCharacterAction
 125:       = unmappableCharacterAction;
 126: 
 127:     try
 128:       {
 129:         if (oldMalformedInputAction != CodingErrorAction.REPORT)
 130:           onMalformedInput (CodingErrorAction.REPORT);
 131:         if (oldUnmappableCharacterAction != CodingErrorAction.REPORT)
 132:           onUnmappableCharacter (CodingErrorAction.REPORT);
 133:       }
 134:     catch (Exception e)
 135:       {
 136:         return false;
 137:       }
 138:     finally
 139:       {
 140:         if (oldMalformedInputAction != CodingErrorAction.REPORT)
 141:           onMalformedInput (oldMalformedInputAction);
 142:         if (oldUnmappableCharacterAction != CodingErrorAction.REPORT)
 143:           onUnmappableCharacter (oldUnmappableCharacterAction);
 144:       }
 145: 
 146:     return true;
 147:   }
 148: 
 149:   public final Charset charset ()
 150:   {
 151:     return charset;
 152:   }
 153: 
 154:   public final ByteBuffer encode (CharBuffer in)
 155:     throws CharacterCodingException
 156:   {
 157:     // XXX: Sun's Javadoc seems to contradict itself saying an
 158:     // IllegalStateException is thrown "if a decoding operation is already
 159:     // in progress" and also that "it resets this Encoder".
 160:     // Should we check to see that the state is reset, or should we
 161:     // call reset()?
 162:     if (state != STATE_RESET)
 163:       throw new IllegalStateException ();
 164: 
 165:     // REVIEW: Using max instead of average may allocate a very large
 166:     // buffer.  Maybe we should do something more efficient?
 167:     int remaining = in.remaining ();
 168:     int n = (int) (remaining * maxBytesPerChar ());
 169:     ByteBuffer out = ByteBuffer.allocate (n);
 170: 
 171:     if (remaining == 0)
 172:       {
 173:         state = STATE_FLUSHED;
 174:         return out;
 175:       }
 176: 
 177:     CoderResult cr = encode (in, out, true);
 178:     if (cr.isError ())
 179:       cr.throwException ();
 180: 
 181:     cr = flush (out);
 182:     if (cr.isError ())
 183:       cr.throwException ();
 184: 
 185:     out.flip ();
 186: 
 187:     // Unfortunately, resizing the actual bytebuffer array is required.
 188:     byte[] resized = new byte[out.remaining()];
 189:     out.get(resized);
 190:     return ByteBuffer.wrap(resized);
 191:   }
 192: 
 193:   public final CoderResult encode (CharBuffer in, ByteBuffer out,
 194:                                    boolean endOfInput)
 195:   {
 196:     int newState = endOfInput ? STATE_END : STATE_CODING;
 197:     // XXX: Need to check for "previous step was an invocation [not] of
 198:     // this method with a value of true for the endOfInput parameter but
 199:     // a return value indicating an incomplete decoding operation"
 200:     // XXX: We will not check the previous return value, just
 201:     // that the previous call passed true for endOfInput
 202:     if (state != STATE_RESET && state != STATE_CODING
 203:         && !(endOfInput && state == STATE_END))
 204:       throw new IllegalStateException ();
 205:     state = newState;
 206: 
 207:     for (;;)
 208:       {
 209:         CoderResult cr;
 210:         try
 211:           {
 212:             cr = encodeLoop (in, out);
 213:           }
 214:         catch (RuntimeException e)
 215:           {
 216:             throw new CoderMalfunctionError (e);
 217:           }
 218: 
 219:         if (cr.isOverflow ())
 220:           return cr;
 221: 
 222:         if (cr.isUnderflow ())
 223:           {
 224:             if (endOfInput && in.hasRemaining ())
 225:               cr = CoderResult.malformedForLength (in.remaining ());
 226:             else
 227:               return cr;
 228:           }
 229: 
 230:         CodingErrorAction action = cr.isMalformed ()
 231:                                      ? malformedInputAction
 232:                                      : unmappableCharacterAction;
 233: 
 234:         if (action == CodingErrorAction.REPORT)
 235:           return cr;
 236: 
 237:         if (action == CodingErrorAction.REPLACE)
 238:           {
 239:             if (out.remaining () < replacement.length)
 240:               return CoderResult.OVERFLOW;
 241:             out.put (replacement);
 242:           }
 243: 
 244:         in.position (in.position () + cr.length ());
 245:       }
 246:   }
 247: 
 248:   protected abstract CoderResult encodeLoop (CharBuffer in, ByteBuffer out);
 249: 
 250:   public final CoderResult flush (ByteBuffer out)
 251:   {
 252:     // It seems weird that you can flush after reset, but Sun's javadoc
 253:     // says an IllegalStateException is thrown "If the previous step of the
 254:     // current decoding operation was an invocation neither of the reset
 255:     // method nor ... of the three-argument encode method with a value of
 256:     // true for the endOfInput parameter."
 257:     // Further note that flush() only requires that there not be
 258:     // an IllegalStateException if the previous step was a call to
 259:     // encode with true as the last argument.  It does not require
 260:     // that the call succeeded.  encode() does require that it succeeded.
 261:     // XXX: test this to see if reality matches javadoc
 262:     if (state != STATE_RESET && state != STATE_END)
 263:       throw new IllegalStateException ();
 264: 
 265:     state = STATE_FLUSHED;
 266:     return implFlush (out);
 267:   }
 268: 
 269:   protected CoderResult implFlush (ByteBuffer out)
 270:   {
 271:     return CoderResult.UNDERFLOW;
 272:   }
 273: 
 274:   protected void implOnMalformedInput (CodingErrorAction newAction)
 275:   {
 276:     // default implementation does nothing
 277:   }
 278: 
 279:   protected void implOnUnmappableCharacter (CodingErrorAction newAction)
 280:   {
 281:     // default implementation does nothing
 282:   }
 283: 
 284:   protected void implReplaceWith (byte[] newReplacement)
 285:   {
 286:     // default implementation does nothing
 287:   }
 288: 
 289:   protected void implReset ()
 290:   {
 291:     // default implementation does nothing
 292:   }
 293: 
 294:   public boolean isLegalReplacement (byte[] replacement)
 295:   {
 296:     // TODO: cache the decoder
 297:     // error actions will be REPORT after construction
 298:     CharsetDecoder decoder = charset.newDecoder ();
 299:     ByteBuffer bb = ByteBuffer.wrap (replacement);
 300:     CharBuffer cb
 301:       = CharBuffer.allocate ((int) (replacement.length
 302:                                     * decoder.maxCharsPerByte ()));
 303:     return !decoder.decode (bb, cb, true).isError ();
 304:   }
 305: 
 306:   public CodingErrorAction malformedInputAction ()
 307:   {
 308:     return malformedInputAction;
 309:   }
 310: 
 311:   public final float maxBytesPerChar ()
 312:   {
 313:     return maxBytesPerChar;
 314:   }
 315: 
 316:   public final CharsetEncoder onMalformedInput (CodingErrorAction newAction)
 317:   {
 318:     if (newAction == null)
 319:       throw new IllegalArgumentException ("Null action");
 320: 
 321:     malformedInputAction = newAction;
 322:     implOnMalformedInput (newAction);
 323:     return this;
 324:   }
 325: 
 326:   public CodingErrorAction unmappableCharacterAction ()
 327:   {
 328:     return unmappableCharacterAction;
 329:   }
 330: 
 331:   public final CharsetEncoder onUnmappableCharacter
 332:     (CodingErrorAction newAction)
 333:   {
 334:     if (newAction == null)
 335:       throw new IllegalArgumentException ("Null action");
 336: 
 337:     unmappableCharacterAction = newAction;
 338:     implOnUnmappableCharacter (newAction);
 339:     return this;
 340:   }
 341: 
 342:   public final byte[] replacement ()
 343:   {
 344:     return replacement;
 345:   }
 346: 
 347:   public final CharsetEncoder replaceWith (byte[] newReplacement)
 348:   {
 349:     if (newReplacement == null)
 350:       throw new IllegalArgumentException ("Null replacement");
 351:     if (newReplacement.length == 0)
 352:       throw new IllegalArgumentException ("Empty replacement");
 353:     // XXX: what about maxBytesPerChar?
 354: 
 355:       if (!isLegalReplacement (newReplacement))
 356:         throw new IllegalArgumentException ("Illegal replacement");
 357: 
 358:     this.replacement = newReplacement;
 359:     implReplaceWith (newReplacement);
 360:     return this;
 361:   }
 362: 
 363:   public final CharsetEncoder reset ()
 364:   {
 365:     state = STATE_RESET;
 366:     implReset ();
 367:     return this;
 368:   }
 369: }