public static string ToBcpKey(string key) { key = AsciiUtil.ToLowerString(key); KeyData keyData = KEYMAP.Get(key); if (keyData != null) { return(keyData.BcpId); } return(null); }
public static Key Normalize(Key key) { string lang = AsciiUtil.ToLowerString(key._lang).Intern(); string scrt = AsciiUtil.ToTitleString(key._scrt).Intern(); string regn = AsciiUtil.ToUpperString(key._regn).Intern(); string vart; if (JDKIMPL) { // preserve upper/lower cases vart = key._vart.Intern(); } else { vart = AsciiUtil.ToUpperString(key._vart).Intern(); } return(new Key(lang, scrt, regn, vart)); }
internal abstract bool IsWellFormed(string value); // doesn't test validity, just whether it is well formed. internal string Canonicalize(string value) { return(AsciiUtil.ToLowerString(value)); }
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.ToLowerString(legacyTypeId)] = t; if (!hasSameType) { typeDataMap[AsciiUtil.ToLowerString(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.ToLowerString(alias)] = t; } } } if (bcpTypeAliasMap != null) { ISet <string> bcpTypeAliasSet = bcpTypeAliasMap.Get(bcpTypeId); if (bcpTypeAliasSet != null) { foreach (string alias in bcpTypeAliasSet) { typeDataMap[AsciiUtil.ToLowerString(alias)] = t; } } } } } KeyData keyData = new KeyData(legacyKeyId, bcpKeyId, typeDataMap, specialTypeSet); KEYMAP[AsciiUtil.ToLowerString(legacyKeyId)] = keyData; if (!hasSameKey) { KEYMAP[AsciiUtil.ToLowerString(bcpKeyId)] = keyData; } } BCP47_KEYS = _Bcp47Keys.ToUnmodifiableDictionary(); } }
public CaseInsensitiveKey(string key) { _key = key; _hash = AsciiUtil.ToLowerString(key).GetHashCode(); }