public object Clone()
{
var copy = new OrTreePredicate();
foreach (var expression in _predciates)
{
copy.Add((ITreePredicate)expression.Clone());
}
return(copy);
}
//We don't need different combinations of an ORTreePredicates, we will instead get its final form.
public ITreePredicate Expand()
{
foreach (var predciate in _predciates)
{
var resultExpression = predciate.Expand();
if (resultExpression != null)
{
OrTreePredicate expandedPred = new OrTreePredicate();
foreach (var predciate1 in _predciates)
{
if (predciate != predciate1)
{
expandedPred.Add(predciate1);
}
}
expandedPred.Add(resultExpression);
return(expandedPred);
}
}
return(null);
}
public override bool Equals(object obj)
{
if (!(obj is OrTreePredicate))
{
return(false);
}
OrTreePredicate orObject = (OrTreePredicate)obj;
if (!_predciates.Count.Equals(orObject.TreePredicates.Count))
{
return(false);
}
foreach (var expression in orObject.TreePredicates)
{
if (!_predciates.Contains(expression))
{
return(false);
}
}
return(true);
}
public ITreePredicate Contract()
{
if (!IsTerminal)
{
Dictionary <int, ITreePredicate> contractedPreds = new Dictionary <int, ITreePredicate>();
for (int i = 0; i < _predciates.Count; i++)
{
ITreePredicate contracted = _predciates[i].Contract();
if (contracted != null)
{
while (contracted.Contract() != null)
{
contracted = contracted.Contract();
}
contractedPreds[i] = contracted;
}
}
if (contractedPreds.Count.Equals(0))
{
return(null);
}
OrTreePredicate returnOr = new OrTreePredicate();
for (int i = 0; i < _predciates.Count; i++)
{
if (contractedPreds.ContainsKey(i))
{
returnOr.Add(contractedPreds[i]);
}
else
{
returnOr.Add(_predciates[i]);
}
}
ITreePredicate contractedPred = returnOr;
while (contractedPred.Contract() != null)
{
contractedPred = contractedPred.Contract();
}
return(contractedPred);
}
List <AndTreePredicate> ands = new List <AndTreePredicate>();
foreach (var predciate in _predciates)
{
if (!(predciate is AndTreePredicate))
{
return(null);
}
ands.Add((AndTreePredicate)(predciate));
}
if (ands.Count < 2)
{
return(null);
}
ITreePredicate commonPred = null;
foreach (var expression in ands[0].TreePredicates)
{
commonPred = expression;
for (int i = 1; i < ands.Count; i++)
{
if (ands[i].TreePredicates.Count < 2 ||
!ands[i].TreePredicates.Contains(expression))
{
return(null);
}
}
}
AndTreePredicate returnPred = new AndTreePredicate();
returnPred.Add(commonPred);
OrTreePredicate orChild = new OrTreePredicate();
foreach (var and in ands)
{
foreach (var predciate in and.TreePredicates)
{
if (!predciate.Equals(commonPred))
{
orChild.Add(predciate);
}
}
}
returnPred.Add(orChild);
ITreePredicate contractPred = returnPred;
while (contractPred.Contract() != null)
{
contractPred = contractPred.Contract();
}
return(contractPred);
}
