/// <summary> /// Compares two strings. /// </summary> /// <param name="a">The first string to compare.</param> /// <param name="b">The second string to compare.</param> /// <returns>True if the strings are equal.</returns> public bool Equals(ISpanString a, ISpanString b) { // Find optimized comparison methods. if (a is SpanString1 a1) { if (b is SpanString1 b1) { return(_ignoreCase ? SpanString1.EqualsIgnoreCase(a1, b1) : SpanString1.Equals(a1, b1)); } if (b is SpanString2 b2) { return(_ignoreCase ? SpanString1.EqualsIgnoreCase(a1, b2) : SpanString1.Equals(a1, b2)); } throw new ArgumentException($"Second param 'b' is an unknown SpanString type '{b.GetType().Name}', is this a bug?"); } if (a is SpanString2 a2) { if (b is SpanString1 b1) { return(_ignoreCase ? SpanString2.EqualsIgnoreCase(a2, b1) : SpanString2.Equals(a2, b1)); } if (b is SpanString2 b2) { return(_ignoreCase ? SpanString2.EqualsIgnoreCase(a2, b2) : SpanString2.Equals(a2, b2)); } throw new ArgumentException($"Second param 'b' is an unknown SpanString type '{b.GetType().Name}', is this a bug?"); } throw new ArgumentException($"First param 'a' is an unknown SpanString type '{a.GetType().Name}', is this a bug?"); }
/// <summary> /// Gets a hash code for a SpanString. If strings A and B are such that A.Equals(B), then /// they will return the same hash code. /// </summary> public int GetHashCode(SpanString1 s) { if (!_ignoreCase) { return(s.GetHashCode()); } return(s.GetHashCodeIgnoreCase()); }
/// <summary> /// Compares two SpanStrings using an ordinal comparison. /// </summary> /// <param name="a">The first string to compare.</param> /// <param name="b">The second string to compare.</param> /// <returns>True if the strings are equal.</returns> public static bool EqualsIgnoreCase(SpanString2 a, SpanString1 b) { if (a.Length != b.Length) { return(false); } var s1Enum = new Enumerator(a); var s2Enum = new SpanString1.Enumerator(b); for (int i = 0; i < a.Length; i++) { int c1 = SpanStringComparer.ToUpperAscii(s1Enum.Next()); int c2 = SpanStringComparer.ToUpperAscii(s2Enum.Next()); if (c1 != c2) { return(false); } } return(true); }
/// <summary> /// Compares two SpanStrings using an ordinal comparison. /// </summary> /// <param name="a">The first string to compare.</param> /// <param name="b">The second string to compare.</param> /// <returns>True if the strings are equal.</returns> public static bool Equals(SpanString2 a, SpanString1 b) { if (a.Length != b.Length) { return(false); } var s1Enum = new Enumerator(a); var s2Enum = new SpanString1.Enumerator(b); for (int i = 0; i < a.Length; i++) { int c1 = s1Enum.Next(); int c2 = s2Enum.Next(); if (c1 != c2) { return(false); } } return(true); }
/// <summary> /// Compares this instance with a specified SpanString1 using an ordinal /// comparison and case-insensitivity, and indicates whether this /// instance precedes, follows, or appears in the same position /// in the sort order as the specified string. /// </summary> /// <param name="other">The string to compare with this instance.</param> /// <returns>A 32-bit signed integer that indicates whether this instance precedes, follows, or appears in the same position in the sort order as the strB parameter.</returns> public int CompareToIgnoreCase(SpanString1 other) { // Adapted from https://referencesource.microsoft.com/#mscorlib/system/string.cs CompareOrdinalHelper() int length = Math.Min(Length, other.Length); var s1Enum = new Enumerator(this); var s2Enum = new SpanString1.Enumerator(other); for (int i = 0; i < length; i++) { int c1 = SpanStringComparer.ToUpperAscii(s1Enum.Next()); int c2 = SpanStringComparer.ToUpperAscii(s2Enum.Next()); int cmp = c1.CompareTo(c2); if (cmp != 0) { return(cmp); } } // At this point, we have compared all the characters in at least one string. // The longer string will be larger. return(Length - other.Length); }
public Enumerator(SpanString1 ss) { _currentIndex = 0; _spanString = ss; }
/// <summary> /// Compares two strings. /// </summary> /// <param name="a">The first string to compare.</param> /// <param name="b">The second string to compare.</param> /// <returns>True if the strings are equal.</returns> public bool Equals(SpanString1 a, SpanString1 b) { return(_ignoreCase ? SpanString1.EqualsIgnoreCase(a, b) : a.Equals(b)); }