netcore/System.Private.CoreLib/shared/System/MemoryExtensions.Trim.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Diagnostics;
   6
   7 namespace System
   8 {
   9     public static partial class MemoryExtensions
  10     {
  11         /// <summary>
  12         /// Removes all leading and trailing occurrences of a specified element from the memory.
  13         /// </summary>
  14         /// <param name="memory">The source memory from which the element is removed.</param>
  15         /// <param name="trimElement">The specified element to look for and remove.</param>
  16         public static Memory<T> Trim<T>(this Memory<T> memory, T trimElement)
  17 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
  18             where T : IEquatable<T>
  19 #nullable restore
  20         {
  21             ReadOnlySpan<T> span = memory.Span;
  22             int start = ClampStart(span, trimElement);
  23             int length = ClampEnd(span, start, trimElement);
  24             return memory.Slice(start, length);
  25         }
  26
  27         /// <summary>
  28         /// Removes all leading occurrences of a specified element from the memory.
  29         /// </summary>
  30         /// <param name="memory">The source memory from which the element is removed.</param>
  31         /// <param name="trimElement">The specified element to look for and remove.</param>
  32         public static Memory<T> TrimStart<T>(this Memory<T> memory, T trimElement)
  33 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
  34             where T : IEquatable<T>
  35 #nullable restore
  36             => memory.Slice(ClampStart(memory.Span, trimElement));
  37
  38         /// <summary>
  39         /// Removes all trailing occurrences of a specified element from the memory.
  40         /// </summary>
  41         /// <param name="memory">The source memory from which the element is removed.</param>
  42         /// <param name="trimElement">The specified element to look for and remove.</param>
  43         public static Memory<T> TrimEnd<T>(this Memory<T> memory, T trimElement)
  44 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
  45             where T : IEquatable<T>
  46 #nullable restore
  47             => memory.Slice(0, ClampEnd(memory.Span, 0, trimElement));
  48
  49         /// <summary>
  50         /// Removes all leading and trailing occurrences of a specified element from the memory.
  51         /// </summary>
  52         /// <param name="memory">The source memory from which the element is removed.</param>
  53         /// <param name="trimElement">The specified element to look for and remove.</param>
  54         public static ReadOnlyMemory<T> Trim<T>(this ReadOnlyMemory<T> memory, T trimElement)
  55 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
  56             where T : IEquatable<T>
  57 #nullable restore
  58         {
  59             ReadOnlySpan<T> span = memory.Span;
  60             int start = ClampStart(span, trimElement);
  61             int length = ClampEnd(span, start, trimElement);
  62             return memory.Slice(start, length);
  63         }
  64
  65         /// <summary>
  66         /// Removes all leading occurrences of a specified element from the memory.
  67         /// </summary>
  68         /// <param name="memory">The source memory from which the element is removed.</param>
  69         /// <param name="trimElement">The specified element to look for and remove.</param>
  70         public static ReadOnlyMemory<T> TrimStart<T>(this ReadOnlyMemory<T> memory, T trimElement)
  71 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
  72             where T : IEquatable<T>
  73 #nullable restore
  74             => memory.Slice(ClampStart(memory.Span, trimElement));
  75
  76         /// <summary>
  77         /// Removes all trailing occurrences of a specified element from the memory.
  78         /// </summary>
  79         /// <param name="memory">The source memory from which the element is removed.</param>
  80         /// <param name="trimElement">The specified element to look for and remove.</param>
  81         public static ReadOnlyMemory<T> TrimEnd<T>(this ReadOnlyMemory<T> memory, T trimElement)
  82 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
  83             where T : IEquatable<T>
  84 #nullable restore
  85             => memory.Slice(0, ClampEnd(memory.Span, 0, trimElement));
  86
  87         /// <summary>
  88         /// Removes all leading and trailing occurrences of a specified element from the span.
  89         /// </summary>
  90         /// <param name="span">The source span from which the element is removed.</param>
  91         /// <param name="trimElement">The specified element to look for and remove.</param>
  92         public static Span<T> Trim<T>(this Span<T> span, T trimElement)
  93 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
  94             where T : IEquatable<T>
  95 #nullable restore
  96         {
  97             int start = ClampStart(span, trimElement);
  98             int length = ClampEnd(span, start, trimElement);
  99             return span.Slice(start, length);
 100         }
 101
 102         /// <summary>
 103         /// Removes all leading occurrences of a specified element from the span.
 104         /// </summary>
 105         /// <param name="span">The source span from which the element is removed.</param>
 106         /// <param name="trimElement">The specified element to look for and remove.</param>
 107         public static Span<T> TrimStart<T>(this Span<T> span, T trimElement)
 108 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 109             where T : IEquatable<T>
 110 #nullable restore
 111             => span.Slice(ClampStart(span, trimElement));
 112
 113         /// <summary>
 114         /// Removes all trailing occurrences of a specified element from the span.
 115         /// </summary>
 116         /// <param name="span">The source span from which the element is removed.</param>
 117         /// <param name="trimElement">The specified element to look for and remove.</param>
 118         public static Span<T> TrimEnd<T>(this Span<T> span, T trimElement)
 119 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 120             where T : IEquatable<T>
 121 #nullable restore
 122             => span.Slice(0, ClampEnd(span, 0, trimElement));
 123
 124         /// <summary>
 125         /// Removes all leading and trailing occurrences of a specified element from the span.
 126         /// </summary>
 127         /// <param name="span">The source span from which the element is removed.</param>
 128         /// <param name="trimElement">The specified element to look for and remove.</param>
 129         public static ReadOnlySpan<T> Trim<T>(this ReadOnlySpan<T> span, T trimElement)
 130 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 131             where T : IEquatable<T>
 132 #nullable restore
 133         {
 134             int start = ClampStart(span, trimElement);
 135             int length = ClampEnd(span, start, trimElement);
 136             return span.Slice(start, length);
 137         }
 138
 139         /// <summary>
 140         /// Removes all leading occurrences of a specified element from the span.
 141         /// </summary>
 142         /// <param name="span">The source span from which the element is removed.</param>
 143         /// <param name="trimElement">The specified element to look for and remove.</param>
 144         public static ReadOnlySpan<T> TrimStart<T>(this ReadOnlySpan<T> span, T trimElement)
 145 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 146             where T : IEquatable<T>
 147 #nullable restore
 148             => span.Slice(ClampStart(span, trimElement));
 149
 150         /// <summary>
 151         /// Removes all trailing occurrences of a specified element from the span.
 152         /// </summary>
 153         /// <param name="span">The source span from which the element is removed.</param>
 154         /// <param name="trimElement">The specified element to look for and remove.</param>
 155         public static ReadOnlySpan<T> TrimEnd<T>(this ReadOnlySpan<T> span, T trimElement)
 156 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 157             where T : IEquatable<T>
 158 #nullable restore
 159             => span.Slice(0, ClampEnd(span, 0, trimElement));
 160
 161         /// <summary>
 162         /// Delimits all leading occurrences of a specified element from the span.
 163         /// </summary>
 164         /// <param name="span">The source span from which the element is removed.</param>
 165         /// <param name="trimElement">The specified element to look for and remove.</param>
 166         private static int ClampStart<T>(ReadOnlySpan<T> span, T trimElement)
 167 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 168             where T : IEquatable<T>
 169 #nullable restore
 170         {
 171             int start = 0;
 172
 173             if (trimElement != null)
 174             {
 175                 for (; start < span.Length; start++)
 176                 {
 177                     if (!trimElement.Equals(span[start]))
 178                     {
 179                         break;
 180                     }
 181                 }
 182             }
 183             else
 184             {
 185                 for (; start < span.Length; start++)
 186                 {
 187                     if (span[start] != null)
 188                     {
 189                         break;
 190                     }
 191                 }
 192             }
 193
 194             return start;
 195         }
 196
 197         /// <summary>
 198         /// Delimits all trailing occurrences of a specified element from the span.
 199         /// </summary>
 200         /// <param name="span">The source span from which the element is removed.</param>
 201         /// <param name="start">The start index from which to being searching.</param>
 202         /// <param name="trimElement">The specified element to look for and remove.</param>
 203         private static int ClampEnd<T>(ReadOnlySpan<T> span, int start, T trimElement)
 204 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 205             where T : IEquatable<T>
 206 #nullable restore
 207         {
 208             // Initially, start==len==0. If ClampStart trims all, start==len
 209             Debug.Assert((uint)start <= span.Length);
 210
 211             int end = span.Length - 1;
 212
 213             if (trimElement != null)
 214             {
 215                 for (; end >= start; end--)
 216                 {
 217                     if (!trimElement.Equals(span[end]))
 218                     {
 219                         break;
 220                     }
 221                 }
 222             }
 223             else
 224             {
 225                 for (; end >= start; end--)
 226                 {
 227                     if (span[end] != null)
 228                     {
 229                         break;
 230                     }
 231                 }
 232             }
 233
 234             return end - start + 1;
 235         }
 236
 237         /// <summary>
 238         /// Removes all leading and trailing occurrences of a set of elements specified
 239         /// in a readonly span from the memory.
 240         /// </summary>
 241         /// <param name="memory">The source memory from which the elements are removed.</param>
 242         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 243         /// <remarks>If <paramref name="trimElements"/> is empty, the memory is returned unaltered.</remarks>
 244         public static Memory<T> Trim<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements)
 245 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 246             where T : IEquatable<T>
 247 #nullable restore
 248         {
 249             if (trimElements.Length > 1)
 250             {
 251                 ReadOnlySpan<T> span = memory.Span;
 252                 int start = ClampStart(span, trimElements);
 253                 int length = ClampEnd(span, start, trimElements);
 254                 return memory.Slice(start, length);
 255             }
 256
 257             if (trimElements.Length == 1)
 258             {
 259                 return Trim(memory, trimElements[0]);
 260             }
 261
 262             return memory;
 263         }
 264
 265         /// <summary>
 266         /// Removes all leading occurrences of a set of elements specified
 267         /// in a readonly span from the memory.
 268         /// </summary>
 269         /// <param name="memory">The source memory from which the elements are removed.</param>
 270         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 271         /// <remarks>If <paramref name="trimElements"/> is empty, the memory is returned unaltered.</remarks>
 272         public static Memory<T> TrimStart<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements)
 273 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 274             where T : IEquatable<T>
 275 #nullable restore
 276         {
 277             if (trimElements.Length > 1)
 278             {
 279                 return memory.Slice(ClampStart(memory.Span, trimElements));
 280             }
 281
 282             if (trimElements.Length == 1)
 283             {
 284                 return TrimStart(memory, trimElements[0]);
 285             }
 286
 287             return memory;
 288         }
 289
 290         /// <summary>
 291         /// Removes all trailing occurrences of a set of elements specified
 292         /// in a readonly span from the memory.
 293         /// </summary>
 294         /// <param name="memory">The source memory from which the elements are removed.</param>
 295         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 296         /// <remarks>If <paramref name="trimElements"/> is empty, the memory is returned unaltered.</remarks>
 297         public static Memory<T> TrimEnd<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements)
 298 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 299             where T : IEquatable<T>
 300 #nullable restore
 301         {
 302             if (trimElements.Length > 1)
 303             {
 304                 return memory.Slice(0, ClampEnd(memory.Span, 0, trimElements));
 305             }
 306
 307             if (trimElements.Length == 1)
 308             {
 309                 return TrimEnd(memory, trimElements[0]);
 310             }
 311
 312             return memory;
 313         }
 314
 315         /// <summary>
 316         /// Removes all leading and trailing occurrences of a set of elements specified
 317         /// in a readonly span from the memory.
 318         /// </summary>
 319         /// <param name="memory">The source memory from which the elements are removed.</param>
 320         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 321         /// <remarks>If <paramref name="trimElements"/> is empty, the memory is returned unaltered.</remarks>
 322         public static ReadOnlyMemory<T> Trim<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements)
 323 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 324             where T : IEquatable<T>
 325 #nullable restore
 326         {
 327             if (trimElements.Length > 1)
 328             {
 329                 ReadOnlySpan<T> span = memory.Span;
 330                 int start = ClampStart(span, trimElements);
 331                 int length = ClampEnd(span, start, trimElements);
 332                 return memory.Slice(start, length);
 333             }
 334
 335             if (trimElements.Length == 1)
 336             {
 337                 return Trim(memory, trimElements[0]);
 338             }
 339
 340             return memory;
 341         }
 342
 343         /// <summary>
 344         /// Removes all leading occurrences of a set of elements specified
 345         /// in a readonly span from the memory.
 346         /// </summary>
 347         /// <param name="memory">The source memory from which the elements are removed.</param>
 348         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 349         /// <remarks>If <paramref name="trimElements"/> is empty, the memory is returned unaltered.</remarks>
 350         public static ReadOnlyMemory<T> TrimStart<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements)
 351 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 352             where T : IEquatable<T>
 353 #nullable restore
 354         {
 355             if (trimElements.Length > 1)
 356             {
 357                 return memory.Slice(ClampStart(memory.Span, trimElements));
 358             }
 359
 360             if (trimElements.Length == 1)
 361             {
 362                 return TrimStart(memory, trimElements[0]);
 363             }
 364
 365             return memory;
 366         }
 367
 368         /// <summary>
 369         /// Removes all trailing occurrences of a set of elements specified
 370         /// in a readonly span from the memory.
 371         /// </summary>
 372         /// <param name="memory">The source memory from which the elements are removed.</param>
 373         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 374         /// <remarks>If <paramref name="trimElements"/> is empty, the memory is returned unaltered.</remarks>
 375         public static ReadOnlyMemory<T> TrimEnd<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements)
 376 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 377             where T : IEquatable<T>
 378 #nullable restore
 379         {
 380             if (trimElements.Length > 1)
 381             {
 382                 return memory.Slice(0, ClampEnd(memory.Span, 0, trimElements));
 383             }
 384
 385             if (trimElements.Length == 1)
 386             {
 387                 return TrimEnd(memory, trimElements[0]);
 388             }
 389
 390             return memory;
 391         }
 392
 393         /// <summary>
 394         /// Removes all leading and trailing occurrences of a set of elements specified
 395         /// in a readonly span from the span.
 396         /// </summary>
 397         /// <param name="span">The source span from which the elements are removed.</param>
 398         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 399         /// <remarks>If <paramref name="trimElements"/> is empty, the span is returned unaltered.</remarks>
 400         public static Span<T> Trim<T>(this Span<T> span, ReadOnlySpan<T> trimElements)
 401 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 402             where T : IEquatable<T>
 403 #nullable restore
 404         {
 405             if (trimElements.Length > 1)
 406             {
 407                 int start = ClampStart(span, trimElements);
 408                 int length = ClampEnd(span, start, trimElements);
 409                 return span.Slice(start, length);
 410             }
 411
 412             if (trimElements.Length == 1)
 413             {
 414                 return Trim(span, trimElements[0]);
 415             }
 416
 417             return span;
 418         }
 419
 420         /// <summary>
 421         /// Removes all leading occurrences of a set of elements specified
 422         /// in a readonly span from the span.
 423         /// </summary>
 424         /// <param name="span">The source span from which the elements are removed.</param>
 425         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 426         /// <remarks>If <paramref name="trimElements"/> is empty, the span is returned unaltered.</remarks>
 427         public static Span<T> TrimStart<T>(this Span<T> span, ReadOnlySpan<T> trimElements)
 428 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 429             where T : IEquatable<T>
 430 #nullable restore
 431         {
 432             if (trimElements.Length > 1)
 433             {
 434                 return span.Slice(ClampStart(span, trimElements));
 435             }
 436
 437             if (trimElements.Length == 1)
 438             {
 439                 return TrimStart(span, trimElements[0]);
 440             }
 441
 442             return span;
 443         }
 444
 445         /// <summary>
 446         /// Removes all trailing occurrences of a set of elements specified
 447         /// in a readonly span from the span.
 448         /// </summary>
 449         /// <param name="span">The source span from which the elements are removed.</param>
 450         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 451         /// <remarks>If <paramref name="trimElements"/> is empty, the span is returned unaltered.</remarks>
 452         public static Span<T> TrimEnd<T>(this Span<T> span, ReadOnlySpan<T> trimElements)
 453 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 454             where T : IEquatable<T>
 455 #nullable restore
 456         {
 457             if (trimElements.Length > 1)
 458             {
 459                 return span.Slice(0, ClampEnd(span, 0, trimElements));
 460             }
 461
 462             if (trimElements.Length == 1)
 463             {
 464                 return TrimEnd(span, trimElements[0]);
 465             }
 466
 467             return span;
 468         }
 469
 470         /// <summary>
 471         /// Removes all leading and trailing occurrences of a set of elements specified
 472         /// in a readonly span from the span.
 473         /// </summary>
 474         /// <param name="span">The source span from which the elements are removed.</param>
 475         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 476         /// <remarks>If <paramref name="trimElements"/> is empty, the span is returned unaltered.</remarks>
 477         public static ReadOnlySpan<T> Trim<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements)
 478 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 479             where T : IEquatable<T>
 480 #nullable restore
 481         {
 482             if (trimElements.Length > 1)
 483             {
 484                 int start = ClampStart(span, trimElements);
 485                 int length = ClampEnd(span, start, trimElements);
 486                 return span.Slice(start, length);
 487             }
 488
 489             if (trimElements.Length == 1)
 490             {
 491                 return Trim(span, trimElements[0]);
 492             }
 493
 494             return span;
 495         }
 496
 497         /// <summary>
 498         /// Removes all leading occurrences of a set of elements specified
 499         /// in a readonly span from the span.
 500         /// </summary>
 501         /// <param name="span">The source span from which the elements are removed.</param>
 502         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 503         /// <remarks>If <paramref name="trimElements"/> is empty, the span is returned unaltered.</remarks>
 504         public static ReadOnlySpan<T> TrimStart<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements)
 505 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 506             where T : IEquatable<T>
 507 #nullable restore
 508         {
 509             if (trimElements.Length > 1)
 510             {
 511                 return span.Slice(ClampStart(span, trimElements));
 512             }
 513
 514             if (trimElements.Length == 1)
 515             {
 516                 return TrimStart(span, trimElements[0]);
 517             }
 518
 519             return span;
 520         }
 521
 522         /// <summary>
 523         /// Removes all trailing occurrences of a set of elements specified
 524         /// in a readonly span from the span.
 525         /// </summary>
 526         /// <param name="span">The source span from which the elements are removed.</param>
 527         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 528         /// <remarks>If <paramref name="trimElements"/> is empty, the span is returned unaltered.</remarks>
 529         public static ReadOnlySpan<T> TrimEnd<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements)
 530 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 531             where T : IEquatable<T>
 532 #nullable restore
 533         {
 534             if (trimElements.Length > 1)
 535             {
 536                 return span.Slice(0, ClampEnd(span, 0, trimElements));
 537             }
 538
 539             if (trimElements.Length == 1)
 540             {
 541                 return TrimEnd(span, trimElements[0]);
 542             }
 543
 544             return span;
 545         }
 546
 547         /// <summary>
 548         /// Delimits all leading occurrences of a set of elements specified
 549         /// in a readonly span from the span.
 550         /// </summary>
 551         /// <param name="span">The source span from which the elements are removed.</param>
 552         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 553         private static int ClampStart<T>(ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements)
 554 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 555             where T : IEquatable<T>
 556 #nullable restore
 557         {
 558             int start = 0;
 559             for (; start < span.Length; start++)
 560             {
 561                 if (!trimElements.Contains(span[start]))
 562                 {
 563                     break;
 564                 }
 565             }
 566
 567             return start;
 568         }
 569
 570         /// <summary>
 571         /// Delimits all trailing occurrences of a set of elements specified
 572         /// in a readonly span from the span.
 573         /// </summary>
 574         /// <param name="span">The source span from which the elements are removed.</param>
 575         /// <param name="start">The start index from which to being searching.</param>
 576         /// <param name="trimElements">The span which contains the set of elements to remove.</param>
 577         private static int ClampEnd<T>(ReadOnlySpan<T> span, int start, ReadOnlySpan<T> trimElements)
 578 #nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
 579             where T : IEquatable<T>
 580 #nullable restore
 581         {
 582             // Initially, start==len==0. If ClampStart trims all, start==len
 583             Debug.Assert((uint)start <= span.Length);
 584
 585             int end = span.Length - 1;
 586             for (; end >= start; end--)
 587             {
 588                 if (!trimElements.Contains(span[end]))
 589                 {
 590                     break;
 591                 }
 592             }
 593
 594             return end - start + 1;
 595         }
 596
 597         /// <summary>
 598         /// Removes all leading and trailing white-space characters from the memory.
 599         /// </summary>
 600         /// <param name="memory">The source memory from which the characters are removed.</param>
 601         public static Memory<char> Trim(this Memory<char> memory)
 602         {
 603             ReadOnlySpan<char> span = memory.Span;
 604             int start = ClampStart(span);
 605             int length = ClampEnd(span, start);
 606             return memory.Slice(start, length);
 607         }
 608
 609         /// <summary>
 610         /// Removes all leading white-space characters from the memory.
 611         /// </summary>
 612         /// <param name="memory">The source memory from which the characters are removed.</param>
 613         public static Memory<char> TrimStart(this Memory<char> memory)
 614             => memory.Slice(ClampStart(memory.Span));
 615
 616         /// <summary>
 617         /// Removes all trailing white-space characters from the memory.
 618         /// </summary>
 619         /// <param name="memory">The source memory from which the characters are removed.</param>
 620         public static Memory<char> TrimEnd(this Memory<char> memory)
 621             => memory.Slice(0, ClampEnd(memory.Span, 0));
 622
 623         /// <summary>
 624         /// Removes all leading and trailing white-space characters from the memory.
 625         /// </summary>
 626         /// <param name="memory">The source memory from which the characters are removed.</param>
 627         public static ReadOnlyMemory<char> Trim(this ReadOnlyMemory<char> memory)
 628         {
 629             ReadOnlySpan<char> span = memory.Span;
 630             int start = ClampStart(span);
 631             int length = ClampEnd(span, start);
 632             return memory.Slice(start, length);
 633         }
 634
 635         /// <summary>
 636         /// Removes all leading white-space characters from the memory.
 637         /// </summary>
 638         /// <param name="memory">The source memory from which the characters are removed.</param>
 639         public static ReadOnlyMemory<char> TrimStart(this ReadOnlyMemory<char> memory)
 640             => memory.Slice(ClampStart(memory.Span));
 641
 642         /// <summary>
 643         /// Removes all trailing white-space characters from the memory.
 644         /// </summary>
 645         /// <param name="memory">The source memory from which the characters are removed.</param>
 646         public static ReadOnlyMemory<char> TrimEnd(this ReadOnlyMemory<char> memory)
 647             => memory.Slice(0, ClampEnd(memory.Span, 0));
 648
 649         /// <summary>
 650         /// Removes all leading and trailing white-space characters from the span.
 651         /// </summary>
 652         /// <param name="span">The source span from which the characters are removed.</param>
 653         public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span)
 654         {
 655             int start = 0;
 656             for (; start < span.Length; start++)
 657             {
 658                 if (!char.IsWhiteSpace(span[start]))
 659                 {
 660                     break;
 661                 }
 662             }
 663
 664             int end = span.Length - 1;
 665             for (; end > start; end--)
 666             {
 667                 if (!char.IsWhiteSpace(span[end]))
 668                 {
 669                     break;
 670                 }
 671             }
 672
 673             return span.Slice(start, end - start + 1);
 674         }
 675
 676         /// <summary>
 677         /// Removes all leading white-space characters from the span.
 678         /// </summary>
 679         /// <param name="span">The source span from which the characters are removed.</param>
 680         public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span)
 681         {
 682             int start = 0;
 683             for (; start < span.Length; start++)
 684             {
 685                 if (!char.IsWhiteSpace(span[start]))
 686                 {
 687                     break;
 688                 }
 689             }
 690
 691             return span.Slice(start);
 692         }
 693
 694         /// <summary>
 695         /// Removes all trailing white-space characters from the span.
 696         /// </summary>
 697         /// <param name="span">The source span from which the characters are removed.</param>
 698         public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span)
 699         {
 700             int end = span.Length - 1;
 701             for (; end >= 0; end--)
 702             {
 703                 if (!char.IsWhiteSpace(span[end]))
 704                 {
 705                     break;
 706                 }
 707             }
 708
 709             return span.Slice(0, end + 1);
 710         }
 711
 712         /// <summary>
 713         /// Removes all leading and trailing occurrences of a specified character from the span.
 714         /// </summary>
 715         /// <param name="span">The source span from which the character is removed.</param>
 716         /// <param name="trimChar">The specified character to look for and remove.</param>
 717         public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span, char trimChar)
 718         {
 719             int start = 0;
 720             for (; start < span.Length; start++)
 721             {
 722                 if (span[start] != trimChar)
 723                 {
 724                     break;
 725                 }
 726             }
 727
 728             int end = span.Length - 1;
 729             for (; end > start; end--)
 730             {
 731                 if (span[end] != trimChar)
 732                 {
 733                     break;
 734                 }
 735             }
 736
 737             return span.Slice(start, end - start + 1);
 738         }
 739
 740         /// <summary>
 741         /// Removes all leading occurrences of a specified character from the span.
 742         /// </summary>
 743         /// <param name="span">The source span from which the character is removed.</param>
 744         /// <param name="trimChar">The specified character to look for and remove.</param>
 745         public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span, char trimChar)
 746         {
 747             int start = 0;
 748             for (; start < span.Length; start++)
 749             {
 750                 if (span[start] != trimChar)
 751                 {
 752                     break;
 753                 }
 754             }
 755
 756             return span.Slice(start);
 757         }
 758
 759         /// <summary>
 760         /// Removes all trailing occurrences of a specified character from the span.
 761         /// </summary>
 762         /// <param name="span">The source span from which the character is removed.</param>
 763         /// <param name="trimChar">The specified character to look for and remove.</param>
 764         public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span, char trimChar)
 765         {
 766             int end = span.Length - 1;
 767             for (; end >= 0; end--)
 768             {
 769                 if (span[end] != trimChar)
 770                 {
 771                     break;
 772                 }
 773             }
 774
 775             return span.Slice(0, end + 1);
 776         }
 777
 778         /// <summary>
 779         /// Removes all leading and trailing occurrences of a set of characters specified
 780         /// in a readonly span from the span.
 781         /// </summary>
 782         /// <param name="span">The source span from which the characters are removed.</param>
 783         /// <param name="trimChars">The span which contains the set of characters to remove.</param>
 784         /// <remarks>If <paramref name="trimChars"/> is empty, white-space characters are removed instead.</remarks>
 785         public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars)
 786             => span.TrimStart(trimChars).TrimEnd(trimChars);
 787
 788         /// <summary>
 789         /// Removes all leading occurrences of a set of characters specified
 790         /// in a readonly span from the span.
 791         /// </summary>
 792         /// <param name="span">The source span from which the characters are removed.</param>
 793         /// <param name="trimChars">The span which contains the set of characters to remove.</param>
 794         /// <remarks>If <paramref name="trimChars"/> is empty, white-space characters are removed instead.</remarks>
 795         public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars)
 796         {
 797             if (trimChars.IsEmpty)
 798             {
 799                 return span.TrimStart();
 800             }
 801
 802             int start = 0;
 803             for (; start < span.Length; start++)
 804             {
 805                 for (int i = 0; i < trimChars.Length; i++)
 806                 {
 807                     if (span[start] == trimChars[i])
 808                     {
 809                         goto Next;
 810                     }
 811                 }
 812
 813                 break;
 814             Next:
 815                 ;
 816             }
 817
 818             return span.Slice(start);
 819         }
 820
 821         /// <summary>
 822         /// Removes all trailing occurrences of a set of characters specified
 823         /// in a readonly span from the span.
 824         /// </summary>
 825         /// <param name="span">The source span from which the characters are removed.</param>
 826         /// <param name="trimChars">The span which contains the set of characters to remove.</param>
 827         /// <remarks>If <paramref name="trimChars"/> is empty, white-space characters are removed instead.</remarks>
 828         public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars)
 829         {
 830             if (trimChars.IsEmpty)
 831             {
 832                 return span.TrimEnd();
 833             }
 834
 835             int end = span.Length - 1;
 836             for (; end >= 0; end--)
 837             {
 838                 for (int i = 0; i < trimChars.Length; i++)
 839                 {
 840                     if (span[end] == trimChars[i])
 841                     {
 842                         goto Next;
 843                     }
 844                 }
 845
 846                 break;
 847             Next:
 848                 ;
 849             }
 850
 851             return span.Slice(0, end + 1);
 852         }
 853
 854         /// <summary>
 855         /// Removes all leading and trailing white-space characters from the span.
 856         /// </summary>
 857         /// <param name="span">The source span from which the characters are removed.</param>
 858         public static Span<char> Trim(this Span<char> span)
 859         {
 860             int start = ClampStart(span);
 861             int length = ClampEnd(span, start);
 862             return span.Slice(start, length);
 863         }
 864
 865         /// <summary>
 866         /// Removes all leading white-space characters from the span.
 867         /// </summary>
 868         /// <param name="span">The source span from which the characters are removed.</param>
 869         public static Span<char> TrimStart(this Span<char> span)
 870             => span.Slice(ClampStart(span));
 871
 872         /// <summary>
 873         /// Removes all trailing white-space characters from the span.
 874         /// </summary>
 875         /// <param name="span">The source span from which the characters are removed.</param>
 876         public static Span<char> TrimEnd(this Span<char> span)
 877             => span.Slice(0, ClampEnd(span, 0));
 878
 879         /// <summary>
 880         /// Delimits all leading occurrences of whitespace charecters from the span.
 881         /// </summary>
 882         /// <param name="span">The source span from which the characters are removed.</param>
 883         private static int ClampStart(ReadOnlySpan<char> span)
 884         {
 885             int start = 0;
 886
 887             for (; start < span.Length; start++)
 888             {
 889                 if (!char.IsWhiteSpace(span[start]))
 890                 {
 891                     break;
 892                 }
 893             }
 894
 895             return start;
 896         }
 897
 898         /// <summary>
 899         /// Delimits all trailing occurrences of whitespace charecters from the span.
 900         /// </summary>
 901         /// <param name="span">The source span from which the characters are removed.</param>
 902         /// <param name="start">The start index from which to being searching.</param>
 903         private static int ClampEnd(ReadOnlySpan<char> span, int start)
 904         {
 905             // Initially, start==len==0. If ClampStart trims all, start==len
 906             Debug.Assert((uint)start <= span.Length);
 907
 908             int end = span.Length - 1;
 909
 910             for (; end >= start; end--)
 911             {
 912                 if (!char.IsWhiteSpace(span[end]))
 913                 {
 914                     break;
 915                 }
 916             }
 917
 918             return end - start + 1;
 919         }
 920     }
 921 }