/*
* Protected Methods
*/
protected void changeIndexWindow(Dependency d)
{
try
{
if (d.IsFormula())
{
IEnumerator e = ((Formula)d).GetDependencies();
while (e.MoveNext())
{
changeIndexWindow((Dependency)e.Current);
}
}
else if (d is StateDependency)
{
StateDependency sd = (StateDependency)d;
changeIndexWindow(sd.StateWindow);
if (sd is StateValueDependency && ((StateValueDependency)sd).IsReference)
{
changeIndexWindow(((StateValueDependency)sd).ReferenceWindow);
}
}
}
catch (NullReferenceException e)
{
throw new PUC.Parsers.SpecParseException(d.LineNumber, "A dependency within an apply-over block does not refer to a variable within the referenced list group.", e);
}
}
protected ArrayList mergeTwoVectors(ArrayList array1, ArrayList array2)
{
ArrayList result = new ArrayList();
result.AddRange(array1);
IEnumerator e = array2.GetEnumerator();
while (e.MoveNext())
{
bool cont = false;
StateDependency d1 = (StateDependency)e.Current;
for (int i = 0; i < result.Count; i++)
{
StateDependency d2 = (StateDependency)result[i];
StateDependency dm = d1.Merge(d2);
if (dm != null)
{
if (dm is WholeSetDependency)
{
result.Clear();
result.Add(dm);
return(result);
}
result[i] = dm;
cont = true;
break;
}
}
if (cont)
{
continue;
}
result.Add(d1);
}
return(result);
}
protected StateDependency mergeVector(ArrayList array)
{
IEnumerator e = array.GetEnumerator();
StateDependency d = null;
if (e.MoveNext())
{
d = (StateDependency)e.Current;
}
while (e.MoveNext())
{
StateDependency nd = (StateDependency)e.Current;
d = nd.Merge(d);
}
return(d);
}
protected void resolveHelper(Dependency df,
VariableTable varTable)
{
if (df == null)
{
return;
}
if (df is ApplyOver)
{
((ApplyOver)df).ResolveObject(varTable);
}
if (df is Formula)
{
IEnumerator e = ((Formula)df).GetDependencies();
while (e.MoveNext())
{
resolveHelper((Dependency)e.Current, varTable);
}
}
else if (df is StateDependency)
{
StateDependency d = (StateDependency)df;
if (!d.ResolveObject(varTable))
{
throw new PUC.Parsers.SpecParseException(d.LineNumber, "Problem resolving a dependency state name: " + d.StateName);
}
_states.Add(d.State);
if (d.HasValue() && ((StateValueDependency)d).IsReference)
{
_states.Add(((StateValueDependency)d).ReferenceState);
}
}
if (df is ApplyOver)
{
((ApplyOver)df).FixDataWindows();
}
}
protected void filterDependencies(ArrayList deps)
{
// Step #1: Filter dependencies into groups
ArrayList greaterThan = new ArrayList();
ArrayList lessThan = new ArrayList();
ArrayList equals = new ArrayList();
IEnumerator e = deps.GetEnumerator();
while (e.MoveNext())
{
Dependency d = (Dependency)e.Current;
if (d is EqualsDependency)
{
equals.Add(d);
}
else if (d is LessThanDependency)
{
lessThan.Add(d);
}
else if (d is GreaterThanDependency)
{
greaterThan.Add(d);
}
else if (d is WholeSetDependency)
{
deps.Clear();
deps.Add(d);
return;
}
else
{
throw new NotSupportedException("unknown dependency");
}
}
deps.Clear();
// Step #2: Merge greater-than (gt) and less-than (lt) dependencies
StateDependency gtDep = mergeVector(greaterThan);
StateDependency ltDep = mergeVector(lessThan);
// Step #3: Check that filtered gt and lt dependencies don't
// overlap. If they do, we're done. (return a new WholeSetDependency)
if (gtDep != null && ltDep != null)
{
Dependency d = gtDep.Merge(ltDep);
if (d != null)
{
// d must be a WholeSetDependency. Make it the only
// thing in deps, and return.
deps.Add(d);
return;
}
}
// Step #4: Merge with equals dependencies
if (gtDep != null)
{
deps.Add(gtDep);
}
if (ltDep != null)
{
deps.Add(ltDep);
}
e = equals.GetEnumerator();
while (e.MoveNext())
{
StateDependency d = (StateDependency)e.Current;
StateDependency m = null;
for (int i = 0; i < deps.Count; i++)
{
m = d.Merge((StateDependency)deps[i]);
if (m != null)
{
deps[i] = m;
break;
}
}
if (m == null)
{
deps.Add(d);
}
}
}
