Lines Matching refs:buffer
63 public static int ParseLength(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
65 return (int)ParseRawVarint32(ref buffer, ref state);
72 public static uint ParseTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
84 // Optimize for the incredibly common case of having at least two bytes left in the buffer,
88 int tmp = buffer[state.bufferPos++];
96 if ((tmp = buffer[state.bufferPos++]) < 128)
105 state.lastTag = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
111 if (SegmentedBufferHelper.IsAtEnd(ref buffer, ref state))
117 state.lastTag = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
132 public static bool MaybeConsumeTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, uint tag)
134 if (PeekTag(ref buffer, ref state) == tag)
147 public static uint PeekTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
155 state.nextTag = ParseTag(ref buffer, ref state);
164 public static ulong ParseRawVarint64(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
168 return ParseRawVarint64SlowPath(ref buffer, ref state);
171 ulong result = buffer[state.bufferPos++];
180 byte b = buffer[state.bufferPos++];
193 private static ulong ParseRawVarint64SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
199 byte b = ReadRawByte(ref buffer, ref state);
214 /// This method is optimised for the case where we've got lots of data in the buffer.
215 /// That means we can check the size just once, then just read directly from the buffer
216 /// without constant rechecking of the buffer length.
218 public static uint ParseRawVarint32(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
222 return ParseRawVarint32SlowPath(ref buffer, ref state);
225 int tmp = buffer[state.bufferPos++];
231 if ((tmp = buffer[state.bufferPos++]) < 128)
238 if ((tmp = buffer[state.bufferPos++]) < 128)
245 if ((tmp = buffer[state.bufferPos++]) < 128)
252 result |= (tmp = buffer[state.bufferPos++]) << 28;
261 if (ReadRawByte(ref buffer, ref state) < 128)
274 private static uint ParseRawVarint32SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
276 int tmp = ReadRawByte(ref buffer, ref state);
282 if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
289 if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
296 if ((tmp = ReadRawByte(ref buffer, ref state)) < 128)
303 result |= (tmp = ReadRawByte(ref buffer, ref state)) << 28;
309 if (ReadRawByte(ref buffer, ref state) < 128)
325 public static uint ParseRawLittleEndian32(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
331 return ParseRawLittleEndian32SlowPath(ref buffer, ref state);
335 uint result = (uint) BinaryPrimitives.ReadUInt64LittleEndian(buffer.Slice(state.bufferPos, ulongLength));
340 private static uint ParseRawLittleEndian32SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
342 uint b1 = ReadRawByte(ref buffer, ref state);
343 uint b2 = ReadRawByte(ref buffer, ref state);
344 uint b3 = ReadRawByte(ref buffer, ref state);
345 uint b4 = ReadRawByte(ref buffer, ref state);
352 public static ulong ParseRawLittleEndian64(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
357 return ParseRawLittleEndian64SlowPath(ref buffer, ref state);
359 ulong result = BinaryPrimitives.ReadUInt64LittleEndian(buffer.Slice(state.bufferPos, length));
364 private static ulong ParseRawLittleEndian64SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
366 ulong b1 = ReadRawByte(ref buffer, ref state);
367 ulong b2 = ReadRawByte(ref buffer, ref state);
368 ulong b3 = ReadRawByte(ref buffer, ref state);
369 ulong b4 = ReadRawByte(ref buffer, ref state);
370 ulong b5 = ReadRawByte(ref buffer, ref state);
371 ulong b6 = ReadRawByte(ref buffer, ref state);
372 ulong b7 = ReadRawByte(ref buffer, ref state);
373 ulong b8 = ReadRawByte(ref buffer, ref state);
381 public static double ParseDouble(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
386 return BitConverter.Int64BitsToDouble((long)ParseRawLittleEndian64(ref buffer, ref state));
389 double result = Unsafe.ReadUnaligned<double>(ref MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, length)));
397 public static float ParseFloat(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
402 return ParseFloatSlow(ref buffer, ref state);
405 float result = Unsafe.ReadUnaligned<float>(ref MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, length)));
410 private static unsafe float ParseFloatSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
417 tempSpan[i] = ReadRawByte(ref buffer, ref state);
434 public static byte[] ReadRawBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
445 buffer.Slice(state.bufferPos, size).CopyTo(bytes);
450 return ReadRawBytesSlow(ref buffer, ref state, size);
453 private static byte[] ReadRawBytesSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
455 ValidateCurrentLimit(ref buffer, ref state, size);
457 if ((!state.segmentedBufferHelper.TotalLength.HasValue && size < buffer.Length) ||
460 // Reading more bytes than are in the buffer, but not an excessive number
464 ReadRawBytesIntoSpan(ref buffer, ref state, size, bytes);
481 buffer.Slice(state.bufferPos, pos).CopyTo(firstChunk);
489 state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
492 buffer.Slice(0, chunk.Length)
499 // OK, got everything. Now concatenate it all into one buffer.
518 public static void SkipRawBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
525 ValidateCurrentLimit(ref buffer, ref state, size);
534 // Skipping more bytes than are in the buffer. First skip what we have.
538 // TODO: If our segmented buffer is backed by a Stream that is seekable, we could skip the bytes more efficiently
541 state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
547 state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
558 public static string ReadString(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
560 int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
561 return ParsingPrimitives.ReadRawString(ref buffer, ref state, length);
568 public static ByteString ReadBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
570 int length = ParsingPrimitives.ParseLength(ref buffer, ref state);
571 return ByteString.AttachBytes(ParsingPrimitives.ReadRawBytes(ref buffer, ref state, length));
581 public static string ReadRawString(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length)
598 ReadOnlySpan<byte> data = buffer.Slice(state.bufferPos, length);
614 return ReadStringSlow(ref buffer, ref state, length);
620 private static string ReadStringSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length)
622 ValidateCurrentLimit(ref buffer, ref state, length);
627 // Read string data into a temporary buffer, either stackalloc'ed or from ArrayPool
628 // Once all data is read then call Encoding.GetString on buffer and return to pool if needed.
642 // in a method with a "ref Span<byte> buffer" argument. If the stackalloc'd span was assigned
646 ReadRawBytesIntoSpan(ref buffer, ref state, length, tempSpan);
666 return WritingPrimitives.Utf8Encoding.GetString(ReadRawBytes(ref buffer, ref state, length), 0, length);
673 private static void ValidateCurrentLimit(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
678 SkipRawBytes(ref buffer, ref state, state.currentLimit - state.totalBytesRetired - state.bufferPos);
685 private static byte ReadRawByte(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
689 state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
691 return buffer[state.bufferPos++];
771 // Data fits in remaining buffer
797 private static void ReadRawBytesIntoSpan(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length, Span<byte> byteSpan)
804 state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, true);
807 ReadOnlySpan<byte> unreadSpan = buffer.Slice(state.bufferPos, Math.Min(remainingByteLength, state.bufferSize - state.bufferPos));