dynamically-sized buffer of elements
Track object returned by nextElement upon end of stream; Return it later when they ask for LT passed end of input.
index of next element to fill
How deep have we gone?
Size of entire stream is unknown; we only know buffer size from FastQueue
Make sure we have at least one element to remove, even if EOF
Get and remove first element in queue; override {@link FastQueue#remove()}; it's the same, just checks for backtracking.
add n elements to buffer
Return element {@code i} elements ahead of current element. {@code i==0} gets current element. This is not an absolute index into {@link #data} since {@code p} defines the start of the real list.
Implement nextElement to supply a stream of elements to this lookahead buffer. Return EOF upon end of the stream we're pulling from.
Seek to a 0-indexed absolute token index. Normally used to seek backwards in the buffer. Does not force loading of nodes. To preserve backward compatibility, this method allows seeking past the end of the currently buffered data. In this case, the input pointer will be moved but the data will only actually be loaded upon the next call to {@link #consume} or {@link #LT} for {@code k>0}.
Make sure we have 'need' elements from current position p. Last valid p index is data.size()-1. p+need-1 is the data index 'need' elements ahead. If we need 1 element, (p+1-1)==p must be < data.size().
Return string of current buffer contents; non-destructive
Generated using TypeDoc
A lookahead queue that knows how to mark/release locations in the buffer for backtracking purposes. Any markers force the FastQueue superclass to keep all elements until no more markers; then can reset to avoid growing a huge buffer.