Esempio n. 1
0
        static CollationRoot()
        {  // Corresponds to C++ load() function.
            CollationTailoring t  = null;
            Exception          e2 = null;

            try
            {
                // ICU4N specific - passing in assembly name so we resolve to this assembly rather than ICU4N.dll
                ByteBuffer         bytes = ICUBinary.GetRequiredData(typeof(CollationRoot).GetTypeInfo().Assembly, null, "coll/ucadata.icu");
                CollationTailoring t2    = new CollationTailoring(null);
                CollationDataReader.Read(null, bytes, t2);
                // Keep t=null until after the root data has been read completely.
                // Otherwise we would set a non-null root object if the data reader throws an exception.
                t = t2;
            }
            catch (IOException e)
            {
                e2 = new MissingManifestResourceException(
                    "IOException while reading CLDR root data, " +
                    "type: CollationRoot, bundle: " + ICUData.ICU_BUNDLE + "/coll/ucadata.icu", e);
            }
            catch (Exception e)
            {
                e2 = e;
            }
            rootSingleton = t;
            exception     = e2;
        }
Esempio n. 2
0
        // ICU4N: Avoid static constructor by initializing inline
        private static CollationTailoring LoadCollationTailoring(out Exception exception)
        {
            // Corresponds to C++ load() function.
            CollationTailoring t  = null;
            Exception          e2 = null;

            try
            {
                ByteBuffer         bytes = ICUBinary.GetRequiredData("coll/ucadata.icu");
                CollationTailoring t2    = new CollationTailoring(null);
                CollationDataReader.Read(null, bytes, t2);
                // Keep t=null until after the root data has been read completely.
                // Otherwise we would set a non-null root object if the data reader throws an exception.
                t = t2;
            }
            catch (IOException e)
            {
                e2 = new MissingManifestResourceException(
                    "IOException while reading CLDR root data, " +
                    "type: CollationRoot, bundle: " + ICUData.IcuBundle + "/coll/ucadata.icu", e);
            }
            catch (Exception e)
            {
                e2 = e;
            }
            exception = e2;
            return(t);
        }
Esempio n. 3
0
        public static CollationTailoring LoadTailoring(ULocale locale, out ULocale outValidLocale)
        {
            // Java porting note: ICU4J getWithFallback/getStringWithFallback currently does not
            // work well when alias table is involved in a resource path, unless full path is specified.
            // For now, collation resources does not contain such data, so the code below should work fine.

            CollationTailoring root       = CollationRoot.Root;
            string             localeName = locale.GetName();

            if (localeName.Length == 0 || localeName.Equals("root"))
            {
                outValidLocale = ULocale.ROOT;
                return(root);
            }

            UResourceBundle bundle = null;

            try
            {
                bundle = ICUResourceBundle.GetBundleInstance(
                    ICUData.ICU_COLLATION_BASE_NAME, locale,
                    // ICU4N specific - need to pass in this assembly
                    // name for the resources to be resolved here.
                    CollationData.ICU_DATA_CLASS_LOADER,
                    ICUResourceBundle.OpenType.LOCALE_ROOT);
            }
            catch (MissingManifestResourceException e)
            {
                outValidLocale = ULocale.ROOT;
                return(root);
            }

            ULocale validLocale = bundle.GetULocale();
            // Normalize the root locale. See
            // http://bugs.icu-project.org/trac/ticket/10715
            string validLocaleName = validLocale.GetName();

            if (validLocaleName.Length == 0 || validLocaleName.Equals("root"))
            {
                validLocale = ULocale.ROOT;
            }
            outValidLocale = validLocale;

            // There are zero or more tailorings in the collations table.
            UResourceBundle collations;

            try
            {
                collations = bundle.Get("collations");
                if (collations == null)
                {
                    return(root);
                }
            }
            catch (MissingManifestResourceException ignored)
            {
                return(root);
            }

            // Fetch the collation type from the locale ID and the default type from the data.
            string type        = locale.GetKeywordValue("collation");
            string defaultType = "standard";

            string defT = ((ICUResourceBundle)collations).FindStringWithFallback("default");

            if (defT != null)
            {
                defaultType = defT;
            }

            if (type == null || type.Equals("default"))
            {
                type = defaultType;
            }
            else
            {
                type = ASCII.ToLower(type);
            }

            // Load the collations/type tailoring, with type fallback.

            // Java porting note: typeFallback is used for setting U_USING_DEFAULT_WARNING in
            // ICU4C, but not used by ICU4J

            // boolean typeFallback = false;
            UResourceBundle data = FindWithFallback(collations, type);

            if (data == null &&
                type.Length > 6 && type.StartsWith("search", StringComparison.Ordinal))
            {
                // fall back from something like "searchjl" to "search"
                // typeFallback = true;
                type = "search";
                data = FindWithFallback(collations, type);
            }

            if (data == null && !type.Equals(defaultType))
            {
                // fall back to the default type
                // typeFallback = true;
                type = defaultType;
                data = FindWithFallback(collations, type);
            }

            if (data == null && !type.Equals("standard"))
            {
                // fall back to the "standard" type
                // typeFallback = true;
                type = "standard";
                data = FindWithFallback(collations, type);
            }

            if (data == null)
            {
                return(root);
            }

            // Is this the same as the root collator? If so, then use that instead.
            ULocale actualLocale = data.GetULocale();
            // http://bugs.icu-project.org/trac/ticket/10715 ICUResourceBundle(root).getULocale() != ULocale.ROOT
            // Therefore not just if (actualLocale.equals(ULocale.ROOT) && type.equals("standard")) {
            string actualLocaleName = actualLocale.GetName();

            if (actualLocaleName.Length == 0 || actualLocaleName.Equals("root"))
            {
                actualLocale = ULocale.ROOT;
                if (type.Equals("standard"))
                {
                    return(root);
                }
            }

            CollationTailoring t = new CollationTailoring(root.Settings);

            t.ActualLocale = actualLocale;

            // deserialize
            UResourceBundle binary  = data.Get("%%CollationBin");
            ByteBuffer      inBytes = binary.GetBinary();

            try
            {
                CollationDataReader.Read(root, inBytes, t);
            }
            catch (IOException e)
            {
                throw new ICUUncheckedIOException("Failed to load collation tailoring data for locale:"
                                                  + actualLocale + " type:" + type, e);
            }

            // Try to fetch the optional rules string.
            try
            {
                t.SetRulesResource(data.Get("Sequence"));
            }
            catch (MissingManifestResourceException ignored)
            {
            }

            // Set the collation types on the informational locales,
            // except when they match the default types (for brevity and backwards compatibility).
            // For the valid locale, suppress the default type.
            if (!type.Equals(defaultType))
            {
                outValidLocale = validLocale.SetKeywordValue("collation", type);
            }

            // For the actual locale, suppress the default type *according to the actual locale*.
            // For example, zh has default=pinyin and contains all of the Chinese tailorings.
            // zh_Hant has default=stroke but has no other data.
            // For the valid locale "zh_Hant" we need to suppress stroke.
            // For the actual locale "zh" we need to suppress pinyin instead.
            if (!actualLocale.Equals(validLocale))
            {
                // Opening a bundle for the actual locale should always succeed.
                UResourceBundle actualBundle = UResourceBundle.GetBundleInstance(
                    ICUData.ICU_COLLATION_BASE_NAME, actualLocale);
                defT = ((ICUResourceBundle)actualBundle).FindStringWithFallback("collations/default");
                if (defT != null)
                {
                    defaultType = defT;
                }
            }

            if (!type.Equals(defaultType))
            {
                t.ActualLocale = t.ActualLocale.SetKeywordValue("collation", type);
            }

            // if (typeFallback) {
            //     ICU4C implementation sets U_USING_DEFAULT_WARNING here
            // }

            return(t);
        }