/// <summary>
/// Add metadata for a term/field pair to this instance of match data.
/// </summary>
/// <param name="term">The term this match data is associated with.</param>
/// <param name="field">The field in which the term was found.</param>
/// <param name="metadata">The metadata recorded about this term in this field.</param>
public void Add(string term, string field, FieldMatchMetadata metadata)
{
if (!Posting.ContainsKey(term))
{
Posting.Add(term, new FieldMatches
{
{
field,
metadata
}
});
return;
}
FieldMatches termMetadata = Posting[term];
if (!termMetadata.ContainsKey(field))
{
termMetadata.Add(field, metadata);
return;
}
foreach (string key in metadata.Keys)
{
FieldMatchMetadata fieldMetadata = termMetadata[field];
if (fieldMetadata.ContainsKey(key))
{
fieldMetadata[key] = fieldMetadata[key].Concat(metadata[key]).ToList();
}
else
{
fieldMetadata[key] = metadata[key];
}
}
}
public override InvertedIndexEntry Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
if (reader.TokenType != JsonTokenType.StartObject)
{
throw new JsonException("An inverted index entry can only be deserialized from an object.");
}
var result = new InvertedIndexEntry();
reader.ReadOrThrow();
while (reader.AdvanceTo(JsonTokenType.PropertyName, JsonTokenType.EndObject) != JsonTokenType.EndObject)
{
string fieldName = reader.ReadValue <string>(options);
if (fieldName is "_index")
{
result.Index = reader.ReadValue <int>(options);
}
else
{
var fieldMatches = new FieldMatches();
reader.AdvanceTo(JsonTokenType.StartObject);
while (reader.AdvanceTo(JsonTokenType.PropertyName, JsonTokenType.EndObject) != JsonTokenType.EndObject)
{
string token = reader.ReadValue <string>(options);
var metadata = new FieldMatchMetadata();
reader.AdvanceTo(JsonTokenType.StartObject);
while (reader.AdvanceTo(JsonTokenType.PropertyName, JsonTokenType.EndObject) != JsonTokenType.EndObject)
{
string metadataName = reader.ReadValue <string>(options);
reader.AdvanceTo(JsonTokenType.StartArray);
reader.ReadOrThrow();
var data = new List <object?>();
while (reader.TokenType != JsonTokenType.EndArray)
{
// Special-case known metadata
if (metadataName is "position")
{
data.Add(JsonSerializer.Deserialize <Slice>(ref reader, options));
}
else
{
data.Add(reader.ReadObject(options));
}
}
reader.ReadOrThrow();
metadata.Add(metadataName, data);
}
reader.ReadOrThrow();
fieldMatches.Add(token, metadata);
}
reader.ReadOrThrow();
result.Add(fieldName, fieldMatches);
}
}
reader.ReadOrThrow();
return(result);
}
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);
}
