/// <inheritdoc />
public override bool TryGetObjectProperty(
IJsonNavigatorNode objectNode,
string propertyName,
out ObjectProperty objectProperty)
{
_ = JsonBinaryNavigator.GetNodeOfType(
JsonNodeType.Object,
objectNode);
Utf8Span utf8StringPropertyName = Utf8Span.TranscodeUtf16(propertyName);
foreach (ObjectProperty objectPropertyNode in this.GetObjectProperties(objectNode))
{
if (this.TryGetBufferedStringValue(objectPropertyNode.NameNode, out Utf8Memory bufferedUtf8StringValue))
{
// First try and see if we can avoid materializing the UTF16 string.
if (utf8StringPropertyName.Equals(bufferedUtf8StringValue.Span))
{
objectProperty = objectPropertyNode;
return(true);
}
}
else
{
if (this.GetStringValue(objectPropertyNode.NameNode) == propertyName)
{
objectProperty = objectPropertyNode;
return(true);
}
}
}
objectProperty = default;
return(false);
}
public static void Equals_NonOrdinal(string str1, string str2, StringComparison comparison, string culture, bool shouldCompareAsEqual)
{
Func <string, string, string, string, string, int> action = (str1, str2, comparison, culture, shouldCompareAsEqual) =>
{
using (new ThreadCultureChange(culture))
{
using BoundedUtf8Span boundedSpan1 = new BoundedUtf8Span(str1);
using BoundedUtf8Span boundedSpan2 = new BoundedUtf8Span(str2);
Utf8Span span1 = boundedSpan1.Span;
Utf8Span span2 = boundedSpan2.Span;
StringComparison comparisonType = Enum.Parse <StringComparison>(comparison);
bool expected = bool.Parse(shouldCompareAsEqual);
Assert.Equal(expected, span1.Equals(span2, comparisonType));
Assert.Equal(expected, span2.Equals(span1, comparisonType));
Assert.Equal(expected, Utf8Span.Equals(span1, span2, comparisonType));
Assert.Equal(expected, Utf8Span.Equals(span2, span1, comparisonType));
}
return(RemoteExecutor.SuccessExitCode);
};
if (culture != null && PlatformDetection.IsUap) // need to apply a culture to the current thread
{
RemoteExecutor.Invoke(action, str1, str2, comparison.ToString(), culture, shouldCompareAsEqual.ToString()).Dispose();
}
else
{
action(str1, str2, comparison.ToString(), culture, shouldCompareAsEqual.ToString());
}
}
private static void AssertEqualOrdinal(Utf8Span span1, Utf8Span span2)
{
Assert.True(span1.Equals(span2));
Assert.True(span2.Equals(span1));
Assert.True(span1.Equals(span2, StringComparison.Ordinal));
Assert.True(span2.Equals(span1, StringComparison.Ordinal));
Assert.True(Utf8Span.Equals(span1, span2));
Assert.True(Utf8Span.Equals(span2, span1));
Assert.True(Utf8Span.Equals(span1, span2, StringComparison.Ordinal));
Assert.True(Utf8Span.Equals(span2, span1, StringComparison.Ordinal));
Assert.True(span1 == span2);
Assert.True(span2 == span1);
Assert.False(span1 != span2);
Assert.False(span2 != span1);
}
internal HttpVersion ReadHttpVersion()
{
ReadOnlySpan <byte> oldBuffer = Buffer;
Utf8Span version = ReadHttpVersionAsUtf8Span();
if (version.Equals(s_Http1_1))
{
return(HttpVersion.V1_1);
}
else if (version.Equals(s_Http2_0))
{
return(HttpVersion.V2_0);
}
else if (version.Equals(s_Http1_0))
{
return(HttpVersion.V1_0);
}
else
{
Buffer = oldBuffer;
return(HttpVersion.Unknown);
}
}
public static void Equals_NonOrdinal(string str1, string str2, StringComparison comparison, string culture, bool shouldCompareAsEqual)
{
using (new ThreadCultureChange(culture))
{
using BoundedUtf8Span boundedSpan1 = new BoundedUtf8Span(str1);
using BoundedUtf8Span boundedSpan2 = new BoundedUtf8Span(str2);
Utf8Span span1 = boundedSpan1.Span;
Utf8Span span2 = boundedSpan2.Span;
Assert.Equal(shouldCompareAsEqual, span1.Equals(span2, comparison));
Assert.Equal(shouldCompareAsEqual, span2.Equals(span1, comparison));
Assert.Equal(shouldCompareAsEqual, Utf8Span.Equals(span1, span2, comparison));
Assert.Equal(shouldCompareAsEqual, Utf8Span.Equals(span2, span1, comparison));
}
}
public override bool Equals(Utf8Span x, Utf8Span y) => Utf8Span.Equals(x, y);
private static SymbolTable CreateSymbolTable(string localeId, Stream resourceStream)
{
const int maxIdLength = 15;
const int recordSize = 20;
var b1 = resourceStream.ReadByte();
var b2 = resourceStream.ReadByte();
var numberOfIDs = b1 * 256 + b2;
var indexSize = numberOfIDs * 20;
var index = new byte[indexSize];
resourceStream.Read(index, 0, indexSize);
byte[] idBytes = new byte[maxIdLength];
var status = Encodings.Utf16.ToUtf8(MemoryMarshal.AsBytes(localeId.AsSpan()), idBytes, out int consumed, out int idByteCount);
if (status != System.Buffers.OperationStatus.Done)
{
throw new Exception("bad locale id");
}
var id = new Utf8Span(idBytes.AsSpan().Slice(0, idByteCount));
int recordStart = -1;
for (int record = 0; record < numberOfIDs; record++)
{
var indexId = index.AsSpan().Slice(record * recordSize, idByteCount);
if (id.Equals(new Utf8Span(indexId))) // found record
{
var indexData = index.AsSpan().Slice(record * recordSize + maxIdLength);
recordStart = 0;
recordStart += indexData[3] * 256 * 256 * 256;
recordStart += indexData[2] * 256 * 256;
recordStart += indexData[1] * 256;
recordStart += indexData[0];
break;
}
}
if (recordStart == -1)
{
throw new Exception("local not found");
}
resourceStream.Position = recordStart;
const int bufferSize = 512;
var data = new byte[bufferSize];
var bytesRead = resourceStream.Read(data, 0, bufferSize);
// TODO: maybe we should store length in the index
var numberOfStrings = ReadUInt16At(data, 0);
Debug.Assert(numberOfStrings == 17);
var utf16digitsAndSymbols = new byte[numberOfStrings][];
for (int stringIndex = 0; stringIndex < numberOfStrings; stringIndex++)
{
var stringStart = ReadUInt16At(data, stringIndex * 2 + 1);
var stringLength = ReadUInt16At(data, stringIndex * 2 + 2);
utf16digitsAndSymbols[stringIndex] = new byte[stringLength];
Array.Copy(data, stringStart, utf16digitsAndSymbols[stringIndex], 0, stringLength);
}
return(new CultureUtf16SymbolTable(utf16digitsAndSymbols));
}
