Merge pull request #2 from Open-NET-Libraries/dev

V3 update

Author: electricessence

README.md

@@ -1,5 +1,47 @@
 # Open.Text
 
-A set of useful classes for working with strings and formatting values.
+A set of useful classes for working with strings, spans, and value formatting.
 
 [![NuGet](https://img.shields.io/nuget/v/Open.Text.svg)](https://www.nuget.org/packages/Open.Text/)
+
+## Features
+
+* v3.x is a major overhaul with much improved methods and expanded tests and coverage.
+* Avoids allocation wherever possible.
+
+### String vs Span Equality
+
+Optimized `.Equals(...)` extension methods for comparing spans and strings.
+
+### String & Span Splitting
+
+#### `SplitToEnumerable`
+
+Returns each string segment of the split through an enumerable instead of all at once in an array.
+
+#### `SplitToMemory`
+
+Produces an enumerable where each segment is yielded as a `ReadOnlyMemory<char>`.
+
+### Trimming
+
+#### `TrimStartPattern` & `TrimEndPattern`
+
+Similar to their character trimming counterparts, these methods can trim sequences of characters or regular expression patterns.
+
+### String Segments
+
+Similar to `ArraySegment`, `StringSegment` offers methods for operating on strings without requiring allocation.
+
+Instead of extensions like `string.BeforeFirst(search)`, now you can call `string.First(search).Preceding()`.
+
+### StringBuilder Extensions
+
+* Extensions for adding segments with separators.
+* Extensions for adding spans without creating a string first.
+* Extensions for converting enumerables to a `StringBuilder`.
+
+### ... And more
+
+Various formatting and `Regex` extensions including `Capture.AsSpan()` for getting a `ReadOnlySpan<char>` instead of allocating a string.
+

Source/Extensions.Equals.cs

@@ -0,0 +1,127 @@
+using System;
+
+namespace Open.Text
+{
+	public static partial class Extensions
+	{
+
+		/// <summary>
+		/// Optimized equals for comparing as span vs a string.
+		/// </summary>
+		/// <param name="source">The source span.</param>
+		/// <param name="other">The string to compare to.</param>
+		/// <param name="stringComparison">The string comparison type.</param>
+		/// <returns>True if the are contents equal.</returns>
+		public static bool Equals(this in ReadOnlySpan<char> source, string? other, StringComparison stringComparison)
+		{
+			if (other is null) return false;
+			var len = source.Length;
+			if (len != other.Length) return false;
+			return len switch
+			{
+				0 => true,
+				1 when stringComparison == StringComparison.Ordinal => source[0] == other[0],
+				_ => source.Equals(other.AsSpan(), stringComparison),
+			};
+		}
+
+		/// <summary>
+		/// Optimized equals for comparing as span vs a string.
+		/// </summary>
+		/// <param name="source">The source span.</param>
+		/// <param name="other">The string to compare to.</param>
+		/// <param name="stringComparison">The string comparison type.</param>
+		/// <returns>True if the are contents equal.</returns>
+		public static bool Equals(this in Span<char> source, string? other, StringComparison stringComparison)
+		{
+			if (other is null) return false;
+			var len = source.Length;
+			if (len != other.Length) return false;
+			return len switch
+			{
+				0 => true,
+				1 when stringComparison == StringComparison.Ordinal => source[0] == other[0],
+				_ => MemoryExtensions.Equals(source, other.AsSpan(), stringComparison)
+			};
+		}
+
+		/// <summary>
+		/// Optimized equals for comparing spans.
+		/// </summary>
+		/// <param name="source">The source span.</param>
+		/// <param name="other">The span to compare to.</param>
+		/// <param name="stringComparison">The string comparison type.</param>
+		/// <returns>True if the are contents equal.</returns>
+		public static bool Equals(this in Span<char> source, in Span<char> other, StringComparison stringComparison)
+		{
+			var len = source.Length;
+			if (len != other.Length) return false;
+			return len switch
+			{
+				0 => true,
+				1 when stringComparison == StringComparison.Ordinal => source[0] == other[0],
+				_ => MemoryExtensions.Equals(source, other, stringComparison)
+			};
+		}
+
+		/// <summary>
+		/// Optimized equals for comparing spans.
+		/// </summary>
+		/// <param name="source">The source span.</param>
+		/// <param name="other">The span to compare to.</param>
+		/// <param name="stringComparison">The string comparison type.</param>
+		/// <returns>True if the are contents equal.</returns>
+		public static bool Equals(this in Span<char> source, in ReadOnlySpan<char> other, StringComparison stringComparison)
+		{
+			var len = source.Length;
+			if (len != other.Length) return false;
+			return len switch
+			{
+				0 => true,
+				1 when stringComparison == StringComparison.Ordinal => source[0] == other[0],
+				_ => MemoryExtensions.Equals(source, other, stringComparison)
+			};
+		}
+
+		/// <summary>
+		/// Optimized equals for comparing as string to a span.
+		/// </summary>
+		/// <param name="source">The source string.</param>
+		/// <param name="other">The span to compare to.</param>
+		/// <param name="stringComparison">The string comparison type.</param>
+		/// <returns>True if the are contents equal.</returns>
+		public static bool Equals(this string source, in ReadOnlySpan<char> other, StringComparison stringComparison)
+		{
+			if (source is null)
+				throw new ArgumentNullException(nameof(source));
+			var len = source.Length;
+			if (len != other.Length) return false;
+			return len switch
+			{
+				0 => true,
+				1 when stringComparison == StringComparison.Ordinal => source[0] == other[0],
+				_ => source.AsSpan().Equals(other, stringComparison),
+			};
+		}
+
+		/// <summary>
+		/// Optimized equals for comparing as string to a span.
+		/// </summary>
+		/// <param name="source">The source string.</param>
+		/// <param name="other">The span to compare to.</param>
+		/// <param name="stringComparison">The string comparison type.</param>
+		/// <returns>True if the are contents equal.</returns>
+		public static bool Equals(this string source, in Span<char> other, StringComparison stringComparison)
+		{
+			if (source is null) throw new ArgumentNullException(nameof(source));
+			var len = source.Length;
+			if (len != other.Length) return false;
+			return len switch
+			{
+				0 => true,
+				1 when stringComparison == StringComparison.Ordinal => source[0] == other[0],
+				_ => source.AsSpan().Equals(other, stringComparison),
+			};
+		}
+	}
+}