New smart class FastCharset

[Ulf Zibis]

Martin, Sherman, Dalibor,

I'm proud to present a new patch, which could dramatically improve the 
memory-footprint and instantiation performance of charsets usage, so 
Charset instances could directly be hold in cache.
The footprint of the code is again little smaller than before.
Provided patch fixes:
6862158 Make sun.nio.cs.* charset objects light-weight
6850361 Avoid 2-step lookup in sun.nio.cs charset providers
6790402 Speed-up FastCharsetProvider
6795536 No system start for file.encoding=x-SJIS_0213
6792535 NoClassDefFoundError after failed new StreamEncoder(out, lock, 
Charset.defaultCh
6850337 Hasher.java interprets given option value badly
6853677 Provide names of supported charsets -> now superfluous

Do you like to review and/or sponsor my CR ?

See:
https://bugs.openjdk.java.net/show_bug.cgi?id=100098

As the code of the new FastCharset is so tiny and flexible, I paste it 
here directly...
Using it's De/Encoders in general would make interfaces ArrayDecoder ad 
ArrayEncoder superfluous.
For charsets with huge mappings it is foreseen to split class Mapping 
for decoders and encoders.

Thanks,

Ulf



package sun.nio.cs;

import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.UnsupportedCharsetException;

class FastCharset extends Charset implements HistoricallyNamedCharset {

   private final String pkgName;
   final String mappingClsName; // package private for 
ExternalCharsetProvider
   private transient Decoder decoder;
   private transient Encoder encoder;

   FastCharset(String className, String canonicalName, String... aliases) {
       super(canonicalName, aliases);
       pkgName = getClass().getPackage().getName();
       mappingClsName = className;
   }
   FastCharset(String packageName, String className, String 
canonicalName, String[] aliases) {
       super(canonicalName, aliases);
       pkgName = packageName;
       mappingClsName = className;
   }

   public String historicalName() {
       return mapping().historicalName;
   }

   public boolean contains(Charset cs) {
       return cs.name().equals(name()) ||
               mapping().isASCII && cs.name().equals("US-ASCII");
   }

   public Decoder newDecoder() {
       return decoder().clone();
   }

   public Encoder newEncoder() {
       if (encoder == null)
           encoder = decoder().newEncoder();
       return encoder.clone();
   }

   private final Decoder decoder() {
       if (decoder == null)
           decoder = mapping().newDecoder(this);
       return decoder;
   }

   final Mapping mapping() {
       try {
           return ((Class<Mapping>) Class.forName(
               pkgName+'.'+mappingClsName)).newInstance();
       } catch (ClassNotFoundException ex) {
           throw new NoClassDefFoundError(ex.getMessage());
       } catch (ReflectiveOperationException ex) {
           Error error = new InternalError("Can't instantiate class 
["+pkgName+'.'+mappingClsName+"]");
           error.initCause(ex);
           throw error;
       }
   }


   static abstract class Decoder<M extends Mapping>
           extends CharsetDecoder implements Cloneable, ArrayDecoder {

       M mapping;

       Decoder(FastCharset cs, M mapping,
               float averageCharsPerByte, float maxCharsPerByte) {
           super(cs, 1.0f, 1.0f);
           this.mapping = mapping;
       }

       protected Decoder<M> clone() {
           try {
               return (Decoder<M>)super.clone();
           } catch (CloneNotSupportedException ex) {
               return null;
           }
       }

       Encoder<M> newEncoder() {
           return mapping.newEncoder(this);
       }
   }


   static abstract class Encoder<M extends Mapping>
           extends CharsetEncoder implements Cloneable, ArrayEncoder {

       M mapping;

       Encoder(Decoder<M> decoder,
                  float averageBytesPerChar, float maxBytesPerChar) {
           super(decoder.charset(), 1.0f, 1.0f);
           mapping = decoder.mapping;
           mapping.initEncoderMaps();
       }

       protected Encoder<M> clone() {
           try {
               return (Encoder<M>)super.clone();
           } catch (CloneNotSupportedException ex) {
               return null;
           }
       }
   }
}