public static ReadOnlySpan <byte> Serialize(this InvertedIndexEntry invertedIndexEntry)
{
using var ms = new MemoryStream();
using var bw = new BinaryWriter(ms);
var context = new SerializeContext(bw);
Serialize(invertedIndexEntry, context);
ms.Position = 0;
return(ms.GetBuffer());
}
public static void Serialize(this InvertedIndexEntry invertedIndexEntry, SerializeContext context)
{
context.Write(invertedIndexEntry.Index);
context.Write(invertedIndexEntry.Count);
foreach (KeyValuePair <string, FieldMatches> pair in invertedIndexEntry)
{
context.Write(pair.Key);
context.Write(pair.Value.Count); // FieldMatches
foreach (KeyValuePair <string, FieldMatchMetadata> fieldMatches in pair.Value)
{
context.Write(fieldMatches.Key);
context.Write(fieldMatches.Value.Count); // FieldMatchMetadata
foreach (KeyValuePair <string, IList <object?> > fieldMatchMetadata in fieldMatches.Value)
{
context.Write(fieldMatchMetadata.Key);
context.Write(fieldMatchMetadata.Value.Count);
foreach (object?meta in fieldMatchMetadata.Value)
{
var type = meta?.GetType();
if (type == null)
{
continue;
}
if (!SerializeContext.KnownTypes.TryGetValue(type, out var serializer))
{
throw new SerializationException($"no serializer registered for '{type.Name}'");
}
if (context.Write(meta != null && type != null))
{
context.Write(type?.AssemblyQualifiedName !);
context.Write(serializer.Item1(meta ?? throw new InvalidOperationException("unexpected null value")));
}
}
}
}
}
}
private static void AssertInvertedIndexEntry(InvertedIndexEntry left, InvertedIndexEntry right)
{
Assert.Equal(left.Index, right.Index);
Assert.Equal(left.Count, right.Count);
var allFieldMatches = left.Zip(right, (fieldMatchesLeft, fieldMatchesRight) =>
{
Assert.Equal(fieldMatchesLeft.Key, fieldMatchesRight.Key);
Assert.Equal(fieldMatchesLeft.Value.Count, fieldMatchesRight.Value.Count);
var allFieldMatchMetadata = fieldMatchesLeft.Value.Zip(fieldMatchesRight.Value, (fieldMatchMetadataLeft, fieldMatchMetadataRight) =>
{
Assert.Equal(fieldMatchMetadataLeft.Key, fieldMatchMetadataRight.Key);
return(true);
}).ToList();
Assert.All(allFieldMatchMetadata, Assert.True);
return(true);
}).ToList();
Assert.All(allFieldMatches, Assert.True);
}
public static InvertedIndexEntry DeserializeInvertedIndexEntry(this DeserializeContext context, ref ReadOnlySpan <byte> buffer)
{
var entry = new InvertedIndexEntry();
entry.Index = context.ReadInt32(ref buffer);
var fieldMatchesCount = context.ReadInt32(ref buffer);
for (var i = 0; i < fieldMatchesCount; i++)
{
var fieldMatches = new FieldMatches();
var fieldMatchesKey = context.ReadString(ref buffer);
var fieldMatchCount = context.ReadInt32(ref buffer);
for (var j = 0; j < fieldMatchCount; j++)
{
var fieldMatchMeta = new FieldMatchMetadata();
var fieldMatchMetaKey = context.ReadString(ref buffer);
var fieldMatchMetaCount = context.ReadInt32(ref buffer);
for (var k = 0; k < fieldMatchMetaCount; k++)
{
var fieldMatchMetaValueKey = context.ReadString(ref buffer);
var fieldMatchMetaValueCount = context.ReadInt32(ref buffer);
var meta = new List <object?>(fieldMatchMetaValueCount);
for (var l = 0; l < fieldMatchMetaValueCount; l++)
{
if (context.ReadBoolean(ref buffer))
{
var typeName = context.ReadString(ref buffer);
var type = Type.GetType(typeName);
if (type == null)
{
throw new SerializationException($"no type named '{typeName}' found in loaded assemblies");
}
if (!SerializeContext.KnownTypes.TryGetValue(type, out var serializer))
{
throw new SerializationException($"no serializer registered for '{type.Name}'");
}
var data = context.ReadBytes(ref buffer);
var deserialized = serializer.Item2(data.ToArray());
meta.Add(deserialized);
}
else
{
meta.Add(null);
}
}
fieldMatchMeta.Add(fieldMatchMetaValueKey, meta);
}
fieldMatches.Add(fieldMatchMetaKey, fieldMatchMeta);
}
entry.Add(fieldMatchesKey, fieldMatches);
}
return(entry);
}
