Subversion Repositories openrisc

/* Provider.java --

   Copyright (C) 2002, 2005, 2006 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2, or (at your option)

any later version.

GNU Classpath 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 for more details.

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

along with GNU Classpath; see the file COPYING.  If not, write to the

Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301 USA.

Linking this library statically or dynamically with other modules is

making a combined work based on this library.  Thus, the terms and

conditions of the GNU General Public License cover the whole

combination.

As a special exception, the copyright holders of this library give you

permission to link this library with independent modules to produce an

executable, regardless of the license terms of these independent

modules, and to copy and distribute the resulting executable under

terms of your choice, provided that you also meet, for each linked

independent module, the terms and conditions of the license of that

module.  An independent module is a module which is not derived from

or based on this library.  If you modify this library, you may extend

this exception to your version of the library, but you are not

obligated to do so.  If you do not wish to do so, delete this

exception statement from your version. */

package gnu.java.nio.charset;

import java.nio.charset.Charset;

import java.nio.charset.spi.CharsetProvider;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

/**

 * Charset provider for the required charsets.  Used by

 * {@link Charset#charsetForName} and * {@link Charset#availableCharsets}.

 *

 * Note: This class is a privileged class, because it can be instantiated without

 * requiring the RuntimePermission("charsetProvider"). There is a check in

 * java.nio.charset.spi.CharsetProvider to skip the security check if the provider

 * is an instance of this class.

 *

 * @author Jesse Rosenstock

 * @author Robert Schuster (thebohemian@gmx.net)

 * @see Charset

 */

public final class Provider extends CharsetProvider

{

  private static Provider singleton;

  /**

   * Map from charset name to charset canonical name. The strings

   * are all lower-case to allow case-insensitive retrieval of

   * Charset instances.

   */

  private final HashMap<String, String> canonicalNames;

  /**

   * Map from lower-case canonical name to Charset.

   * TODO: We may want to use soft references.  We would then need to keep

   * track of the class name to regenerate the object.

   */

  private final HashMap<String, Charset> charsets;

  /**

   * We don't load all available charsets at the start

   */

  private boolean extendedLoaded;

  // Package private to avoid an accessor method in PrivilegedAction below.

  Provider ()

  {

    extendedLoaded = false;

    canonicalNames = new HashMap<String,String> ();

    charsets = new HashMap<String,Charset> ();

    // US-ASCII aka ISO646-US

    addCharset (new US_ASCII ());

    // ISO-8859-1 aka ISO-LATIN-1

    addCharset (new ISO_8859_1 ());

    // UTF-8

    addCharset (new UTF_8 ());

    // UTF-16BE

    addCharset (new UTF_16BE ());

    // UTF-16LE

    addCharset (new UTF_16LE ());

    // UTF-16

    addCharset (new UTF_16 ());

    // UTF-16LE (marked)

    addCharset (new UnicodeLittle ());

    // Windows-1250 aka cp-1250 (East European)

    addCharset (new Windows1250 ());

    // Windows-1251 (Cyrillic)

    addCharset (new Windows1251 ());

    // Windows-1252 aka cp-1252 (Latin-1)

    addCharset (new Windows1252 ());

    // Windows-1253 (Greek)

    addCharset (new Windows1253 ());

    // Windows-1254 (Turkish)

    addCharset (new Windows1254 ());

    // Windows-1257 (Baltic)

    addCharset (new Windows1257 ());

    // ISO-8859-2 aka ISO-LATIN-2

    addCharset (new ISO_8859_2 ());

    // ISO-8859-4 aka ISO-LATIN-4

    addCharset (new ISO_8859_4 ());

    // ISO-8859-5 (Cyrillic)

    addCharset (new ISO_8859_5 ());

    // ISO-8859-7 (Greek)

    addCharset (new ISO_8859_7 ());

    // ISO-8859-9 aka ISO-LATIN-5

    addCharset (new ISO_8859_9 ());

    // ISO-8859-13 aka ISO-LATIN-7

    addCharset (new ISO_8859_13 ());

    // ISO-8859-15 aka ISO-LATIN-9

    addCharset (new ISO_8859_15 ());

    // KOI8 (Cyrillic)

    addCharset (new KOI_8 ());

  }

 /**

  * Load non-mandatory charsets.

  */

  private synchronized void loadExtended ()

  {

    if (extendedLoaded)

      return;

    addCharset (new ISO_8859_3 ());    // ISO-8859-3 aka ISO-LATIN-3

    addCharset (new ISO_8859_6 ());    // ISO-8859-6 (Arabic)

    addCharset (new ISO_8859_8 ());    // ISO-8859-8 (Hebrew)

    // Some more codepages

    addCharset (new Cp424());

    addCharset (new Cp437());

    addCharset (new Cp737());

    addCharset (new Cp775());

    addCharset (new Cp850());

    addCharset (new Cp852());

    addCharset (new Cp855()); // IBM Cyrillic

    addCharset (new Cp857()); // IBM Turkish

    addCharset (new Cp860()); // MSDOS Portugese

    addCharset (new Cp861()); // MSDOS Icelandic

    addCharset (new Cp862()); // PC Hebrew

    addCharset (new Cp863()); // MSDOS Can. French

    addCharset (new Cp864()); // PC Arabic

    addCharset (new Cp865()); // MSDOS Nordic

    addCharset (new Cp866()); // MSDOS Russian

    addCharset (new Cp869()); // IBM modern Greek

    addCharset (new Cp874()); // IBM Thai

    addCharset (new MacCentralEurope());

    addCharset (new MacCroatian());

    addCharset (new MacCyrillic());

    addCharset (new MacDingbat());

    addCharset (new MacGreek());

    addCharset (new MacIceland());

    addCharset (new MacRoman());

    addCharset (new MacRomania());

    addCharset (new MacSymbol());

    addCharset (new MacThai());

    addCharset (new MacTurkish());

    addCharset (new MS874());

    addCharset (new Windows1255());

    addCharset (new Windows1256());

    addCharset (new Windows1258());

    extendedLoaded = true;

  }

  public Iterator<Charset> charsets ()

  {

    loadExtended();

    return Collections.unmodifiableCollection (charsets.values ())

                      .iterator ();

  }

  /**

   * Returns a Charset instance by converting the given

   * name to lower-case, looking up the canonical charset

   * name and finally looking up the Charset with that name.

   *

   * <p>The lookup is therefore case-insensitive.</p>

   *

   *  @returns The Charset having <code>charsetName</code>

   *  as its alias or null if no such Charset exist.

   */

  public Charset charsetForName (String charsetName)

  {

    Charset cs = (Charset) charsets.get(canonicalNames.get(charsetName.toLowerCase()));

    if (cs == null)

     {

       loadExtended();

       cs = (Charset) charsets.get(canonicalNames.get(charsetName.toLowerCase()));

     }

    return cs;

  }

  /**

   * Puts a Charset under its canonical name into the 'charsets' map.

   * Then puts a mapping from all its alias names to the canonical name.

   *

   * <p>All names are converted to lower-case</p>.

   *

   * @param cs

   */

  private void addCharset (Charset cs)

  {

    String canonicalName = cs.name().toLowerCase();

    charsets.put (canonicalName, cs);

    /* Adds a mapping between the canonical name

     * itself making a lookup using that name

     * no special case.

     */

    canonicalNames.put(canonicalName, canonicalName);

    for (Iterator<String> i = cs.aliases ().iterator (); i.hasNext (); )

      canonicalNames.put (((String) i.next()).toLowerCase(), canonicalName);

  }

  public static synchronized Provider provider ()

  {

    // The default provider is safe to instantiate.

    if (singleton == null)

      singleton = AccessController.doPrivileged

        (new PrivilegedAction<Provider>()

          {

            public Provider run()

            {

              return new Provider();

            }

          });

    return singleton;

  }

}