JsonPathComparer
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace System.ClientModel.Primitives
{
internal class JsonPathComparer : IEqualityComparer<byte[]>
{
[System.Runtime.CompilerServices.Nullable(1)]
internal static readonly JsonPathComparer Default = new JsonPathComparer();
[System.Runtime.CompilerServices.NullableContext(2)]
public bool Equals(byte[] x, byte[] y)
{
if (x == y)
return true;
if (x == null || y == null)
return false;
return x.AsSpan().SequenceEqual(y.AsSpan());
}
[System.Runtime.CompilerServices.NullableContext(1)]
public int GetHashCode(byte[] obj)
{
return GetHashCode(obj.AsSpan());
}
public bool Equals(ReadOnlySpan<byte> alternate, [System.Runtime.CompilerServices.Nullable(1)] byte[] other)
{
if (other == null)
return false;
return alternate.SequenceEqual(other.AsSpan());
}
public int GetHashCode(ReadOnlySpan<byte> alternate)
{
int num = 17;
for (int i = 0; i < alternate.Length; i++) {
num = num * 31 + alternate[i];
}
return num;
}
[return: System.Runtime.CompilerServices.Nullable(1)]
public byte[] Create(ReadOnlySpan<byte> alternate)
{
return alternate.ToArray();
}
public void Normalize(ReadOnlySpan<byte> jsonPath, Span<byte> buffer, out int bytesWritten)
{
ReadOnlySpan<byte> readOnlySpan = jsonPath;
bytesWritten = 0;
int length = jsonPath.Length;
int num = 0;
bool flag = false;
bool flag2 = false;
ReadOnlySpan<byte> readOnlySpan2;
for (int i = 0; i < length; i++) {
byte b = jsonPath[i];
if (b == 91 && i + 1 < length && (jsonPath[i + 1] == 39 || jsonPath[i + 1] == 34)) {
readOnlySpan2 = readOnlySpan.Slice(0, num);
readOnlySpan2.CopyTo(buffer.Slice(bytesWritten));
readOnlySpan = readOnlySpan.Slice(num + 2);
bytesWritten += num;
num = 0;
buffer[bytesWritten++] = 46;
i++;
flag = true;
} else if (b == 93 && i - 1 >= 0 && (jsonPath[i - 1] == 39 || jsonPath[i - 1] == 34)) {
num--;
readOnlySpan2 = readOnlySpan.Slice(0, num);
readOnlySpan2.CopyTo(buffer.Slice(bytesWritten));
readOnlySpan = readOnlySpan.Slice(num + 2);
bytesWritten += num;
num = 0;
if (flag2) {
buffer[bytesWritten++] = 39;
buffer[bytesWritten++] = 93;
flag2 = false;
}
flag = false;
} else if (((b == 46) & flag) && !flag2) {
buffer[bytesWritten - 1] = 91;
buffer[bytesWritten++] = 39;
flag2 = true;
num++;
} else {
num++;
}
}
if (num > 0) {
readOnlySpan2 = readOnlySpan.Slice(0, num);
readOnlySpan2.CopyTo(buffer.Slice(bytesWritten));
bytesWritten += num;
}
}
public unsafe int GetNormalizedHashCode(ReadOnlySpan<byte> jsonPath)
{
int length = jsonPath.Length;
Span<byte> span = new Span<byte>(stackalloc byte[(int)(uint)length], length);
Normalize(jsonPath, span, out int bytesWritten);
span = span.Slice(0, bytesWritten);
return GetHashCode(span);
}
public unsafe bool NormalizedEquals(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y)
{
if (x.SequenceEqual(y))
return true;
int length = x.Length;
Span<byte> buffer = new Span<byte>(stackalloc byte[(int)(uint)length], length);
length = y.Length;
Span<byte> buffer2 = new Span<byte>(stackalloc byte[(int)(uint)length], length);
Normalize(x, buffer, out int bytesWritten);
Normalize(y, buffer2, out int bytesWritten2);
if (bytesWritten != bytesWritten2)
return false;
return buffer.Slice(0, bytesWritten).SequenceEqual(buffer2.Slice(0, bytesWritten2));
}
}
}