public static bool TryReadUntill <TSequence>(ref BufferReader <TSequence> reader, out ReadOnlyBuffer <byte> bytes, byte delimiter) where TSequence : ISequence <ReadOnlyMemory <byte> >, ISlicable { var copy = reader; var start = reader.Position; while (!reader.End) { SequencePosition end = reader.Position; if (reader.Read() == delimiter) { bytes = reader.Sequence.Slice(start, end); return(true); } } reader = copy; bytes = default; return(false); }
public static bool TryReadUntill <TSequence>(ref BufferReader <TSequence> reader, out ReadOnlyBuffer <byte> bytes, ReadOnlySpan <byte> delimiter) where TSequence : ISequence <ReadOnlyMemory <byte> >, ISlicable { if (delimiter.Length == 0) { bytes = default; return(true); } int matched = 0; var copy = reader; var start = reader.Position; var end = reader.Position; while (!reader.End) { if (reader.Read() == delimiter[matched]) { matched++; } else { end = reader.Position; matched = 0; } if (matched >= delimiter.Length) { bytes = reader.Sequence.Slice(start, end); return(true); } } reader = copy; bytes = default; return(false); }
/// <summary> /// /// </summary> public Enumerator(ReadOnlyBuffer <T> readOnlyBuffer) { _readOnlyBuffer = readOnlyBuffer; _currentMemory = default; _next = readOnlyBuffer.Start; }
public bool Equals(ReadOnlyBuffer <T> other) { return(other.Equals(this)); }
public ReadOnlyBytes(ReadOnlyBuffer <byte> buffer) : this(buffer, null, buffer.Length) { }
public ReadOnlyBytes(ReadOnlyBuffer <byte> first, IReadOnlyBufferList <byte> rest) : this(first, rest, rest == null?first.Length:Unspecified) { }
public static void Pipe(this IBufferOperation transformation, ReadOnlyBuffer <byte> source, IOutput destination) { int afterMergeSlice = 0; // Assign 'remainder' to something formally stack-referring. // The default classification is "returnable, not referring to stack", we want the opposite in this case. ReadOnlySpan <byte> remainder = stackalloc byte[0]; Span <byte> stackSpan = stackalloc byte[stackLength]; Position poisition = default; while (source.TryGet(ref poisition, out var sourceBuffer)) { Span <byte> outputSpan = destination.GetSpan(); ReadOnlySpan <byte> sourceSpan = sourceBuffer.Span; if (!remainder.IsEmpty) { int leftOverBytes = remainder.Length; remainder.CopyTo(stackSpan); int amountToCopy = Math.Min(sourceSpan.Length, stackSpan.Length - leftOverBytes); sourceSpan.Slice(0, amountToCopy).CopyTo(stackSpan.Slice(leftOverBytes)); int amountOfData = leftOverBytes + amountToCopy; Span <byte> spanToTransform = stackSpan.Slice(0, amountOfData); TryTransformWithRemainder: OperationStatus status = transformation.Execute(spanToTransform, outputSpan, out int bytesConsumed, out int bytesWritten); if (status != OperationStatus.Done) { destination.Advance(bytesWritten); spanToTransform = spanToTransform.Slice(bytesConsumed); if (status == OperationStatus.DestinationTooSmall) { outputSpan = destination.GetSpan(); if (outputSpan.Length - bytesWritten < 3) { return; // no more output space, user decides what to do. } goto TryTransformWithRemainder; } else { if (status == OperationStatus.InvalidData) { continue; // source buffer contains invalid bytes, user decides what to do for fallback } // at this point, status = TransformationStatus.NeedMoreSourceData // left over bytes in stack span remainder = spanToTransform; } continue; } else // success { afterMergeSlice = bytesConsumed - remainder.Length; remainder = Span <byte> .Empty; destination.Advance(bytesWritten); outputSpan = destination.GetSpan(); } } TryTransform: OperationStatus result = transformation.Execute(sourceSpan.Slice(afterMergeSlice), outputSpan, out int consumed, out int written); afterMergeSlice = 0; destination.Advance(written); sourceSpan = sourceSpan.Slice(consumed); if (result == OperationStatus.Done) { continue; } // Not successful if (result == OperationStatus.DestinationTooSmall) { destination.GetMemory(); // output buffer is too small outputSpan = destination.GetSpan(); if (outputSpan.Length - written < 3) { return; // no more output space, user decides what to do. } goto TryTransform; } else { if (result == OperationStatus.InvalidData) { continue; // source buffer contains invalid bytes, user decides what to do for fallback } // at this point, result = TransformationStatus.NeedMoreSourceData // left over bytes in source span remainder = sourceSpan; } } return; }
public BytesReader(ReadOnlyBuffer <byte> bytes) : this(bytes, SymbolTable.InvariantUtf8) { }
public BytesReader(ReadOnlyBuffer <byte> bytes) : this(bytes, TextEncoder.Utf8) { }