Beispiel #1
0
 private BaseLocale(string language, string script, string region, string variant)
 {
     if (language != null)
     {
         _language = AsciiUtil.ToLower(language).Intern();
     }
     if (script != null)
     {
         _script = AsciiUtil.ToTitle(script).Intern();
     }
     if (region != null)
     {
         _region = AsciiUtil.ToUpper(region).Intern();
     }
     if (variant != null)
     {
         if (JDKIMPL)
         {
             // preserve upper/lower cases
             _variant = variant.Intern();
         }
         else
         {
             _variant = AsciiUtil.ToUpper(variant).Intern();
         }
     }
 }
Beispiel #2
0
        public static string ToBcpType(string key, string type,
                                       out bool isKnownKey, out bool isSpecialType)
        {
            isKnownKey    = false;
            isSpecialType = false;

            key  = AsciiUtil.ToLower(key);
            type = AsciiUtil.ToLower(type);

            if (KEYMAP.TryGetValue(key, out KeyData keyData) && keyData != null)
            {
                isKnownKey = true;
                if (keyData.TypeMap.TryGetValue(type, out Type t) && t != null)
                {
                    return(t.bcpId);
                }
                if (keyData.SpecialTypes != null)
                {
                    foreach (SpecialType st in keyData.SpecialTypes)
                    {
                        if (st.GetHandler().IsWellFormed(type))
                        {
                            isSpecialType = true;
                            return(st.GetHandler().Canonicalize(type));
                        }
                    }
                }
            }
            return(null);
        }
Beispiel #3
0
            public override int GetHashCode()
            {
                int h = _hash;

                if (h == 0)
                {
                    // Generating a hash value from language, script, region and variant
                    for (int i = 0; i < _lang.Length; i++)
                    {
                        h = 31 * h + AsciiUtil.ToLower(_lang[i]);
                    }
                    for (int i = 0; i < _scrt.Length; i++)
                    {
                        h = 31 * h + AsciiUtil.ToLower(_scrt[i]);
                    }
                    for (int i = 0; i < _regn.Length; i++)
                    {
                        h = 31 * h + AsciiUtil.ToLower(_regn[i]);
                    }
                    for (int i = 0; i < _vart.Length; i++)
                    {
                        if (JDKIMPL)
                        {
                            h = 31 * h + _vart[i];
                        }
                        else
                        {
                            h = 31 * h + AsciiUtil.ToLower(_vart[i]);
                        }
                    }
                    _hash = h;
                }
                return(h);
            }
Beispiel #4
0
        public virtual Extension GetExtension(char key)
        {
            Extension result;

            _map.TryGetValue(AsciiUtil.ToLower(key), out result);
            return(result);
        }
Beispiel #5
0
        public static string ToLegacyType(string key, string type,
                                          out bool isKnownKey, out bool isSpecialType)
        {
            isKnownKey    = false;
            isSpecialType = false;

            key  = AsciiUtil.ToLower(key);
            type = AsciiUtil.ToLower(type);

            KeyData keyData = KEYMAP.Get(key);

            if (keyData != null)
            {
                isKnownKey = true;
                Type t = keyData.TypeMap.Get(type);
                if (t != null)
                {
                    return(t.legacyId);
                }
                if (keyData.SpecialTypes != null)
                {
                    foreach (SpecialType st in keyData.SpecialTypes)
                    {
                        if (st.GetHandler().IsWellFormed(type))
                        {
                            isSpecialType = true;
                            return(st.GetHandler().Canonicalize(type));
                        }
                    }
                }
            }
            return(null);
        }
Beispiel #6
0
 public static int CaseIgnoreCompare(string s1, string s2)
 {
     if (Utility.SameObjects(s1, s2))
     {
         return(0);
     }
     return(AsciiUtil.ToLower(s1).CompareToOrdinal(AsciiUtil.ToLower(s2)));
 }
Beispiel #7
0
 public virtual string GetExtensionValue(char key)
 {
     if (!_map.TryGetValue(AsciiUtil.ToLower(key), out Extension ext) || ext == null)
     {
         return(null);
     }
     return(ext.Value);
 }
Beispiel #8
0
 public static string ToLegacyKey(string key)
 {
     key = AsciiUtil.ToLower(key);
     if (KEYMAP.TryGetValue(key, out KeyData keyData) && keyData != null)
     {
         return(keyData.LegacyId);
     }
     return(null);
 }
Beispiel #9
0
 public virtual string GetUnicodeLocaleType(string unicodeLocaleKey)
 {
     if (!_map.TryGetValue(UnicodeLocaleExtension.Singleton, out Extension ext) || ext == null)
     {
         return(null);
     }
     Debug.Assert(ext is UnicodeLocaleExtension);
     return(((UnicodeLocaleExtension)ext).GetUnicodeLocaleType(AsciiUtil.ToLower(unicodeLocaleKey)));
 }
Beispiel #10
0
        public static string ToLegacyKey(string key)
        {
            key = AsciiUtil.ToLower(key);
            KeyData keyData = KEYMAP.Get(key);

            if (keyData != null)
            {
                return(keyData.LegacyId);
            }
            return(null);
        }
Beispiel #11
0
 public override bool Equals(object obj)
 {
     if (this == obj)
     {
         return(true);
     }
     if (!(obj is CaseInsensitiveChar))
     {
         return(false);
     }
     return(_c == AsciiUtil.ToLower(((CaseInsensitiveChar)obj).Value));
 }
            public override bool Equals(object obj)
            {
                if (ReferenceEquals(this, obj))
                {
                    return(true);
                }

                if (obj is CaseInsensitiveChar other)
                {
                    return(_c == AsciiUtil.ToLower(other.Value));
                }

                return(false);
            }
Beispiel #13
0
            public static Key Normalize(Key key)
            {
                string lang = AsciiUtil.ToLower(key._lang).Intern();
                string scrt = AsciiUtil.ToTitle(key._scrt).Intern();
                string regn = AsciiUtil.ToUpper(key._regn).Intern();
                string vart;

                if (JDKIMPL)
                {
                    // preserve upper/lower cases
                    vart = key._vart.Intern();
                }
                else
                {
                    vart = AsciiUtil.ToUpper(key._vart).Intern();
                }
                return(new Key(lang, scrt, regn, vart));
            }
Beispiel #14
0
 public static bool IsSingletonChar(char c)
 {
     return(Singleton == AsciiUtil.ToLower(c));
 }
Beispiel #15
0
        private static void InitFromTables()
        {
            foreach (object[] keyDataEntry in KEY_DATA)
            {
                string     legacyKeyId      = (string)keyDataEntry[0];
                string     bcpKeyId         = (string)keyDataEntry[1];
                string[][] typeData         = (string[][])keyDataEntry[2];
                string[][] typeAliasData    = (string[][])keyDataEntry[3];
                string[][] bcpTypeAliasData = (string[][])keyDataEntry[4];

                bool hasSameKey = false;
                if (bcpKeyId == null)
                {
                    bcpKeyId   = legacyKeyId;
                    hasSameKey = true;
                }

                // reverse type alias map
                IDictionary <string, ISet <string> > typeAliasMap = null;
                if (typeAliasData != null)
                {
                    typeAliasMap = new Dictionary <string, ISet <string> >();
                    foreach (string[] typeAliasDataEntry in typeAliasData)
                    {
                        string        from = typeAliasDataEntry[0];
                        string        to   = typeAliasDataEntry[1];
                        ISet <string> aliasSet;
                        if (!typeAliasMap.TryGetValue(to, out aliasSet) || aliasSet == null)
                        {
                            aliasSet         = new HashSet <string>();
                            typeAliasMap[to] = aliasSet;
                        }
                        aliasSet.Add(from);
                    }
                }

                // BCP type alias map data
                IDictionary <string, ISet <string> > bcpTypeAliasMap = null;
                if (bcpTypeAliasData != null)
                {
                    bcpTypeAliasMap = new Dictionary <string, ISet <string> >();
                    foreach (string[] bcpTypeAliasDataEntry in bcpTypeAliasData)
                    {
                        string        from = bcpTypeAliasDataEntry[0];
                        string        to   = bcpTypeAliasDataEntry[1];
                        ISet <string> aliasSet;
                        if (!bcpTypeAliasMap.TryGetValue(to, out aliasSet) || aliasSet == null)
                        {
                            aliasSet            = new HashSet <string>();
                            bcpTypeAliasMap[to] = aliasSet;
                        }
                        aliasSet.Add(from);
                    }
                }

                // Type map data
                Debug.Assert(typeData != null);
                IDictionary <string, Type> typeDataMap    = new Dictionary <string, Type>();
                ISet <SpecialType>         specialTypeSet = null;

                foreach (string[] typeDataEntry in typeData)
                {
                    string legacyTypeId = typeDataEntry[0];
                    string bcpTypeId    = typeDataEntry[1];

                    // special types
                    bool isSpecialType = false;
                    foreach (SpecialType st in Enum.GetValues(typeof(SpecialType)))
                    {
                        if (legacyTypeId.Equals(st.ToString()))
                        {
                            isSpecialType = true;
                            if (specialTypeSet == null)
                            {
                                specialTypeSet = new HashSet <SpecialType>();
                            }
                            specialTypeSet.Add(st);
                            break;
                        }
                    }
                    if (isSpecialType)
                    {
                        continue;
                    }

                    bool hasSameType = false;
                    if (bcpTypeId == null)
                    {
                        bcpTypeId   = legacyTypeId;
                        hasSameType = true;
                    }

                    // Note: legacy type value should never be
                    // equivalent to bcp type value of a different
                    // type under the same key. So we use a single
                    // map for lookup.
                    Type t = new Type(legacyTypeId, bcpTypeId);
                    typeDataMap[AsciiUtil.ToLower(legacyTypeId)] = t;
                    if (!hasSameType)
                    {
                        typeDataMap[AsciiUtil.ToLower(bcpTypeId)] = t;
                    }

                    // Also put aliases in the index
                    ISet <string> typeAliasSet;
                    if (typeAliasMap.TryGetValue(legacyTypeId, out typeAliasSet) && typeAliasSet != null)
                    {
                        foreach (string alias in typeAliasSet)
                        {
                            typeDataMap[AsciiUtil.ToLower(alias)] = t;
                        }
                    }
                    ISet <string> bcpTypeAliasSet;
                    if (!bcpTypeAliasMap.TryGetValue(bcpTypeId, out bcpTypeAliasSet) && bcpTypeAliasSet != null)
                    {
                        foreach (string alias in bcpTypeAliasSet)
                        {
                            typeDataMap[AsciiUtil.ToLower(alias)] = t;
                        }
                    }
                }

                ISet <SpecialType> specialTypes = null;
                if (specialTypeSet != null)
                {
                    specialTypes = new HashSet <SpecialType>(specialTypeSet);
                }

                KeyData keyData = new KeyData(legacyKeyId, bcpKeyId, typeDataMap, specialTypes);

                KEYMAP[AsciiUtil.ToLower(legacyKeyId)] = keyData;
                if (!hasSameKey)
                {
                    KEYMAP[AsciiUtil.ToLower(bcpKeyId)] = keyData;
                }
            }
        }
Beispiel #16
0
            internal abstract bool IsWellFormed(string value); // doesn't test validity, just whether it is well formed.

            internal string Canonicalize(string value)
            {
                return(AsciiUtil.ToLower(value));
            }
Beispiel #17
0
        private static void InitFromResourceBundle()
        {
            UResourceBundle keyTypeDataRes = UResourceBundle.GetBundleInstance(
                ICUData.ICU_BASE_NAME,
                "keyTypeData",
                ICUResourceBundle.ICU_DATA_CLASS_LOADER);

            GetKeyInfo(keyTypeDataRes.Get("keyInfo"));
            GetTypeInfo(keyTypeDataRes.Get("typeInfo"));

            UResourceBundle keyMapRes  = keyTypeDataRes.Get("keyMap");
            UResourceBundle typeMapRes = keyTypeDataRes.Get("typeMap");

            // alias data is optional
            UResourceBundle typeAliasRes    = null;
            UResourceBundle bcpTypeAliasRes = null;

            try
            {
                typeAliasRes = keyTypeDataRes.Get("typeAlias");
            }
            catch (MissingManifestResourceException e)
            {
                // fall through
            }

            try
            {
                bcpTypeAliasRes = keyTypeDataRes.Get("bcpTypeAlias");
            }
            catch (MissingManifestResourceException e)
            {
                // fall through
            }

            // iterate through keyMap resource
            using (UResourceBundleEnumerator keyMapItr = keyMapRes.GetEnumerator())
            {
                IDictionary <string, IList <string> > _Bcp47Keys = new Dictionary <string, IList <string> >(); // ICU4N NOTE: As long as we don't delete, Dictionary keeps insertion order the same as LinkedHashMap

                while (keyMapItr.MoveNext())
                {
                    UResourceBundle keyMapEntry = keyMapItr.Current;
                    string          legacyKeyId = keyMapEntry.Key;
                    string          bcpKeyId    = keyMapEntry.GetString();

                    bool hasSameKey = false;
                    if (bcpKeyId.Length == 0)
                    {
                        // Empty value indicates that BCP key is same with the legacy key.
                        bcpKeyId   = legacyKeyId;
                        hasSameKey = true;
                    }
                    IList <string> _bcp47Types = new List <string>(); // ICU4N: Mimic LinkedHashSet with List by ensuring no duplicates are added
                    _Bcp47Keys[bcpKeyId] = _bcp47Types.ToUnmodifiableList();

                    bool isTZ = legacyKeyId.Equals("timezone");

                    // reverse type alias map
                    IDictionary <string, ISet <string> > typeAliasMap = null;
                    if (typeAliasRes != null)
                    {
                        UResourceBundle typeAliasResByKey = null;
                        try
                        {
                            typeAliasResByKey = typeAliasRes.Get(legacyKeyId);
                        }
                        catch (MissingManifestResourceException e)
                        {
                            // fall through
                        }
                        if (typeAliasResByKey != null)
                        {
                            typeAliasMap = new Dictionary <string, ISet <string> >();
                            using (UResourceBundleEnumerator typeAliasResItr = typeAliasResByKey.GetEnumerator())
                            {
                                while (typeAliasResItr.MoveNext())
                                {
                                    UResourceBundle typeAliasDataEntry = typeAliasResItr.Current;
                                    string          from = typeAliasDataEntry.Key;
                                    string          to   = typeAliasDataEntry.GetString();
                                    if (isTZ)
                                    {
                                        from = from.Replace(':', '/');
                                    }
                                    ISet <string> aliasSet = typeAliasMap.Get(to);
                                    if (aliasSet == null)
                                    {
                                        aliasSet         = new HashSet <string>();
                                        typeAliasMap[to] = aliasSet;
                                    }
                                    aliasSet.Add(from);
                                }
                            }
                        }
                    }

                    // reverse bcp type alias map
                    IDictionary <string, ISet <string> > bcpTypeAliasMap = null;
                    if (bcpTypeAliasRes != null)
                    {
                        UResourceBundle bcpTypeAliasResByKey = null;
                        try
                        {
                            bcpTypeAliasResByKey = bcpTypeAliasRes.Get(bcpKeyId);
                        }
                        catch (MissingManifestResourceException e)
                        {
                            // fall through
                        }
                        if (bcpTypeAliasResByKey != null)
                        {
                            bcpTypeAliasMap = new Dictionary <string, ISet <string> >();
                            using (UResourceBundleEnumerator bcpTypeAliasResItr = bcpTypeAliasResByKey.GetEnumerator())
                            {
                                while (bcpTypeAliasResItr.MoveNext())
                                {
                                    UResourceBundle bcpTypeAliasDataEntry = bcpTypeAliasResItr.Current;
                                    string          from     = bcpTypeAliasDataEntry.Key;
                                    string          to       = bcpTypeAliasDataEntry.GetString();
                                    ISet <string>   aliasSet = bcpTypeAliasMap.Get(to);
                                    if (aliasSet == null)
                                    {
                                        aliasSet            = new HashSet <string>();
                                        bcpTypeAliasMap[to] = aliasSet;
                                    }
                                    aliasSet.Add(from);
                                }
                            }
                        }
                    }

                    IDictionary <string, Type> typeDataMap    = new Dictionary <string, Type>();
                    ISet <SpecialType>         specialTypeSet = null;

                    // look up type map for the key, and walk through the mapping data
                    UResourceBundle typeMapResByKey = null;
                    try
                    {
                        typeMapResByKey = typeMapRes.Get(legacyKeyId);
                    }
                    catch (MissingManifestResourceException e)
                    {
                        // type map for each key must exist
                        Debug.Assert(false);
                    }
                    if (typeMapResByKey != null)
                    {
                        using (UResourceBundleEnumerator typeMapResByKeyItr = typeMapResByKey.GetEnumerator())
                            while (typeMapResByKeyItr.MoveNext())
                            {
                                UResourceBundle typeMapEntry = typeMapResByKeyItr.Current;
                                string          legacyTypeId = typeMapEntry.Key;
                                string          bcpTypeId    = typeMapEntry.GetString();

                                // special types
                                char first         = legacyTypeId[0];
                                bool isSpecialType = '9' < first && first < 'a' && bcpTypeId.Length == 0;
                                if (isSpecialType)
                                {
                                    if (specialTypeSet == null)
                                    {
                                        specialTypeSet = new HashSet <SpecialType>();
                                    }
                                    specialTypeSet.Add((SpecialType)Enum.Parse(typeof(SpecialType), legacyTypeId, true));
                                    if (!_bcp47Types.Contains(legacyTypeId)) // ICU4N: Mimic LinkedHashSet with a List by not allowing duplicates
                                    {
                                        _bcp47Types.Add(legacyTypeId);
                                    }
                                    continue;
                                }

                                if (isTZ)
                                {
                                    // a timezone key uses a colon instead of a slash in the resource.
                                    // e.g. America:Los_Angeles
                                    legacyTypeId = legacyTypeId.Replace(':', '/');
                                }

                                bool hasSameType = false;
                                if (bcpTypeId.Length == 0)
                                {
                                    // Empty value indicates that BCP type is same with the legacy type.
                                    bcpTypeId   = legacyTypeId;
                                    hasSameType = true;
                                }
                                if (!_bcp47Types.Contains(legacyTypeId)) // ICU4N: Mimic LinkedHashSet with a List by not allowing duplicates
                                {
                                    _bcp47Types.Add(bcpTypeId);
                                }

                                // Note: legacy type value should never be
                                // equivalent to bcp type value of a different
                                // type under the same key. So we use a single
                                // map for lookup.
                                Type t = new Type(legacyTypeId, bcpTypeId);
                                typeDataMap[AsciiUtil.ToLower(legacyTypeId)] = t;
                                if (!hasSameType)
                                {
                                    typeDataMap[AsciiUtil.ToLower(bcpTypeId)] = t;
                                }

                                // Also put aliases in the map
                                if (typeAliasMap != null)
                                {
                                    ISet <string> typeAliasSet = typeAliasMap.Get(legacyTypeId);
                                    if (typeAliasSet != null)
                                    {
                                        foreach (string alias in typeAliasSet)
                                        {
                                            typeDataMap[AsciiUtil.ToLower(alias)] = t;
                                        }
                                    }
                                }
                                if (bcpTypeAliasMap != null)
                                {
                                    ISet <string> bcpTypeAliasSet = bcpTypeAliasMap.Get(bcpTypeId);
                                    if (bcpTypeAliasSet != null)
                                    {
                                        foreach (string alias in bcpTypeAliasSet)
                                        {
                                            typeDataMap[AsciiUtil.ToLower(alias)] = t;
                                        }
                                    }
                                }
                            }
                    }

                    KeyData keyData = new KeyData(legacyKeyId, bcpKeyId, typeDataMap, specialTypeSet);

                    KEYMAP[AsciiUtil.ToLower(legacyKeyId)] = keyData;
                    if (!hasSameKey)
                    {
                        KEYMAP[AsciiUtil.ToLower(bcpKeyId)] = keyData;
                    }
                }

                BCP47_KEYS = _Bcp47Keys.ToUnmodifiableDictionary();
            }
        }
Beispiel #18
0
        public static LanguageTag ParseLocale(BaseLocale baseLocale, LocaleExtensions localeExtensions)
        {
            LanguageTag tag = new LanguageTag();

            string language = baseLocale.GetLanguage();
            string script   = baseLocale.GetScript();
            string region   = baseLocale.GetRegion();
            string variant  = baseLocale.GetVariant();

            bool hasSubtag = false;

            string privuseVar = null;   // store ill-formed variant subtags

            if (language.Length > 0 && IsLanguage(language))
            {
                // Convert a deprecated language code used by Java to
                // a new code
                if (language.Equals("iw"))
                {
                    language = "he";
                }
                else if (language.Equals("ji"))
                {
                    language = "yi";
                }
                else if (language.Equals("in"))
                {
                    language = "id";
                }
                tag._language = language;
            }

            if (script.Length > 0 && IsScript(script))
            {
                tag._script = CanonicalizeScript(script);
                hasSubtag   = true;
            }

            if (region.Length > 0 && IsRegion(region))
            {
                tag._region = CanonicalizeRegion(region);
                hasSubtag   = true;
            }

            // ICU4N TODO: Remove ?
            if (JDKIMPL)
            {
                // Special handling for no_NO_NY - use nn_NO for language tag
                if (tag._language.Equals("no") && tag._region.Equals("NO") && variant.Equals("NY")) // ICU4N TODO: Fix this handling for .NET (no-NO is not reliable across platforms)
                {
                    tag._language = "nn";
                    variant       = "";
                }
            }

            if (variant.Length > 0)
            {
                List <string>         variants = null;
                StringTokenEnumerator varitr   = new StringTokenEnumerator(variant, BaseLocale.SEP);
                while (varitr.MoveNext())
                {
                    string var = varitr.Current;
                    if (!IsVariant(var))
                    {
                        break;
                    }
                    if (variants == null)
                    {
                        variants = new List <string>();
                    }
                    if (JDKIMPL)
                    {
                        variants.Add(var);  // Do not canonicalize!
                    }
                    else
                    {
                        variants.Add(CanonicalizeVariant(var));
                    }
                }
                if (variants != null)
                {
                    tag._variants = variants;
                    hasSubtag     = true;
                }
                if (!varitr.IsDone)
                {
                    // ill-formed variant subtags
                    StringBuilder buf = new StringBuilder();
                    while (!varitr.IsDone)
                    {
                        string prvv = varitr.Current;
                        if (!IsPrivateuseSubtag(prvv))
                        {
                            // cannot use private use subtag - truncated
                            break;
                        }
                        if (buf.Length > 0)
                        {
                            buf.Append(SEP);
                        }
                        if (!JDKIMPL)
                        {
                            prvv = AsciiUtil.ToLower(prvv);
                        }
                        buf.Append(prvv);
                        varitr.MoveNext();
                    }
                    if (buf.Length > 0)
                    {
                        privuseVar = buf.ToString();
                    }
                }
            }

            List <string> extensions = null;
            string        privateuse = null;

            var locextKeys = localeExtensions.Keys;

            foreach (char locextKey in locextKeys)
            {
                Extension ext = localeExtensions.GetExtension(locextKey);
                if (IsPrivateusePrefixChar(locextKey))
                {
                    privateuse = ext.Value;
                }
                else
                {
                    if (extensions == null)
                    {
                        extensions = new List <string>();
                    }
                    extensions.Add(locextKey.ToString() + SEP + ext.Value);
                }
            }

            if (extensions != null)
            {
                tag._extensions = extensions;
                hasSubtag       = true;
            }

            // append ill-formed variant subtags to private use
            if (privuseVar != null)
            {
                if (privateuse == null)
                {
                    privateuse = PRIVUSE_VARIANT_PREFIX + SEP + privuseVar;
                }
                else
                {
                    privateuse = privateuse + SEP + PRIVUSE_VARIANT_PREFIX + SEP + privuseVar.Replace(BaseLocale.SEP, SEP);
                }
            }

            if (privateuse != null)
            {
                tag._privateuse = privateuse;
            }

            if (tag._language.Length == 0 && (hasSubtag || privateuse == null))
            {
                // use lang "und" when 1) no language is available AND
                // 2) any of other subtags other than private use are available or
                // no private use tag is available
                tag._language = UNDETERMINED;
            }

            return(tag);
        }
Beispiel #19
0
 public AsciiCaseInsensitiveKey(string key)
 {
     _key  = key;
     _hash = AsciiUtil.ToLower(key).GetHashCode();
 }
Beispiel #20
0
        //
        // Language subtag canonicalization methods
        //

        public static string CanonicalizeLanguage(string s)
        {
            return(AsciiUtil.ToLower(s));
        }
Beispiel #21
0
 public static string CanonicalizeExtlang(string s)
 {
     return(AsciiUtil.ToLower(s));
 }
Beispiel #22
0
 public static string CanonicalizeVariant(string s)
 {
     return(AsciiUtil.ToLower(s));
 }
 internal CaseInsensitiveChar(char c)
 {
     _c    = c;
     _hash = AsciiUtil.ToLower(_c);// ICU4N specific - cache hash code, since this is an immutable object
 }
Beispiel #24
0
 public override int GetHashCode()
 {
     return(AsciiUtil.ToLower(_c));
 }
Beispiel #25
0
 public static string CanonicalizeExtensionSubtag(string s)
 {
     return(AsciiUtil.ToLower(s));
 }
Beispiel #26
0
 public static string CanonicalizePrivateuseSubtag(string s)
 {
     return(AsciiUtil.ToLower(s));
 }
Beispiel #27
0
        /// <summary>
        /// Internal constructor, only used by <see cref="InternalLocaleBuilder"/>.
        /// </summary>
        internal LocaleExtensions(IDictionary <CaseInsensitiveChar, string> extensions,
                                  ISet <CaseInsensitiveString> uattributes, IDictionary <CaseInsensitiveString, string> ukeywords)
        {
            bool hasExtension   = (extensions != null && extensions.Count > 0);
            bool hasUAttributes = (uattributes != null && uattributes.Count > 0);
            bool hasUKeywords   = (ukeywords != null && ukeywords.Count > 0);

            if (!hasExtension && !hasUAttributes && !hasUKeywords)
            {
                _map = EmptyMap;
                _id  = "";
                return;
            }

            // Build extension map
            _map = new JCG.SortedDictionary <char, Extension>();
            if (hasExtension)
            {
                foreach (var ext in extensions)
                {
                    char   key   = AsciiUtil.ToLower(ext.Key.Value);
                    string value = ext.Value;

                    if (LanguageTag.IsPrivateusePrefixChar(key))
                    {
                        // we need to exclude special variant in privuateuse, e.g. "x-abc-lvariant-DEF"
                        value = InternalLocaleBuilder.RemovePrivateuseVariant(value);
                        if (value == null)
                        {
                            continue;
                        }
                    }

                    Extension e = new Extension(key, AsciiUtil.ToLower(value));
                    _map[key] = e;
                }
            }

            if (hasUAttributes || hasUKeywords)
            {
                JCG.SortedSet <string> uaset = null;
                JCG.SortedDictionary <string, string> ukmap = null;

                if (hasUAttributes)
                {
                    uaset = new JCG.SortedSet <string>(StringComparer.Ordinal);
                    foreach (CaseInsensitiveString cis in uattributes)
                    {
                        uaset.Add(AsciiUtil.ToLower(cis.Value));
                    }
                }

                if (hasUKeywords)
                {
                    ukmap = new JCG.SortedDictionary <string, string>(StringComparer.Ordinal);
                    foreach (var kwd in ukeywords)
                    {
                        string key  = AsciiUtil.ToLower(kwd.Key.Value);
                        string type = AsciiUtil.ToLower(kwd.Value);
                        ukmap[key] = type;
                    }
                }

                UnicodeLocaleExtension ule = new UnicodeLocaleExtension(uaset, ukmap);
                _map[UnicodeLocaleExtension.Singleton] = ule;
            }

            if (_map.Count == 0)
            {
                // this could happen when only privuateuse with special variant
                _map = EmptyMap;
                _id  = "";
            }
            else
            {
                _id = ToID(_map);
            }
        }
 internal CaseInsensitiveString(string s)
 {
     _s    = s;
     _hash = AsciiUtil.ToLower(_s).GetHashCode(); // ICU4N specific - cache hash code, since this is an immutable object
 }