public QueryMatchID RegisterSetQuery(SetQueryArgs queryArgs)
{
var queryMatchID = QueryMatchID.Generate();
EnqueueUpdate(new BufferedAction(true, queryMatchID, queryArgs));
return(queryMatchID);
}
void GetIndexPairs(QueryMatchID id, SetQueryArgs args)
{
k_RelationIndexPairs.Clear();
var relations = args.relations;
GetAllIndexPairs(id, relations);
}
BufferedAction(ActionKind kind)
{
Kind = kind;
IsTimeout = false;
IsRemoveAll = false;
QueryId = QueryMatchID.NullQuery;
SingleArgs = null;
GroupArgs = null;
}
void RegisterRelationChildren(QueryMatchID id, SetQueryArgs args)
{
k_SetMemberIndices.Clear();
foreach (var kvp in args.relations.children)
{
var childArgs = kvp.Value;
// register each group member in the member data and get its index into those collections
var memberIndex = MemberData.Register(id, kvp.Key, childArgs);
k_SetMemberIndices.Add(memberIndex);
}
}
internal void Register(QueryMatchID id, SetQueryArgs args)
{
if (Data.MatchIdToIndex.ContainsKey(id))
{
return; // query is already registered
}
RegisterRelationChildren(id, args);
GetIndexPairs(id, args);
// the index arrays for group & relation members are so small that we create new ones
// on registration, instead of using pooled Lists
var memberIndices = k_SetMemberIndices.ToArray();
var relationIndexPairs = k_RelationIndexPairs.ToArray();
var groupIndex = Data.Register(id, memberIndices, relationIndexPairs, args);
k_TempChildResults.Clear();
foreach (var i in memberIndices)
{
k_TempChildResults.Add(MemberData.ObjectReferences[i], MemberData.QueryResults[i]);
}
Data.QueryResults[groupIndex].SetChildren(k_TempChildResults);
// for each group member, store a representation of which relations it belongs to.
Data.GetRelationMemberships(groupIndex, k_RelationMemberships);
foreach (var kvp in k_RelationMemberships)
{
var memberIndex = kvp.Key;
MemberData.RelationMemberships[memberIndex] = kvp.Value;
}
// calculate the solve order weighting for this group
var weights = QueryPipelineConfiguration.instance.SolveOrderWeighting;
var order = GetGroupOrderWeight(memberIndices, relationIndexPairs.Length, MemberData.Exclusivities, weights);
Data.OrderWeights[groupIndex] = order;
Data.InitializeSearchData(groupIndex, MemberData.ReducedConditionRatings);
}
public BufferedAction(QueryMatchID id, SetQueryArgs args) : this(ActionKind.ModifyGroup)
{
QueryId = id;
GroupArgs = args;
}
public BufferedAction(bool isAdd, QueryMatchID id, SetQueryArgs args) : this(isAdd ? ActionKind.AddGroup : ActionKind.RemoveGroup)
{
QueryId = id;
GroupArgs = args;
}
static void ModifySetQueryNoop(QueryMatchID queryMatchID, SetQueryArgs queryArgs)
{
}
void RegisterSetQuery(QueryMatchID queryMatchID, SetQueryArgs queryArgs)
{
EnqueueUpdate(new BufferedAction(true, queryMatchID, queryArgs));
}
internal void ModifySetQuery(QueryMatchID id, SetQueryArgs args)
{
EnqueueUpdate(new BufferedAction(id, args));
}
internal void Modify(QueryMatchID id, SetQueryArgs args)
{
if (!Data.MatchIdToIndex.TryGetValue(id, out var groupIndex))
{
return;
}
Assert.IsTrue(Data.QueryMatchIds[groupIndex].Equals(id),
$"Mismatch between QueryMatchId {id} and group index {groupIndex}");
k_SetMemberIndices.Clear();
k_KnownMembers.Clear();
var hasMembers = MemberData.MatchIdToIndex.TryGetValue(id, out var memberIndices);
if (hasMembers)
{
// collect data on known members to facilitate remove / update
for (var orderIndex = 0; orderIndex < memberIndices.Count; orderIndex++)
{
var memberIndex = memberIndices[orderIndex];
var mrObject = MemberData.ObjectReferences[memberIndex];
k_KnownMembers.Add(new KnownMember(mrObject, memberIndex));
}
var children = args.relations.children;
// remove members that are gone
for (var i = k_KnownMembers.Count - 1; i >= 0; i--)
{
var knownMember = k_KnownMembers[i];
if (children.ContainsKey(knownMember.Reference))
{
continue;
}
MemberData.Remove(id, knownMember.DataIndex);
// Data child removal will happen with Data.Modify
// as that will reconstruct all data buffers / structures
// and re-associate with the current set of relations
k_KnownMembers.RemoveAt(i);
}
// add or update
foreach (var kvp in children)
{
var knownIndex = -1;
for (var i = 0; i < k_KnownMembers.Count; i++)
{
var knownMember = k_KnownMembers[i];
if (!ReferenceEquals(knownMember.Reference, kvp.Key))
{
continue;
}
knownIndex = i;
break;
}
if (knownIndex >= 0)
{
// update
var knownMember = k_KnownMembers[knownIndex];
MemberData.Modify(id, knownMember.DataIndex, kvp.Value);
k_KnownMembers.RemoveAt(knownIndex);
}
else
{
// register
MemberData.Register(id, kvp.Key, kvp.Value);
}
}
k_KnownMembers.Clear();
}
else
{
RegisterRelationChildren(id, args);
MemberData.MatchIdToIndex.TryGetValue(id, out memberIndices);
}
GetIndexPairs(id, args);
// the index arrays for group & relation members are so small that we create new ones
// on registration, instead of using pooled Lists
var memberIndicesArray = memberIndices.ToArray();
var relationIndexPairs = k_RelationIndexPairs.ToArray();
Data.Modify(groupIndex, memberIndicesArray, relationIndexPairs, args);
k_TempChildResults.Clear();
foreach (var i in memberIndices)
{
k_TempChildResults.Add(MemberData.ObjectReferences[i], MemberData.QueryResults[i]);
}
Data.QueryResults[groupIndex].SetChildren(k_TempChildResults);
// for each group member, store a representation of which relations it belongs to.
Data.GetRelationMemberships(groupIndex, k_RelationMemberships);
foreach (var kvp in k_RelationMemberships)
{
var memberIndex = kvp.Key;
MemberData.RelationMemberships[memberIndex] = kvp.Value;
}
// calculate the solve order weighting for this group
var weights = QueryPipelineConfiguration.instance.SolveOrderWeighting;
var order = GetGroupOrderWeight(memberIndicesArray, relationIndexPairs.Length, MemberData.Exclusivities, weights);
Data.OrderWeights[groupIndex] = order;
Data.InitializeSearchData(groupIndex, MemberData.ReducedConditionRatings);
}
