/// <summary>
/// Outputs all unique triggers for the given table.
/// </summary>
static public int UniqueRuleTriggers(RSRuleTableData inTableData, ICollection <RSTriggerId> outCollection)
{
Assert.True(inTableData != null, "Cannot read from null table");
Assert.True(outCollection != null, "Cannot output to null collection");
if (inTableData == null || inTableData.Rules == null)
{
return(0);
}
int count = 0;
for (int i = 0; i < inTableData.Rules.Length; ++i)
{
RSTriggerId trigger = inTableData.Rules[i].TriggerId;
if (trigger == RSTriggerId.Null)
{
continue;
}
if (outCollection.Contains(trigger))
{
continue;
}
outCollection.Add(trigger);
++count;
}
return(count);
}
/// <summary>
/// Updates the array of all unique triggers for the given table.
/// </summary>
static public void UpdateUniqueRuleTriggers(RSRuleTableData ioTable)
{
HashSet <RSTriggerId> uniqueTriggers = new HashSet <RSTriggerId>();
int uniqueTriggerCount = TableUtils.UniqueRuleTriggers(ioTable, uniqueTriggers);
ioTable.UniqueTriggers = new RSTriggerId[uniqueTriggerCount];
uniqueTriggers.CopyTo(ioTable.UniqueTriggers);
}
public override void Visit(RSRuleTableData inRuleTableData, TableLineRef inSourceRef)
{
base.Visit(inRuleTableData, inSourceRef);
if (Match(inRuleTableData?.Name))
{
AddRef(inSourceRef, "Rule Table Name: " + inRuleTableData.Name);
}
}
public virtual void Visit(RSRuleTableData inRuleTableData, TableLineRef inSourceRef)
{
if (inRuleTableData == null)
{
return;
}
if (inRuleTableData.Rules != null)
{
for (int i = 0; i < inRuleTableData.Rules.Length; ++i)
{
Visit(inRuleTableData.Rules[i], inSourceRef);
}
}
}
/// <summary>
/// Attempts to clean up the given rule table.
/// Returns if any modifications have been made.
/// </summary>
static public bool CleanUp(RSRuleTableData ioTableData)
{
if (ioTableData == null || ioTableData.Rules == null)
{
return(false);
}
bool bChanged = false;
HashSet <string> discoveredRuleIds = new HashSet <string>();
for (int i = 0; i < ioTableData.Rules.Length; ++i)
{
bChanged |= CleanUp(ioTableData.Rules[i], discoveredRuleIds);
}
return(bChanged);
}
public virtual bool Visit(RSRuleTableData ioRuleTable)
{
if (ioRuleTable == null)
{
return(false);
}
bool bChanged = false;
if (ioRuleTable.Rules != null)
{
for (int i = 0; i < ioRuleTable.Rules.Length; ++i)
{
bChanged |= Visit(ioRuleTable.Rules[i]);
}
}
return(bChanged);
}
/// <summary>
/// Returns the index of the rule with the given id.
/// </summary>
static public int IndexOfRule(RSRuleTableData inTableData, string inRuleId)
{
if (inTableData == null || inTableData.Rules == null)
{
return(-1);
}
if (string.IsNullOrEmpty(inRuleId))
{
return(-1);
}
for (int i = 0; i < inTableData.Rules.Length; ++i)
{
if (inTableData.Rules[i].Id.Equals(inRuleId, System.StringComparison.Ordinal))
{
return(i);
}
}
return(-1);
}
/// <summary>
/// Deletes all references to an entity id within the given table.
/// </summary>
static public bool DeleteEntityRef(RSRuleTableData ioTableData, RSEntityId inEntityId)
{
return(UpdateEntityRef(ioTableData, inEntityId, RSEntityId.Invalid));
}
/// <summary>
/// Updates all references to an entity id within the given table.
/// </summary>
static public bool UpdateEntityRef(RSRuleTableData ioTableData, RSEntityId inEntityId, RSEntityId inNewId)
{
EntityRefUpdateVisitor updater = new EntityRefUpdateVisitor(inEntityId, inNewId);
return(updater.Visit(ioTableData));
}
