mcs/class/corlib/corefx/SequenceReader.Search.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 using System.Runtime.CompilerServices;
   7
   8 namespace System.Buffers
   9 {
  10 #if __MonoCS__
  11     public ref partial struct SequenceReader<T> where T : IEquatable<T>
  12 #else
  13     public ref partial struct SequenceReader<T> where T : unmanaged, IEquatable<T>
  14 #endif
  15     {
  16         /// <summary>
  17         /// Try to read everything up to the given <paramref name="delimiter"/>.
  18         /// </summary>
  19         /// <param name="span">The read data, if any.</param>
  20         /// <param name="delimiter">The delimiter to look for.</param>
  21         /// <param name="advancePastDelimiter">True to move past the <paramref name="delimiter"/> if found.</param>
  22         /// <returns>True if the <paramref name="delimiter"/> was found.</returns>
  23         public bool TryReadTo(out ReadOnlySpan<T> span, T delimiter, bool advancePastDelimiter = true)
  24         {
  25             ReadOnlySpan<T> remaining = UnreadSpan;
  26             int index = remaining.IndexOf(delimiter);
  27
  28             if (index != -1)
  29             {
  30                 span = index == 0 ? default : remaining.Slice(0, index);
  31                 AdvanceCurrentSpan(index + (advancePastDelimiter ? 1 : 0));
  32                 return true;
  33             }
  34
  35             return TryReadToSlow(out span, delimiter, advancePastDelimiter);
  36         }
  37
  38         private bool TryReadToSlow(out ReadOnlySpan<T> span, T delimiter, bool advancePastDelimiter)
  39         {
  40             if (!TryReadToInternal(out ReadOnlySequence<T> sequence, delimiter, advancePastDelimiter, CurrentSpan.Length - CurrentSpanIndex))
  41             {
  42                 span = default;
  43                 return false;
  44             }
  45
  46             span = sequence.IsSingleSegment ? sequence.First.Span : sequence.ToArray();
  47             return true;
  48         }
  49
  50         /// <summary>
  51         /// Try to read everything up to the given <paramref name="delimiter"/>, ignoring delimiters that are
  52         /// preceded by <paramref name="delimiterEscape"/>.
  53         /// </summary>
  54         /// <param name="span">The read data, if any.</param>
  55         /// <param name="delimiter">The delimiter to look for.</param>
  56         /// <param name="delimiterEscape">If found prior to <paramref name="delimiter"/> it will skip that occurrence.</param>
  57         /// <param name="advancePastDelimiter">True to move past the <paramref name="delimiter"/> if found.</param>
  58         /// <returns>True if the <paramref name="delimiter"/> was found.</returns>
  59         public bool TryReadTo(out ReadOnlySpan<T> span, T delimiter, T delimiterEscape, bool advancePastDelimiter = true)
  60         {
  61             ReadOnlySpan<T> remaining = UnreadSpan;
  62             int index = remaining.IndexOf(delimiter);
  63
  64             if ((index > 0 && !remaining[index - 1].Equals(delimiterEscape)) || index == 0)
  65             {
  66                 span = remaining.Slice(0, index);
  67                 AdvanceCurrentSpan(index + (advancePastDelimiter ? 1 : 0));
  68                 return true;
  69             }
  70
  71             // This delimiter might be skipped, go down the slow path
  72             return TryReadToSlow(out span, delimiter, delimiterEscape, index, advancePastDelimiter);
  73         }
  74
  75         private bool TryReadToSlow(out ReadOnlySpan<T> span, T delimiter, T delimiterEscape, int index, bool advancePastDelimiter)
  76         {
  77             if (!TryReadToSlow(out ReadOnlySequence<T> sequence, delimiter, delimiterEscape, index, advancePastDelimiter))
  78             {
  79                 span = default;
  80                 return false;
  81             }
  82
  83             Debug.Assert(sequence.Length > 0);
  84             span = sequence.IsSingleSegment ? sequence.First.Span : sequence.ToArray();
  85             return true;
  86         }
  87
  88         private bool TryReadToSlow(out ReadOnlySequence<T> sequence, T delimiter, T delimiterEscape, int index, bool advancePastDelimiter)
  89         {
  90             SequenceReader<T> copy = this;
  91
  92             ReadOnlySpan<T> remaining = UnreadSpan;
  93             bool priorEscape = false;
  94
  95             do
  96             {
  97                 if (index >= 0)
  98                 {
  99                     if (index == 0 && priorEscape)
 100                     {
 101                         // We were in the escaped state, so skip this delimiter
 102                         priorEscape = false;
 103                         Advance(index + 1);
 104                         remaining = UnreadSpan;
 105                         goto Continue;
 106                     }
 107                     else if (index > 0 && remaining[index - 1].Equals(delimiterEscape))
 108                     {
 109                         // This delimiter might be skipped
 110
 111                         // Count our escapes
 112                         int escapeCount = 1;
 113                         int i = index - 2;
 114                         for (; i >= 0; i--)
 115                         {
 116                             if (!remaining[i].Equals(delimiterEscape))
 117                                 break;
 118                         }
 119                         if (i < 0 && priorEscape)
 120                         {
 121                             // Started and ended with escape, increment once more
 122                             escapeCount++;
 123                         }
 124                         escapeCount += index - 2 - i;
 125
 126                         if ((escapeCount & 1) != 0)
 127                         {
 128                             // An odd escape count means we're currently escaped,
 129                             // skip the delimiter and reset escaped state.
 130                             Advance(index + 1);
 131                             priorEscape = false;
 132                             remaining = UnreadSpan;
 133                             goto Continue;
 134                         }
 135                     }
 136
 137                     // Found the delimiter. Move to it, slice, then move past it.
 138                     AdvanceCurrentSpan(index);
 139
 140                     sequence = Sequence.Slice(copy.Position, Position);
 141                     if (advancePastDelimiter)
 142                     {
 143                         Advance(1);
 144                     }
 145                     return true;
 146                 }
 147                 else
 148                 {
 149                     // No delimiter, need to check the end of the span for odd number of escapes then advance
 150                     if (remaining.Length > 0 && remaining[remaining.Length - 1].Equals(delimiterEscape))
 151                     {
 152                         int escapeCount = 1;
 153                         int i = remaining.Length - 2;
 154                         for (; i >= 0; i--)
 155                         {
 156                             if (!remaining[i].Equals(delimiterEscape))
 157                                 break;
 158                         }
 159
 160                         escapeCount += remaining.Length - 2 - i;
 161                         if (i < 0 && priorEscape)
 162                             priorEscape = (escapeCount & 1) == 0;   // equivalent to incrementing escapeCount before setting priorEscape
 163                         else
 164                             priorEscape = (escapeCount & 1) != 0;
 165                     }
 166                     else
 167                     {
 168                         priorEscape = false;
 169                     }
 170                 }
 171
 172                 // Nothing in the current span, move to the end, checking for the skip delimiter
 173                 AdvanceCurrentSpan(remaining.Length);
 174                 remaining = CurrentSpan;
 175
 176             Continue:
 177                 index = remaining.IndexOf(delimiter);
 178             } while (!End);
 179
 180             // Didn't find anything, reset our original state.
 181             this = copy;
 182             sequence = default;
 183             return false;
 184         }
 185
 186         /// <summary>
 187         /// Try to read everything up to the given <paramref name="delimiter"/>.
 188         /// </summary>
 189         /// <param name="sequence">The read data, if any.</param>
 190         /// <param name="delimiter">The delimiter to look for.</param>
 191         /// <param name="advancePastDelimiter">True to move past the <paramref name="delimiter"/> if found.</param>
 192         /// <returns>True if the <paramref name="delimiter"/> was found.</returns>
 193         public bool TryReadTo(out ReadOnlySequence<T> sequence, T delimiter, bool advancePastDelimiter = true)
 194         {
 195             return TryReadToInternal(out sequence, delimiter, advancePastDelimiter);
 196         }
 197
 198         private bool TryReadToInternal(out ReadOnlySequence<T> sequence, T delimiter, bool advancePastDelimiter, int skip = 0)
 199         {
 200             Debug.Assert(skip >= 0);
 201             SequenceReader<T> copy = this;
 202             if (skip > 0)
 203                 Advance(skip);
 204             ReadOnlySpan<T> remaining = UnreadSpan;
 205
 206             while (_moreData)
 207             {
 208                 int index = remaining.IndexOf(delimiter);
 209                 if (index != -1)
 210                 {
 211                     // Found the delimiter. Move to it, slice, then move past it.
 212                     if (index > 0)
 213                     {
 214                         AdvanceCurrentSpan(index);
 215                     }
 216
 217                     sequence = Sequence.Slice(copy.Position, Position);
 218                     if (advancePastDelimiter)
 219                     {
 220                         Advance(1);
 221                     }
 222                     return true;
 223                 }
 224
 225                 AdvanceCurrentSpan(remaining.Length);
 226                 remaining = CurrentSpan;
 227             }
 228
 229             // Didn't find anything, reset our original state.
 230             this = copy;
 231             sequence = default;
 232             return false;
 233         }
 234
 235         /// <summary>
 236         /// Try to read everything up to the given <paramref name="delimiter"/>, ignoring delimiters that are
 237         /// preceded by <paramref name="delimiterEscape"/>.
 238         /// </summary>
 239         /// <param name="sequence">The read data, if any.</param>
 240         /// <param name="delimiter">The delimiter to look for.</param>
 241         /// <param name="delimiterEscape">If found prior to <paramref name="delimiter"/> it will skip that occurrence.</param>
 242         /// <param name="advancePastDelimiter">True to move past the <paramref name="delimiter"/> if found.</param>
 243         /// <returns>True if the <paramref name="delimiter"/> was found.</returns>
 244         public bool TryReadTo(out ReadOnlySequence<T> sequence, T delimiter, T delimiterEscape, bool advancePastDelimiter = true)
 245         {
 246             SequenceReader<T> copy = this;
 247
 248             ReadOnlySpan<T> remaining = UnreadSpan;
 249             bool priorEscape = false;
 250
 251             while (_moreData)
 252             {
 253                 int index = remaining.IndexOf(delimiter);
 254                 if (index != -1)
 255                 {
 256                     if (index == 0 && priorEscape)
 257                     {
 258                         // We were in the escaped state, so skip this delimiter
 259                         priorEscape = false;
 260                         Advance(index + 1);
 261                         remaining = UnreadSpan;
 262                         continue;
 263                     }
 264                     else if (index > 0 && remaining[index - 1].Equals(delimiterEscape))
 265                     {
 266                         // This delimiter might be skipped
 267
 268                         // Count our escapes
 269                         int escapeCount = 0;
 270                         for (int i = index; i > 0 && remaining[i - 1].Equals(delimiterEscape); i--, escapeCount++)
 271                             ;
 272                         if (escapeCount == index && priorEscape)
 273                         {
 274                             // Started and ended with escape, increment once more
 275                             escapeCount++;
 276                         }
 277
 278                         priorEscape = false;
 279                         if ((escapeCount & 1) != 0)
 280                         {
 281                             // Odd escape count means we're in the escaped state, so skip this delimiter
 282                             Advance(index + 1);
 283                             remaining = UnreadSpan;
 284                             continue;
 285                         }
 286                     }
 287
 288                     // Found the delimiter. Move to it, slice, then move past it.
 289                     if (index > 0)
 290                     {
 291                         Advance(index);
 292                     }
 293
 294                     sequence = Sequence.Slice(copy.Position, Position);
 295                     if (advancePastDelimiter)
 296                     {
 297                         Advance(1);
 298                     }
 299                     return true;
 300                 }
 301
 302                 // No delimiter, need to check the end of the span for odd number of escapes then advance
 303                 {
 304                     int escapeCount = 0;
 305                     for (int i = remaining.Length; i > 0 && remaining[i - 1].Equals(delimiterEscape); i--, escapeCount++)
 306                         ;
 307                     if (priorEscape && escapeCount == remaining.Length)
 308                     {
 309                         escapeCount++;
 310                     }
 311                     priorEscape = escapeCount % 2 != 0;
 312                 }
 313
 314                 // Nothing in the current span, move to the end, checking for the skip delimiter
 315                 Advance(remaining.Length);
 316                 remaining = CurrentSpan;
 317             }
 318
 319             // Didn't find anything, reset our original state.
 320             this = copy;
 321             sequence = default;
 322             return false;
 323         }
 324
 325         /// <summary>
 326         /// Try to read everything up to the given <paramref name="delimiters"/>.
 327         /// </summary>
 328         /// <param name="span">The read data, if any.</param>
 329         /// <param name="delimiters">The delimiters to look for.</param>
 330         /// <param name="advancePastDelimiter">True to move past the first found instance of any of the given <paramref name="delimiters"/>.</param>
 331         /// <returns>True if any of the <paramref name="delimiters"/> were found.</returns>
 332         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 333         public bool TryReadToAny(out ReadOnlySpan<T> span, ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true)
 334         {
 335             ReadOnlySpan<T> remaining = UnreadSpan;
 336             int index = delimiters.Length == 2
 337                 ? remaining.IndexOfAny(delimiters[0], delimiters[1])
 338                 : remaining.IndexOfAny(delimiters);
 339
 340             if (index != -1)
 341             {
 342                 span = remaining.Slice(0, index);
 343                 Advance(index + (advancePastDelimiter ? 1 : 0));
 344                 return true;
 345             }
 346
 347             return TryReadToAnySlow(out span, delimiters, advancePastDelimiter);
 348         }
 349
 350         private bool TryReadToAnySlow(out ReadOnlySpan<T> span, ReadOnlySpan<T> delimiters, bool advancePastDelimiter)
 351         {
 352             if (!TryReadToAnyInternal(out ReadOnlySequence<T> sequence, delimiters, advancePastDelimiter, CurrentSpan.Length - CurrentSpanIndex))
 353             {
 354                 span = default;
 355                 return false;
 356             }
 357
 358             span = sequence.IsSingleSegment ? sequence.First.Span : sequence.ToArray();
 359             return true;
 360         }
 361
 362         /// <summary>
 363         /// Try to read everything up to the given <paramref name="delimiters"/>.
 364         /// </summary>
 365         /// <param name="sequence">The read data, if any.</param>
 366         /// <param name="delimiters">The delimiters to look for.</param>
 367         /// <param name="advancePastDelimiter">True to move past the first found instance of any of the given <paramref name="delimiters"/>.</param>
 368         /// <returns>True if any of the <paramref name="delimiters"/> were found.</returns>
 369         public bool TryReadToAny(out ReadOnlySequence<T> sequence, ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true)
 370         {
 371             return TryReadToAnyInternal(out sequence, delimiters, advancePastDelimiter);
 372         }
 373
 374         private bool TryReadToAnyInternal(out ReadOnlySequence<T> sequence, ReadOnlySpan<T> delimiters, bool advancePastDelimiter, int skip = 0)
 375         {
 376             SequenceReader<T> copy = this;
 377             if (skip > 0)
 378                 Advance(skip);
 379             ReadOnlySpan<T> remaining = UnreadSpan;
 380
 381             while (!End)
 382             {
 383                 int index = delimiters.Length == 2
 384                     ? remaining.IndexOfAny(delimiters[0], delimiters[1])
 385                     : remaining.IndexOfAny(delimiters);
 386
 387                 if (index != -1)
 388                 {
 389                     // Found one of the delimiters. Move to it, slice, then move past it.
 390                     if (index > 0)
 391                     {
 392                         AdvanceCurrentSpan(index);
 393                     }
 394
 395                     sequence = Sequence.Slice(copy.Position, Position);
 396                     if (advancePastDelimiter)
 397                     {
 398                         Advance(1);
 399                     }
 400                     return true;
 401                 }
 402
 403                 Advance(remaining.Length);
 404                 remaining = CurrentSpan;
 405             }
 406
 407             // Didn't find anything, reset our original state.
 408             this = copy;
 409             sequence = default;
 410             return false;
 411         }
 412
 413         /// <summary>
 414         /// Try to read data until the entire given <paramref name="delimiter"/> matches.
 415         /// </summary>
 416         /// <param name="sequence">The read data, if any.</param>
 417         /// <param name="delimiter">The multi (T) delimiter.</param>
 418         /// <param name="advancePastDelimiter">True to move past the <paramref name="delimiter"/> if found.</param>
 419         /// <returns>True if the <paramref name="delimiter"/> was found.</returns>
 420         public bool TryReadTo(out ReadOnlySequence<T> sequence, ReadOnlySpan<T> delimiter, bool advancePastDelimiter = true)
 421         {
 422             if (delimiter.Length == 0)
 423             {
 424                 sequence = default;
 425                 return true;
 426             }
 427
 428             SequenceReader<T> copy = this;
 429
 430             bool advanced = false;
 431             while (!End)
 432             {
 433                 if (!TryReadTo(out sequence, delimiter[0], advancePastDelimiter: false))
 434                 {
 435                     this = copy;
 436                     return false;
 437                 }
 438
 439                 if (delimiter.Length == 1)
 440                 {
 441                     if (advancePastDelimiter)
 442                     {
 443                         Advance(1);
 444                     }
 445                     return true;
 446                 }
 447
 448                 if (IsNext(delimiter))
 449                 {
 450                     // Probably a faster way to do this, potentially by avoiding the Advance in the previous TryReadTo call
 451                     if (advanced)
 452                     {
 453                         sequence = copy.Sequence.Slice(copy.Consumed, Consumed - copy.Consumed);
 454                     }
 455
 456                     if (advancePastDelimiter)
 457                     {
 458                         Advance(delimiter.Length);
 459                     }
 460                     return true;
 461                 }
 462                 else
 463                 {
 464                     Advance(1);
 465                     advanced = true;
 466                 }
 467             }
 468
 469             this = copy;
 470             sequence = default;
 471             return false;
 472         }
 473
 474         /// <summary>
 475         /// Advance until the given <paramref name="delimiter"/>, if found.
 476         /// </summary>
 477         /// <param name="delimiter">The delimiter to search for.</param>
 478         /// <param name="advancePastDelimiter">True to move past the <paramref name="delimiter"/> if found.</param>
 479         /// <returns>True if the given <paramref name="delimiter"/> was found.</returns>
 480         public bool TryAdvanceTo(T delimiter, bool advancePastDelimiter = true)
 481         {
 482             ReadOnlySpan<T> remaining = UnreadSpan;
 483             int index = remaining.IndexOf(delimiter);
 484             if (index != -1)
 485             {
 486                 Advance(advancePastDelimiter ? index + 1 : index);
 487                 return true;
 488             }
 489
 490             return TryReadToInternal(out _, delimiter, advancePastDelimiter);
 491         }
 492
 493         /// <summary>
 494         /// Advance until any of the given <paramref name="delimiters"/>, if found.
 495         /// </summary>
 496         /// <param name="delimiters">The delimiters to search for.</param>
 497         /// <param name="advancePastDelimiter">True to move past the first found instance of any of the given <paramref name="delimiters"/>.</param>
 498         /// <returns>True if any of the given <paramref name="delimiters"/> were found.</returns>
 499         public bool TryAdvanceToAny(ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true)
 500         {
 501             ReadOnlySpan<T> remaining = UnreadSpan;
 502             int index = remaining.IndexOfAny(delimiters);
 503             if (index != -1)
 504             {
 505                 AdvanceCurrentSpan(index + (advancePastDelimiter ? 1 : 0));
 506                 return true;
 507             }
 508
 509             return TryReadToAnyInternal(out _, delimiters, advancePastDelimiter);
 510         }
 511
 512         /// <summary>
 513         /// Advance past consecutive instances of the given <paramref name="value"/>.
 514         /// </summary>
 515         /// <returns>How many positions the reader has been advanced.</returns>
 516         public long AdvancePast(T value)
 517         {
 518             long start = Consumed;
 519
 520             do
 521             {
 522                 // Advance past all matches in the current span
 523                 int i;
 524                 for (i = CurrentSpanIndex; i < CurrentSpan.Length && CurrentSpan[i].Equals(value); i++)
 525                 {
 526                 }
 527
 528                 int advanced = i - CurrentSpanIndex;
 529                 if (advanced == 0)
 530                 {
 531                     // Didn't advance at all in this span, exit.
 532                     break;
 533                 }
 534
 535                 AdvanceCurrentSpan(advanced);
 536
 537                 // If we're at postion 0 after advancing and not at the End,
 538                 // we're in a new span and should continue the loop.
 539             } while (CurrentSpanIndex == 0 && !End);
 540
 541             return Consumed - start;
 542         }
 543
 544         /// <summary>
 545         /// Skip consecutive instances of any of the given <paramref name="values"/>.
 546         /// </summary>
 547         /// <returns>How many positions the reader has been advanced.</returns>
 548         public long AdvancePastAny(ReadOnlySpan<T> values)
 549         {
 550             long start = Consumed;
 551
 552             do
 553             {
 554                 // Advance past all matches in the current span
 555                 int i;
 556                 for (i = CurrentSpanIndex; i < CurrentSpan.Length && values.IndexOf(CurrentSpan[i]) != -1; i++)
 557                 {
 558                 }
 559
 560                 int advanced = i - CurrentSpanIndex;
 561                 if (advanced == 0)
 562                 {
 563                     // Didn't advance at all in this span, exit.
 564                     break;
 565                 }
 566
 567                 AdvanceCurrentSpan(advanced);
 568
 569                 // If we're at postion 0 after advancing and not at the End,
 570                 // we're in a new span and should continue the loop.
 571             } while (CurrentSpanIndex == 0 && !End);
 572
 573             return Consumed - start;
 574         }
 575
 576         /// <summary>
 577         /// Advance past consecutive instances of any of the given values.
 578         /// </summary>
 579         /// <returns>How many positions the reader has been advanced.</returns>
 580         public long AdvancePastAny(T value0, T value1, T value2, T value3)
 581         {
 582             long start = Consumed;
 583
 584             do
 585             {
 586                 // Advance past all matches in the current span
 587                 int i;
 588                 for (i = CurrentSpanIndex; i < CurrentSpan.Length; i++)
 589                 {
 590                     T value = CurrentSpan[i];
 591                     if (!value.Equals(value0) && !value.Equals(value1) && !value.Equals(value2) && !value.Equals(value3))
 592                     {
 593                         break;
 594                     }
 595                 }
 596
 597                 int advanced = i - CurrentSpanIndex;
 598                 if (advanced == 0)
 599                 {
 600                     // Didn't advance at all in this span, exit.
 601                     break;
 602                 }
 603
 604                 AdvanceCurrentSpan(advanced);
 605
 606                 // If we're at postion 0 after advancing and not at the End,
 607                 // we're in a new span and should continue the loop.
 608             } while (CurrentSpanIndex == 0 && !End);
 609
 610             return Consumed - start;
 611         }
 612
 613         /// <summary>
 614         /// Advance past consecutive instances of any of the given values.
 615         /// </summary>
 616         /// <returns>How many positions the reader has been advanced.</returns>
 617         public long AdvancePastAny(T value0, T value1, T value2)
 618         {
 619             long start = Consumed;
 620
 621             do
 622             {
 623                 // Advance past all matches in the current span
 624                 int i;
 625                 for (i = CurrentSpanIndex; i < CurrentSpan.Length; i++)
 626                 {
 627                     T value = CurrentSpan[i];
 628                     if (!value.Equals(value0) && !value.Equals(value1) && !value.Equals(value2))
 629                     {
 630                         break;
 631                     }
 632                 }
 633
 634                 int advanced = i - CurrentSpanIndex;
 635                 if (advanced == 0)
 636                 {
 637                     // Didn't advance at all in this span, exit.
 638                     break;
 639                 }
 640
 641                 AdvanceCurrentSpan(advanced);
 642
 643                 // If we're at postion 0 after advancing and not at the End,
 644                 // we're in a new span and should continue the loop.
 645             } while (CurrentSpanIndex == 0 && !End);
 646
 647             return Consumed - start;
 648         }
 649
 650         /// <summary>
 651         /// Advance past consecutive instances of any of the given values.
 652         /// </summary>
 653         /// <returns>How many positions the reader has been advanced.</returns>
 654         public long AdvancePastAny(T value0, T value1)
 655         {
 656             long start = Consumed;
 657
 658             do
 659             {
 660                 // Advance past all matches in the current span
 661                 int i;
 662                 for (i = CurrentSpanIndex; i < CurrentSpan.Length; i++)
 663                 {
 664                     T value = CurrentSpan[i];
 665                     if (!value.Equals(value0) && !value.Equals(value1))
 666                     {
 667                         break;
 668                     }
 669                 }
 670
 671                 int advanced = i - CurrentSpanIndex;
 672                 if (advanced == 0)
 673                 {
 674                     // Didn't advance at all in this span, exit.
 675                     break;
 676                 }
 677
 678                 AdvanceCurrentSpan(advanced);
 679
 680                 // If we're at postion 0 after advancing and not at the End,
 681                 // we're in a new span and should continue the loop.
 682             } while (CurrentSpanIndex == 0 && !End);
 683
 684             return Consumed - start;
 685         }
 686
 687         /// <summary>
 688         /// Check to see if the given <paramref name="next"/> value is next.
 689         /// </summary>
 690         /// <param name="next">The value to compare the next items to.</param>
 691         /// <param name="advancePast">Move past the <paramref name="next"/> value if found.</param>
 692         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 693         public bool IsNext(T next, bool advancePast = false)
 694         {
 695             if (End)
 696                 return false;
 697
 698             if (CurrentSpan[CurrentSpanIndex].Equals(next))
 699             {
 700                 if (advancePast)
 701                 {
 702                     AdvanceCurrentSpan(1);
 703                 }
 704                 return true;
 705             }
 706             return false;
 707         }
 708
 709         /// <summary>
 710         /// Check to see if the given <paramref name="next"/> values are next.
 711         /// </summary>
 712         /// <param name="next">The span to compare the next items to.</param>
 713         /// <param name="advancePast">Move past the <paramref name="next"/> values if found.</param>
 714         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 715         public bool IsNext(ReadOnlySpan<T> next, bool advancePast = false)
 716         {
 717             ReadOnlySpan<T> unread = UnreadSpan;
 718             if (unread.StartsWith(next))
 719             {
 720                 if (advancePast)
 721                 {
 722                     AdvanceCurrentSpan(next.Length);
 723                 }
 724                 return true;
 725             }
 726
 727             // Only check the slow path if there wasn't enough to satisfy next
 728             return unread.Length < next.Length && IsNextSlow(next, advancePast);
 729         }
 730
 731         private unsafe bool IsNextSlow(ReadOnlySpan<T> next, bool advancePast)
 732         {
 733             ReadOnlySpan<T> currentSpan = UnreadSpan;
 734
 735             // We should only come in here if we need more data than we have in our current span
 736             Debug.Assert(currentSpan.Length < next.Length);
 737
 738             int fullLength = next.Length;
 739             SequencePosition nextPosition = _nextPosition;
 740
 741             while (next.StartsWith(currentSpan))
 742             {
 743                 if (next.Length == currentSpan.Length)
 744                 {
 745                     // Fully matched
 746                     if (advancePast)
 747                     {
 748                         Advance(fullLength);
 749                     }
 750                     return true;
 751                 }
 752
 753                 // Need to check the next segment
 754                 while (true)
 755                 {
 756                     if (!Sequence.TryGet(ref nextPosition, out ReadOnlyMemory<T> nextSegment, advance: true))
 757                     {
 758                         // Nothing left
 759                         return false;
 760                     }
 761
 762                     if (nextSegment.Length > 0)
 763                     {
 764                         next = next.Slice(currentSpan.Length);
 765                         currentSpan = nextSegment.Span;
 766                         if (currentSpan.Length > next.Length)
 767                         {
 768                             currentSpan = currentSpan.Slice(0, next.Length);
 769                         }
 770                         break;
 771                     }
 772                 }
 773             }
 774
 775             return false;
 776         }
 777     }
 778 }