public static bool TryParseUInt32(Utf8Span str, out uint val)
{
if (!Utf8Parser.TryParseUInt32(str, out val, out var consumed) || consumed != str.Length())
{
return(false);
}
return(true);
}
public static uint ParseUInt32(Utf8Span str)
{
if (!Utf8Parser.TryParseUInt32(str, out var value, out var consumed))
{
throw new FormatException();
}
if (consumed != str.Length())
{
throw new FormatException();
}
return(value);
}
public bool TryGetUInt32(Utf8Span property, out uint value)
{
var jsonProperty = new JsonProperty(this, property);
JsonValue jsonValue;
if (!_properties.TryGetValue(jsonProperty, out jsonValue))
{
value = default;
return(false);
}
if (jsonValue.Type != JsonValueType.Number)
{
throw new InvalidOperationException();
}
return(Utf8Parser.TryParseUInt32(jsonValue.Value.Bytes, out value));
}
[InlineData("0")] // min value
private unsafe static void PrimitiveParserByteSpanToUInt32(string text)
{
byte[] utf8ByteArray = Text.Encoding.UTF8.GetBytes(text);
var utf8ByteSpan = new ReadOnlySpan <byte>(utf8ByteArray);
foreach (var iteration in Benchmark.Iterations)
{
using (iteration.StartMeasurement())
{
for (int i = 0; i < TestHelper.LoadIterations; i++)
{
uint value;
Utf8Parser.TryParseUInt32(utf8ByteSpan, out value);
TestHelper.DoNotIgnore(value, 0);
}
}
}
}
private unsafe static void PrimitiveParserByteSpanToUInt32_BytesConsumed_VariableLength()
{
int textLength = s_UInt32TextArray.Length;
byte[][] utf8ByteArray = (byte[][])Array.CreateInstance(typeof(byte[]), textLength);
for (var i = 0; i < textLength; i++)
{
utf8ByteArray[i] = Text.Encoding.UTF8.GetBytes(s_UInt32TextArray[i]);
}
foreach (var iteration in Benchmark.Iterations)
{
using (iteration.StartMeasurement())
{
for (int i = 0; i < TestHelper.LoadIterations; i++)
{
ReadOnlySpan <byte> utf8ByteSpan = utf8ByteArray[i % textLength];
uint value;
int bytesConsumed;
Utf8Parser.TryParseUInt32(utf8ByteSpan, out value, out bytesConsumed);
TestHelper.DoNotIgnore(value, bytesConsumed);
}
}
}
}
public static bool TryParseUInt32 <T>(this T bufferSequence, out uint value, out int consumed) where T : ISequence <ReadOnlyMemory <byte> >
{
value = default;
consumed = default;
Position position = Position.First;
// Fetch the first segment
ReadOnlyMemory <byte> first;
if (!bufferSequence.TryGet(ref position, out first))
{
return(false);
}
// Attempt to parse the first segment. If it works (and it should in most cases), then return success.
bool parsed = Utf8Parser.TryParseUInt32(first.Span, out value, out consumed);
if (parsed && consumed < first.Length)
{
return(true);
}
// Apparently the we need data from the second segment to succesfully parse, and so fetch the second segment.
ReadOnlyMemory <byte> second;
if (!bufferSequence.TryGet(ref position, out second))
{
// if there is no second segment and the first parsed succesfully, return the result of the parsing.
if (parsed)
{
return(true);
}
return(false);
}
// Combine the first, the second, and potentially more segments into a stack allocated buffer
if (first.Length < StackBufferSize)
{
Span <byte> destination = stackalloc byte[StackBufferSize];
first.Span.CopyTo(destination);
var free = destination.Slice(first.Length);
if (second.Length > free.Length)
{
second = second.Slice(0, free.Length);
}
second.Span.CopyTo(free);
free = free.Slice(second.Length);
ReadOnlyMemory <byte> next;
while (free.Length > 0)
{
if (bufferSequence.TryGet(ref position, out next))
{
if (next.Length > free.Length)
{
next = next.Slice(0, free.Length);
}
next.Span.CopyTo(free);
free = free.Slice(next.Length);
}
else
{
break;
}
}
var combinedStackSpan = destination.Slice(0, StackBufferSize - free.Length);
// if the stack allocated buffer parsed succesfully (and for uint it should always do), then return success.
if (Utf8Parser.TryParseUInt32(combinedStackSpan, out value, out consumed))
{
if (consumed < combinedStackSpan.Length || combinedStackSpan.Length < StackBufferSize)
{
return(true);
}
}
}
// for invariant culture, we should never reach this point, as invariant uint text is never longer than 127 bytes.
// I left this code here, as we will need it for custom cultures and possibly when we shrink the stack allocated buffer.
var combinedSpan = bufferSequence.ToSpan();
if (!Utf8Parser.TryParseUInt32(combinedSpan, out value, out consumed))
{
return(false);
}
return(true);
}
