internal void CloneItems(BuilderElements builders)
{
foreach (GrammarBuilderBase item in builders.Items)
{
_items.Add(item);
}
}
public override bool Equals(object obj)
{
BuilderElements refObj = obj as BuilderElements;
if (refObj == null)
{
return(false);
}
// Easy out if the number of elements do not match
if (refObj.Count != Count || refObj.Items.Count != Items.Count)
{
return(false);
}
// Deep recursive search for equality
for (int i = 0; i < Items.Count; i++)
{
if (!Items[i].Equals(refObj.Items[i]))
{
return(false);
}
}
return(true);
}
private void RemoveDictionaryElements(SortedDictionary <int, Collection <BuilderElements> > dict)
{
foreach (GrammarBuilderBase item in Items)
{
BuilderElements builderElements = item as BuilderElements;
if (builderElements != null)
{
builderElements.RemoveDictionaryElements(dict);
dict[builderElements.Count].Remove(builderElements);
}
}
}
internal override int CalcCount(BuilderElements parent)
{
base.CalcCount(parent);
int num = 1;
foreach (GrammarBuilderBase item in Items)
{
num += item.CalcCount(this);
}
Count = num;
return(num);
}
internal override int CalcCount(BuilderElements parent)
{
base.CalcCount(parent);
int c = 1;
foreach (GrammarBuilderBase item in Items)
{
c += item.CalcCount(this);
}
Count = c;
return(c);
}
protected void Optimize(Collection <RuleElement> newRules)
{
SortedDictionary <int, Collection <BuilderElements> > sortedDictionary = new SortedDictionary <int, Collection <BuilderElements> >();
GetDictionaryElements(sortedDictionary);
int[] array = new int[sortedDictionary.Keys.Count];
int num = array.Length - 1;
foreach (int key in sortedDictionary.Keys)
{
array[num--] = key;
}
for (int i = 0; i < array.Length && array[i] >= 3; i++)
{
Collection <BuilderElements> collection = sortedDictionary[array[i]];
for (int j = 0; j < collection.Count; j++)
{
RuleElement ruleElement = null;
RuleRefElement ruleRefElement = null;
for (int k = j + 1; k < collection.Count; k++)
{
if (collection[j] == null || !collection[j].Equals(collection[k]))
{
continue;
}
BuilderElements builderElements = collection[k];
BuilderElements parent = builderElements.Parent;
if (builderElements is SemanticKeyElement)
{
parent.Items[parent.Items.IndexOf(builderElements)] = collection[j];
}
else
{
if (ruleElement == null)
{
ruleElement = new RuleElement(builderElements, "_");
newRules.Add(ruleElement);
}
if (ruleRefElement == null)
{
ruleRefElement = new RuleRefElement(ruleElement);
collection[j].Parent.Items[collection[j].Parent.Items.IndexOf(collection[j])] = ruleRefElement;
}
parent.Items[builderElements.Parent.Items.IndexOf(builderElements)] = ruleRefElement;
}
builderElements.RemoveDictionaryElements(sortedDictionary);
collection[k] = null;
}
}
}
}
private void GetDictionaryElements(SortedDictionary <int, Collection <BuilderElements> > dict)
{
foreach (GrammarBuilderBase item in Items)
{
BuilderElements builderElements = item as BuilderElements;
if (builderElements != null)
{
if (!dict.ContainsKey(builderElements.Count))
{
dict.Add(builderElements.Count, new Collection <BuilderElements>());
}
dict[builderElements.Count].Add(builderElements);
builderElements.GetDictionaryElements(dict);
}
}
}
private void RemoveDictionaryElements(SortedDictionary <int, Collection <BuilderElements> > dict)
{
// Recursive search from a matching subtree
foreach (GrammarBuilderBase item in Items)
{
BuilderElements current = item as BuilderElements;
// Go deeper if the number of children is greater the element to compare against.
if (current != null)
{
// Recursively remove all elements
current.RemoveDictionaryElements(dict);
dict[current.Count].Remove(current);
}
}
}
private void GetDictionaryElements(SortedDictionary <int, Collection <BuilderElements> > dict)
{
// Recursive search from a matching subtree
foreach (GrammarBuilderBase item in Items)
{
BuilderElements current = item as BuilderElements;
// Go deeper if the number of children is greater the element to compare against.
if (current != null)
{
if (!dict.ContainsKey(current.Count))
{
dict.Add(current.Count, new Collection <BuilderElements>());
}
dict[current.Count].Add(current);
current.GetDictionaryElements(dict);
}
}
}
public override bool Equals(object obj)
{
BuilderElements builderElements = obj as BuilderElements;
if (builderElements == null)
{
return(false);
}
if (builderElements.Count != Count || builderElements.Items.Count != Items.Count)
{
return(false);
}
for (int i = 0; i < Items.Count; i++)
{
if (!Items[i].Equals(builderElements.Items[i]))
{
return(false);
}
}
return(true);
}
internal virtual int CalcCount(BuilderElements parent)
{
Marked = false;
Parent = parent;
return(Count);
}
/// <summary>
/// Optimization for a element tree
/// </summary>
protected void Optimize(Collection <RuleElement> newRules)
{
// Create an dictionary of [Count of elements, list of elements]
SortedDictionary <int, Collection <BuilderElements> > dict = new();
GetDictionaryElements(dict);
// The dictionary is sorted from the smallest buckets to the largest.
// Revert the order in the keys arrays
int[] keys = new int[dict.Keys.Count];
int index = keys.Length - 1;
foreach (int key in dict.Keys)
{
keys[index--] = key;
}
// Look for each bucket from the largest to the smallest
for (int i = 0; i < keys.Length && keys[i] >= 3; i++)
{
Collection <BuilderElements> gb = dict[keys[i]];
for (int j = 0; j < gb.Count; j++)
{
RuleElement newRule = null;
RuleRefElement ruleRef = null;
for (int k = j + 1; k < gb.Count; k++)
{
if (gb[j] != null && gb[j].Equals(gb[k]))
{
BuilderElements current = gb[k];
BuilderElements parent = current.Parent;
if (current is SemanticKeyElement)
// if current is already a ruleref. There is no need to create a new one
{
// Simply set the ruleref of the current element to the ruleref of the org element.
parent.Items[parent.Items.IndexOf(current)] = gb[j];
}
else
{
// Create a rule to store the common elements
if (newRule == null)
{
newRule = new RuleElement(current, "_");
newRules.Add(newRule);
}
// Create a ruleref and attach the
if (ruleRef == null)
{
ruleRef = new RuleRefElement(newRule);
gb[j].Parent.Items[gb[j].Parent.Items.IndexOf(gb[j])] = ruleRef;
}
parent.Items[current.Parent.Items.IndexOf(current)] = ruleRef;
}
//
current.RemoveDictionaryElements(dict);
gb[k] = null;
}
}
}
}
}
internal override int CalcCount(BuilderElements parent)
{
_rule = null;
return(base.CalcCount(parent));
}
internal override int CalcCount(BuilderElements parent)
{
// clear any existing value
_rule = null;
return(base.CalcCount(parent));
}