public void SortKeyTest(CompareInfo compareInfo, string string1, string string2, CompareOptions options, int expectedSign) { SortKey sk1 = compareInfo.GetSortKey(string1, options); SortKey sk2 = compareInfo.GetSortKey(string2, options); Assert.Equal(expectedSign, Math.Sign(SortKey.Compare(sk1, sk2))); Assert.Equal(expectedSign == 0, sk1.Equals(sk2)); if (!WindowsVersionHasTheCompareStringRegression) { Assert.Equal(Math.Sign(compareInfo.Compare(string1, string2, options)), Math.Sign(SortKey.Compare(sk1, sk2))); } Assert.Equal(compareInfo.GetHashCode(string1, options), sk1.GetHashCode()); Assert.Equal(compareInfo.GetHashCode(string2, options), sk2.GetHashCode()); Assert.Equal(string1, sk1.OriginalString); Assert.Equal(string2, sk2.OriginalString); // Now try the span-based versions - use BoundedMemory to detect buffer overruns RunSpanSortKeyTest(compareInfo, string1, options, sk1.KeyData); RunSpanSortKeyTest(compareInfo, string2, options, sk2.KeyData); unsafe static void RunSpanSortKeyTest(CompareInfo compareInfo, ReadOnlySpan <char> source, CompareOptions options, byte[] expectedSortKey)
public static void Main() { CompareInfo cmpi = null; SortKey sk1 = null; SortKey sk2 = null; string s = "ABC"; string ignoreCase = "Ignore case"; string useCase = "Use case "; // Get a CompareInfo object for the English-Great Britain culture. cmpi = CompareInfo.GetCompareInfo("en-GB"); // Get a sort key that ignores case for the specified string. sk1 = cmpi.GetSortKey(s, CompareOptions.IgnoreCase); // Get a sort key with no compare option for the specified string. sk2 = cmpi.GetSortKey(s); // Display the original string. Console.WriteLine("Original string: \"{0}\"", sk1.OriginalString); Console.WriteLine(); // Display the the string equivalent of the two sort keys. Console.WriteLine("CompareInfo (culture) name: {0}", cmpi.Name); Console.WriteLine("ToString - {0}: \"{1}\"", ignoreCase, sk1.ToString()); Console.WriteLine("ToString - {0}: \"{1}\"", useCase, sk2.ToString()); Console.WriteLine(); // Display the key data of the two sort keys. DisplayKeyData(sk1, ignoreCase); DisplayKeyData(sk2, useCase); }
public void SortKeyTest(CompareInfo compareInfo, string string1, string string2, CompareOptions options, int expected) { SortKey sk1 = compareInfo.GetSortKey(string1, options); SortKey sk2 = compareInfo.GetSortKey(string2, options); Assert.Equal(expected, SortKey.Compare(sk1, sk2)); Assert.Equal(string1, sk1.OriginalString); Assert.Equal(string2, sk2.OriginalString); }
public void SortKeyTest(CompareInfo compareInfo, string string1, string string2, CompareOptions options, int expectedSign) { SortKey sk1 = compareInfo.GetSortKey(string1, options); SortKey sk2 = compareInfo.GetSortKey(string2, options); Assert.Equal(expectedSign, Math.Sign(SortKey.Compare(sk1, sk2))); Assert.Equal(expectedSign == 0, sk1.Equals(sk2)); Assert.Equal(Math.Sign(compareInfo.Compare(string1, string2, options)), Math.Sign(SortKey.Compare(sk1, sk2))); Assert.Equal(compareInfo.GetHashCode(string1, options), sk1.GetHashCode()); Assert.Equal(compareInfo.GetHashCode(string2, options), sk2.GetHashCode()); Assert.Equal(string1, sk1.OriginalString); Assert.Equal(string2, sk2.OriginalString); }
/// <summary> /// Tries to find the key <paramref name="searchText"/> in the dictionary. /// </summary> /// <param name="searchText">The text to search. If this original text was not found, on return, the parameter contains the key for which the content is returned.</param> /// <param name="dictionary">The dictionary.</param> /// <returns>A tuple consisting of the content, the content identifer, and a boolean. The boolean is true if the original search text was found in the dictionary. /// If the original search text was not found, the boolean is false, and <paramref name="searchText"/>contains the search text that was found.</returns> private (string Content, string ContentId, bool foundOriginal) GetResult(ref string searchText, ISlobDictionary dictionary) { var searchKey = _compareInfo.GetSortKey(searchText); var index = Array.BinarySearch(_sortKeys, searchKey, new UnicodeStringSorter()); (string Content, string ContentId)result = (null, null); bool found = false; if (index >= 0) { result = dictionary[searchText]; found = true; } else { index = ~index; if (index < _keys.Length) { searchText = _keys[index]; result = dictionary[searchText]; } } return(result.Content, result.ContentId, found); }
public static byte[] SortKey(string orig) { if (orig == null) { return(null); } return(culture_compare_info.GetSortKey(orig, CompareOptions.IgnoreCase).KeyData); }
public int GetHashCode([NotNull] string o) { #if NETSTANDARD1_3 return(CompareInfo.GetHashCode(o, CompareOptions.IgnoreWidth)); #else return(CompareInfo.GetSortKey(o, CompareOptions.IgnoreWidth).GetHashCode()); #endif }
public int GetHashCode(string obj) { #if NET45 || NET451 return(CompareInfo.GetSortKey(obj, CompareOptions.IgnoreWidth).GetHashCode()); #else return(CompareInfo.GetHashCode(obj, CompareOptions.IgnoreWidth)); #endif }
public int GetHashCode([NotNull] string o) { #if NET45 || NET451 return(CompareInfo.GetSortKey(o, CompareOptions.IgnoreWidth | CompareOptions.IgnoreCase).GetHashCode()); #else return(CompareInfo.GetHashCode(o, CompareOptions.IgnoreWidth | CompareOptions.IgnoreCase)); #endif }
public static void Main() { // Define names. String[] names = { "Adam", "Ignatius", "Batholomew", "Gregory", "Clement", "Frances", "Harold", "Dalmatius", "Edgar", "John", "Benedict", "Paul", "George" }; SortKey[] sortKeys = new SortKey[names.Length]; CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo; for (int ctr = 0; ctr < names.Length; ctr++) { sortKeys[ctr] = ci.GetSortKey(names[ctr], CompareOptions.IgnoreCase); } // Sort array based on value of sort keys. Array.Sort(names, sortKeys); Console.WriteLine("Sorted array: "); foreach (var name in names) { Console.WriteLine(name); } Console.WriteLine(); String[] namesToFind = { "Paul", "PAUL", "Wilberforce" }; Console.WriteLine("Searching an array:"); foreach (var nameToFind in namesToFind) { SortKey searchKey = ci.GetSortKey(nameToFind, CompareOptions.IgnoreCase); int index = Array.FindIndex(sortKeys, (x) => x.Equals(searchKey)); if (index >= 0) { Console.WriteLine("{0} found at index {1}: {2}", nameToFind, index, names[index]); } else { Console.WriteLine("{0} not found", nameToFind); } } }
unsafe static void RunSpanSortKeyTest(CompareInfo compareInfo, ReadOnlySpan <char> source, CompareOptions options, byte[] expectedSortKey) { using BoundedMemory <char> sourceBoundedMemory = BoundedMemory.AllocateFromExistingData(source); sourceBoundedMemory.MakeReadonly(); Assert.Equal(expectedSortKey.Length, compareInfo.GetSortKeyLength(sourceBoundedMemory.Span, options)); using BoundedMemory <byte> sortKeyBoundedMemory = BoundedMemory.Allocate <byte>(expectedSortKey.Length); // First try with a destination which is too small - should result in an error Assert.Throws <ArgumentException>("destination", () => compareInfo.GetSortKey(sourceBoundedMemory.Span, sortKeyBoundedMemory.Span.Slice(1), options)); // Next, try with a destination which is perfectly sized - should succeed Span <byte> sortKeyBoundedSpan = sortKeyBoundedMemory.Span; sortKeyBoundedSpan.Clear(); Assert.Equal(expectedSortKey.Length, compareInfo.GetSortKey(sourceBoundedMemory.Span, sortKeyBoundedSpan, options)); Assert.Equal(expectedSortKey, sortKeyBoundedSpan[0..expectedSortKey.Length].ToArray());
public override int GetHashCode(string s) { if (s == null) { throw new ArgumentNullException("s"); } CompareOptions co = _ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None; return(_compareInfo.GetSortKey(s, co).GetHashCode()); }
/// <summary> /// Hashes the provided string using the given CompareOptions. /// Doing this allows all custom compare options to be applied in determining the hash value. /// </summary> /// <param name="str">The string.</param> /// <param name="info">The CompareInfo object doing the unicode-aware comparison.</param> /// <param name="options">The options to apply to the comparison.</param> /// <returns>Returns the hash code for the string.</returns> public int HashFunction(string str, CompareInfo info, CompareOptions options) { if (string.IsNullOrEmpty(str)) { return(0); } SortKey sortOrder = info.GetSortKey(str, options); int hash = GetByteArrayHash(sortOrder.KeyData); return(hash); }
public static Key Fixed(string data, int length, CompareInfo collation, CompareOptions collationOptions, Direction direction = Direction.Ascending) { Key i; var tmp = collation.GetSortKey(data, collationOptions).KeyData; if (direction == Direction.Descending) { InvertBits(tmp); } i.bytes = tmp; i.length = length * 6; // Assumes 2 bytes per character is enough, may not be true for all UTF-16 characters return(i); }
private string GetStringSortKey(IConvertible value) { string text = value.ToString(null); if (_compareOptions.HasFlag(CompareOptions.Ordinal)) { return(text); } if (_compareOptions.HasFlag(CompareOptions.OrdinalIgnoreCase)) { return(text.ToUpperInvariant()); } return(ToComparableBase64String(_compareInfo.GetSortKey(text, _compareOptions).KeyData)); }
public static void Main() { string lowerABC = "abc"; string upperABC = "ABC"; int result = 0; // Create a CompareInfo object for the en-US culture. Console.WriteLine("\nCreate a CompareInfo object for the en-US culture...\n"); CompareInfo cmpi = CompareInfo.GetCompareInfo("en-US"); // Alternatively: // CompareInfo cmpi = new CultureInfo("en-US").CompareInfo; // Create sort keys for lowercase and uppercase "abc", the en-US culture, and // ignore case. SortKey sk1LowerIgnCase = cmpi.GetSortKey(lowerABC, CompareOptions.IgnoreCase); SortKey sk2UpperIgnCase = cmpi.GetSortKey(upperABC, CompareOptions.IgnoreCase); // Create sort keys for lowercase and uppercase "abc", the en-US culture, and // use case. SortKey sk1LowerUseCase = cmpi.GetSortKey(lowerABC, CompareOptions.None); SortKey sk2UpperUseCase = cmpi.GetSortKey(upperABC, CompareOptions.None); // Compare lowercase and uppercase "abc", ignoring case and using CompareInfo. result = cmpi.Compare(lowerABC, upperABC, CompareOptions.IgnoreCase); Display(result, "CompareInfo, Ignore case", lowerABC, upperABC); // Compare lowercase and uppercase "abc", ignoring case and using SortKey. result = SortKey.Compare(sk1LowerIgnCase, sk2UpperIgnCase); Display(result, "SortKey, Ignore case", lowerABC, upperABC); Console.WriteLine(); // Compare lowercase and uppercase "abc", using case and using CompareInfo. result = cmpi.Compare(lowerABC, upperABC, CompareOptions.None); Display(result, "CompareInfo, Use case", lowerABC, upperABC); // Compare lowercase and uppercase "abc", using case and using SortKey. result = SortKey.Compare(sk1LowerUseCase, sk2UpperUseCase); Display(result, "SortKey, Use case", lowerABC, upperABC); }
/// <summary> /// Collects the keys of all loaded dictionaries and sorts them alphabetically. The list of keys is then published in <see cref="KeyList"/>. /// </summary> public void CollectAndSortKeys() { var hashSet = new HashSet <string>(); foreach (var dict in _dictionaries) { hashSet.UnionWith(dict.GetKeys()); } _keys = hashSet.ToArray(); _compareInfo = new CultureInfo("en-US", false).CompareInfo; _sortKeys = _keys.Select(x => _compareInfo.GetSortKey(x)).ToArray(); Array.Sort(_sortKeys, _keys, new UnicodeStringSorter()); KeyList = new ObservableCollection <string>(_keys); }
/// <summary> /// Hashes the provided string using the given CompareOptions. /// Doing this allows all custom compare options to be applied in determining the hash value. /// </summary> /// <param name="str">The string.</param> /// <param name="info">The CompareInfo object doing the unicode-aware comparison.</param> /// <param name="options">The options to apply to the comparison.</param> /// <returns>Returns the hash code for the string.</returns> public static int HashFunction(string str, CompareInfo info, CompareOptions options) { if (info == null) { throw new ArgumentNullException(nameof(info)); } if (string.IsNullOrEmpty(str)) { return(0); } SortKey sortOrder = info.GetSortKey(str, options); int hash = GetByteArrayHash(sortOrder.KeyData); return(hash); }
public int GetHashCode(string obj) { return(CompareInfo.GetSortKey(obj, CompareOptions.IgnoreWidth | CompareOptions.IgnoreCase).GetHashCode()); }
public int GetHashCode([NotNull] string o) => CompareInfo.GetSortKey(o, CompareOptions.IgnoreWidth | CompareOptions.IgnoreCase).GetHashCode();
// Windows Test Function private void TestWin(int lineNum) { wComp.GetSortKey(wLines[lineNum], wOptions); }
public int GetHashCode(string o) => CompareInfo.GetSortKey(o, CompareOptions.IgnoreWidth | CompareOptions.IgnoreCase | CompareOptions.IgnoreKanaType).GetHashCode();
public override int GetHashCode(string obj) { return(m_compareInfo.GetSortKey(obj, m_options).GetHashCode()); }