Merge pull request #14 from rameel/alternate-lookup-support

Add support for `IAlternateEqualityComparer`

Author: rameel

Ramstack.Structures.Tests/Text/StringViewComparerTests.cs

@@ -136,4 +136,34 @@ public void Create_IgnoreCase()
         Assert.That(c1.Equals("test", "TEST"), Is.True);
         Assert.That(c2.Equals("test", "TEST"), Is.True);
     }
+
+    #if NET9_0_OR_GREATER
+    [Test]
+    public void AlternateComparer_Ordinal()
+    {
+        var dictionary = new Dictionary<StringView, int>(StringViewComparer.Ordinal)
+        {
+            ["test"] = 1
+        };
+
+        var lookup = dictionary.GetAlternateLookup<ReadOnlySpan<char>>();
+        Assert.That(lookup.TryGetValue("TEST", out _), Is.False);
+        Assert.That(lookup.TryGetValue("test", out var v), Is.True);
+        Assert.That(v, Is.EqualTo(1));
+    }
+
+    [Test]
+    public void AlternateComparer_OrdinalIgnoreCase()
+    {
+        var dictionary = new Dictionary<StringView, int>(StringViewComparer.OrdinalIgnoreCase)
+        {
+            ["TEST"] = 1
+        };
+
+        var lookup = dictionary.GetAlternateLookup<ReadOnlySpan<char>>();
+        Assert.That(lookup.TryGetValue("text", out _), Is.False);
+        Assert.That(lookup.TryGetValue("test", out var v), Is.True);
+        Assert.That(v, Is.EqualTo(1));
+    }
+    #endif
 }

Ramstack.Structures/Text/StringView.cs

@@ -651,6 +651,24 @@ public bool Contains(ReadOnlySpan<char> value, StringComparison comparisonType)
     public int CompareTo(StringView other) =>
         Compare(this, other, StringComparison.CurrentCulture);
 
+    /// <summary>
+    /// Compares one view with a readonly span, and returns an integer
+    /// that indicates their relative position in the sort order.
+    /// </summary>
+    /// <param name="other">An object to compare with this instance.</param>
+    /// <returns>
+    /// A signed integer that indicates the relative order of view and other:
+    ///     - If less than 0, this instance precedes than <paramref name="other"/>.
+    ///     - If 0, this instance equals <paramref name="other"/>.
+    ///     - If greater than 0, this instance follows <paramref name="other"/>.
+    /// </returns>
+    public int CompareTo(ReadOnlySpan<char> other) =>
+        Compare(this, other, StringComparison.CurrentCulture);
+
+    /// <inheritdoc />
+    public int CompareTo(string? other) =>
+        Compare(this, other, StringComparison.CurrentCulture);
+
     /// <summary>
     /// Compares one view with another using a specified string comparison,
     /// and returns an integer that indicates their relative position in the sort order.
@@ -667,12 +685,24 @@ public int CompareTo(StringView other) =>
     public int CompareTo(StringView other, StringComparison comparisonType) =>
         Compare(this, other, comparisonType);
 
-    /// <inheritdoc />
-    public int CompareTo(string? other) =>
-        Compare(this, other, StringComparison.CurrentCulture);
+    /// <summary>
+    /// Compares one view with a readonly span using a specified string comparison,
+    /// and returns an integer that indicates their relative position in the sort order.
+    /// </summary>
+    /// <param name="other">The view to compare with the current instance.</param>
+    /// <param name="comparisonType">An enumeration value that determines
+    /// how current view and other are compared.</param>
+    /// <returns>
+    /// A signed integer that indicates the relative order of view and other:
+    ///     - If less than 0, this instance precedes than <paramref name="other"/>.
+    ///     - If 0, this instance equals <paramref name="other"/>.
+    ///     - If greater than 0, this instance follows <paramref name="other"/>.
+    /// </returns>
+    public int CompareTo(ReadOnlySpan<char> other, StringComparison comparisonType) =>
+        Compare(this, other, comparisonType);
 
     /// <summary>
-    /// Compares one view with another using a specified string comparison,
+    /// Compares one view with a string using a specified string comparison,
     /// and returns an integer that indicates their relative position in the sort order.
     /// </summary>
     /// <param name="other">The view to compare with the current instance.</param>
@@ -703,6 +733,17 @@ public override bool Equals([NotNullWhen(true)] object? obj)
     public bool Equals(StringView other) =>
         Equals(this, other);
 
+    /// <summary>
+    /// Indicates whether the current object is equal to a specified readonly span.
+    /// </summary>
+    /// <param name="other">An object to compare with this object.</param>
+    /// <returns>
+    /// <see langword="true" /> if the current object is equal to the <paramref name="other" /> parameter;
+    /// otherwise, <see langword="false" />.
+    /// </returns>
+    public bool Equals(ReadOnlySpan<char> other) =>
+        Equals(this, other);
+
     /// <inheritdoc />
     public bool Equals(string? other) =>
         Equals(this, other);
@@ -720,6 +761,19 @@ public bool Equals(string? other) =>
     public bool Equals(StringView other, StringComparison comparisonType) =>
         Equals(this, other, comparisonType);
 
+    /// <summary>
+    /// Determines whether this view and the specified readonly span have the same characters
+    /// when compared using the specified <paramref name="comparisonType"/> option.
+    /// </summary>
+    /// <param name="other">The value to compare with the current instance.</param>
+    /// <param name="comparisonType">An enumeration value that determines
+    /// how current instance and <paramref name="other"/> are compared.</param>
+    /// <returns>
+    /// true if equal, false otherwise.
+    /// </returns>
+    public bool Equals(ReadOnlySpan<char> other, StringComparison comparisonType) =>
+        Equals(this, other, comparisonType);
+
     /// <summary>
     /// Determines whether this view and the specified other view have the same characters
     /// when compared using the specified <paramref name="comparisonType"/> option.
@@ -864,6 +918,18 @@ public bool TryCopyTo(Span<char> destination) =>
     public static bool Equals(StringView a, StringView b) =>
         a.AsSpan().SequenceEqual(b);
 
+    /// <summary>
+    /// Determines whether two specified <see cref="StringView"/> objects have the same value.
+    /// </summary>
+    /// <param name="a">The first value to compare.</param>
+    /// <param name="b">The second value to compare.</param>
+    /// <returns>
+    /// <see langword="true"/> if the value of <paramref name="a"/> is the same as the value
+    /// of <paramref name="b"/>; otherwise, <see langword="false"/>.
+    /// </returns>
+    public static bool Equals(StringView a, ReadOnlySpan<char> b) =>
+        a.AsSpan().SequenceEqual(b);
+
     /// <summary>
     /// Determines whether two specified <see cref="StringView"/> objects have the same value.
     /// </summary>
@@ -891,6 +957,21 @@ public static bool Equals(StringView a, string? b) =>
     public static bool Equals(StringView a, StringView b, StringComparison comparison) =>
         a.AsSpan().Equals(b, comparison);
 
+    /// <summary>
+    /// Determines whether two specified <see cref="StringView"/> objects have the same value
+    /// with the specified comparison rules.
+    /// </summary>
+    /// <param name="a">The first value to compare.</param>
+    /// <param name="b">The second value to compare.</param>
+    /// <param name="comparison">An enumeration value that determines how values are compared.</param>
+    /// <returns>
+    /// <see langword="true"/> if the value of the <paramref name="a"/> parameter
+    /// is equal to the value of <paramref name="b"/> parameter;
+    /// otherwise, <see langword="false"/>.
+    /// </returns>
+    public static bool Equals(StringView a, ReadOnlySpan<char> b, StringComparison comparison) =>
+        a.AsSpan().Equals(b, comparison);
+
     /// <summary>
     /// Determines whether two specified <see cref="StringView"/> objects have the same value
     /// with the specified comparison rules.
@@ -922,6 +1003,22 @@ public static bool Equals(StringView a, string? b, StringComparison comparison)
     public static int CompareOrdinal(StringView a, StringView b) =>
         a.AsSpan().SequenceCompareTo(b);
 
+    /// <summary>
+    /// Compares two specified <see cref="StringView"/> objects and returns an integer
+    /// that indicates their relative position in the sort order.
+    /// </summary>
+    /// <param name="a">The first value to compare.</param>
+    /// <param name="b">The second value to compare.</param>
+    /// <returns>
+    /// A 32-bit signed integer that indicates the lexical relationship between the two comparands.
+    /// A signed integer that indicates the relative order of view and other:
+    ///     - If less than 0, <paramref name="a"/>> precedes <paramref name="b"/> in the sort order.
+    ///     - If 0, <paramref name="a"/>> equals <paramref name="b"/>.
+    ///     - If greater than 0, <paramref name="a"/>> follows <paramref name="b"/> in the sort order.
+    /// </returns>
+    public static int CompareOrdinal(StringView a, ReadOnlySpan<char> b) =>
+        a.AsSpan().SequenceCompareTo(b);
+
     /// <summary>
     /// Compares two specified <see cref="StringView"/> objects and returns an integer
     /// that indicates their relative position in the sort order.
@@ -956,6 +1053,24 @@ public static int CompareOrdinal(StringView a, string? b) =>
     public static int Compare(StringView a, StringView b, StringComparison comparison) =>
         a.AsSpan().CompareTo(b, comparison);
 
+    /// <summary>
+    /// Compares two specified <see cref="StringView"/> objects and returns an integer
+    /// that indicates their relative position in the sort order.
+    /// </summary>
+    /// <param name="a">The first value to compare.</param>
+    /// <param name="b">The second value to compare.</param>
+    /// <param name="comparison">One of the enumeration values
+    /// that specifies the rules to use in the comparison.</param>
+    /// <returns>
+    /// A 32-bit signed integer that indicates the lexical relationship between the two comparands.
+    /// A signed integer that indicates the relative order of view and other:
+    ///     - If less than 0, <paramref name="a"/>> precedes <paramref name="b"/> in the sort order.
+    ///     - If 0, <paramref name="a"/>> equals <paramref name="b"/>.
+    ///     - If greater than 0, <paramref name="a"/>> follows <paramref name="b"/> in the sort order.
+    /// </returns>
+    public static int Compare(StringView a, ReadOnlySpan<char> b, StringComparison comparison) =>
+        a.AsSpan().CompareTo(b, comparison);
+
     /// <summary>
     /// Compares two specified <see cref="StringView"/> objects and returns an integer
     /// that indicates their relative position in the sort order.

Ramstack.Structures/Text/StringViewComparer.cs

@@ -121,6 +121,9 @@ static StringViewComparer Error(StringComparison comparisonType) =>
     /// <param name="options">A bitwise combination of <see cref="CompareOptions"/> values
     /// that specify how the comparison should be performed.</param>
     private sealed class CultureAwareComparer(CompareInfo info, CompareOptions options) : StringViewComparer
+        #if NET9_0_OR_GREATER
+        , IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>
+        #endif
     {
         /// <summary>
         /// A singleton instance of the <see cref="T:CultureAwareComparer"/> class
@@ -147,6 +150,20 @@ public override int GetHashCode(StringView obj) =>
         /// <inheritdoc />
         public override int Compare(StringView x, StringView y) =>
             info.IndexOf(x, y, options);
+
+        #if NET9_0_OR_GREATER
+        /// <inheritdoc />
+        bool IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>.Equals(ReadOnlySpan<char> alternate, StringView other) =>
+            info.IndexOf(alternate, other, options) == 0;
+
+        /// <inheritdoc />
+        int IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>.GetHashCode(ReadOnlySpan<char> alternate) =>
+            info.GetHashCode(alternate, options);
+
+        /// <inheritdoc />
+        StringView IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>.Create(ReadOnlySpan<char> alternate) =>
+            alternate.ToString();
+        #endif
     }
 
     #endregion
@@ -158,6 +175,9 @@ public override int Compare(StringView x, StringView y) =>
     /// that performs a case-sensitive ordinal string comparison.
     /// </summary>
     private sealed class OrdinalComparer : StringViewComparer
+        #if NET9_0_OR_GREATER
+        , IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>
+        #endif
     {
         /// <summary>
         /// A singleton instance of the <see cref="T:OrdinalComparer"/> class.
@@ -175,6 +195,20 @@ public override int Compare(StringView x, StringView y) =>
         /// <inheritdoc />
         public override int GetHashCode(StringView obj) =>
             obj.GetHashCode();
+
+        #if NET9_0_OR_GREATER
+        /// <inheritdoc />
+        bool IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>.Equals(ReadOnlySpan<char> alternate, StringView other) =>
+            alternate.SequenceEqual(other);
+
+        /// <inheritdoc />
+        int IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>.GetHashCode(ReadOnlySpan<char> alternate) =>
+            string.GetHashCode(alternate);
+
+        /// <inheritdoc />
+        StringView IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>.Create(ReadOnlySpan<char> alternate) =>
+            alternate.ToString();
+        #endif
     }
 
     #endregion
@@ -186,6 +220,9 @@ public override int GetHashCode(StringView obj) =>
     /// that performs a case-insensitive ordinal string comparison.
     /// </summary>
     private sealed class OrdinalIgnoreCaseComparer : StringViewComparer
+        #if NET9_0_OR_GREATER
+        , IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>
+        #endif
     {
         /// <summary>
         /// A singleton instance of the <see cref="T:OrdinalIgnoreCaseComparer"/> class.
@@ -203,6 +240,20 @@ public override int Compare(StringView x, StringView y) =>
         /// <inheritdoc />
         public override int GetHashCode(StringView obj) =>
             obj.GetHashCode(StringComparison.OrdinalIgnoreCase);
+
+        #if NET9_0_OR_GREATER
+        /// <inheritdoc />
+        bool IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>.Equals(ReadOnlySpan<char> alternate, StringView other) =>
+            alternate.Equals(other, StringComparison.OrdinalIgnoreCase);
+
+        /// <inheritdoc />
+        int IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>.GetHashCode(ReadOnlySpan<char> alternate) =>
+            string.GetHashCode(alternate, StringComparison.OrdinalIgnoreCase);
+
+        /// <inheritdoc />
+        StringView IAlternateEqualityComparer<ReadOnlySpan<char>, StringView>.Create(ReadOnlySpan<char> alternate) =>
+            alternate.ToString();
+        #endif
     }
 
     #endregion