public void TestEvaluate()
{
_notNode.AddChildNode(new SupportBoolExprNode(true));
SupportExprNodeUtil.Validate(_notNode);
Assert.IsFalse(_notNode.Evaluate(new EvaluateParams(null, false, null)).AsBoolean());
_notNode = new ExprNotNode();
_notNode.AddChildNode(new SupportBoolExprNode(false));
SupportExprNodeUtil.Validate(_notNode);
Assert.IsTrue(_notNode.Evaluate(new EvaluateParams(null, false, null)).AsBoolean());
}
public void TestValidate()
{
// fails with zero expressions
try
{
_notNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
// fails with too many sub-expressions
_notNode.AddChildNode(new SupportExprNode(typeof(Boolean)));
_notNode.AddChildNode(new SupportExprNode(typeof(Boolean)));
try
{
_notNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
// test failure, type mismatch
_notNode = new ExprNotNode();
_notNode.AddChildNode(new SupportExprNode(typeof(string)));
try
{
_notNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
// validates
_notNode = new ExprNotNode();
_notNode.AddChildNode(new SupportExprNode(typeof(Boolean)));
_notNode.Validate(ExprValidationContextFactory.MakeEmpty());
}
public void QExprNot(ExprNotNode exprNotNode)
{
}
public void SetUp()
{
_notNode = new ExprNotNode();
}
internal static FilterSpecPlanForge PlanRemainingNodesWithConditions(
FilterSpecParaForgeMap overallExpressions,
FilterSpecCompilerArgs args,
int filterServiceMaxFilterWidth,
ExprNode topLevelNegator)
{
var unassigned = overallExpressions.UnassignedExpressions;
var orNodes = new List <ExprOrNode>(unassigned.Count);
foreach (var node in unassigned)
{
if (node is ExprOrNode)
{
orNodes.Add((ExprOrNode)node);
}
}
var expressionsWithoutOr = new FilterSpecParaForgeMap();
expressionsWithoutOr.Add(overallExpressions);
// first dimension: or-node index
// second dimension: or child node index
var countOr = 0;
var sizeFactorized = 1;
var sizePerOr = new int[orNodes.Count];
var orChildNodes = new OrChildNode[orNodes.Count][];
var hasControl = false;
foreach (var orNode in orNodes)
{
expressionsWithoutOr.RemoveNode(orNode);
// get value-nodes and non-value nodes
var nonValueNodes = GetNonValueChildNodes(orNode);
var valueNodes = new List <ExprNode>(Arrays.AsList(orNode.ChildNodes));
valueNodes.RemoveAll(nonValueNodes);
ExprNode singleValueNode = ExprNodeUtilityMake.ConnectExpressionsByLogicalOrWhenNeeded(valueNodes);
// get all child nodes; last one is confirm if present
IList <ExprNode> allChildNodes = new List <ExprNode>(nonValueNodes);
if (singleValueNode != null)
{
allChildNodes.Add(singleValueNode);
}
var len = allChildNodes.Count;
orChildNodes[countOr] = new OrChildNode[len];
for (var i = 0; i < len; i++)
{
var child = allChildNodes[i];
if (child == singleValueNode)
{
hasControl = true;
orChildNodes[countOr][i] = new OrChildNodeV(singleValueNode);
}
else
{
var map = new FilterSpecParaForgeMap();
var nodes = Collections.SingletonList(child);
var confirm = DecomposePopulateConsolidate(map, true, nodes, args);
if (confirm == null)
{
orChildNodes[countOr][i] = new OrChildNodeNV(child, map);
}
else
{
hasControl = true;
orChildNodes[countOr][i] = new OrChildNodeNVNegated(child, map, confirm);
}
}
}
sizePerOr[countOr] = len;
sizeFactorized = sizeFactorized * len;
countOr++;
}
// compute permutations
var permutations = new CombPermutationTriplets[sizeFactorized];
var combinationEnumeration = CombinationEnumeration.FromZeroBasedRanges(sizePerOr);
var count = 0;
foreach (var permutation in combinationEnumeration)
{
permutations[count] = ComputePermutation(expressionsWithoutOr, permutation, orChildNodes, hasControl, args);
count++;
}
// Remove any permutations that only have a control-confirm
var result = new List <FilterSpecPlanPathForge>(sizeFactorized);
var pathControlConfirm = new List <ExprNode>();
foreach (var permutation in permutations)
{
if (permutation.Triplets.Length > 0)
{
result.Add(new FilterSpecPlanPathForge(permutation.Triplets, permutation.NegateCondition));
}
else
{
pathControlConfirm.Add(permutation.NegateCondition);
}
}
if (result.Count > filterServiceMaxFilterWidth)
{
return(null);
}
var pathArray = result.ToArray();
ExprNode topLevelConfirmer = ExprNodeUtilityMake.ConnectExpressionsByLogicalOrWhenNeeded(pathControlConfirm);
// determine when the path-negate condition is the same as the root confirm-expression
if (topLevelConfirmer != null)
{
var not = new ExprNotNode();
not.AddChildNode(topLevelConfirmer);
foreach (var path in pathArray)
{
if (ExprNodeUtilityCompare.DeepEquals(not, path.PathNegate, true))
{
path.PathNegate = null;
}
}
}
var convertor = new MatchedEventConvertorForge(
args.taggedEventTypes,
args.arrayEventTypes,
args.allTagNamesOrdered,
null,
true);
return(new FilterSpecPlanForge(pathArray, topLevelConfirmer, topLevelNegator, convertor));
}
private static CombPermutationTriplets ComputePermutation(
FilterSpecParaForgeMap filterParamExprMap,
object[] permutation,
OrChildNode[][] orChildNodes,
bool hasControl,
FilterSpecCompilerArgs args)
{
var mapAll = new FilterSpecParaForgeMap();
mapAll.Add(filterParamExprMap);
// combine
IList <ExprNode> nvPerOr = new List <ExprNode>(permutation.Length);
IList <ExprNode> negatingPath = new List <ExprNode>(permutation.Length);
for (var orNodeNum = 0; orNodeNum < permutation.Length; orNodeNum++)
{
int orChildNodeNum = permutation[orNodeNum].AsInt32();
var current = orChildNodes[orNodeNum][orChildNodeNum];
if (current is OrChildNodeNV)
{
var nv = (OrChildNodeNV)current;
mapAll.Add(nv.Map);
if (current is OrChildNodeNVNegated)
{
negatingPath.Add(((OrChildNodeNVNegated)current).Control);
}
}
else
{
var v = (OrChildNodeV)current;
negatingPath.Add(v.Node);
}
var orChildNodesForCurrent = orChildNodes[orNodeNum];
foreach (var other in orChildNodesForCurrent)
{
if (current == other)
{
continue;
}
if (other is OrChildNodeV)
{
var v = (OrChildNodeV)other;
var not = new ExprNotNode();
not.AddChildNode(v.Node);
nvPerOr.Add(not);
}
}
}
// consolidate across
FilterSpecCompilerConsolidateUtil.Consolidate(mapAll, args.statementRawInfo.StatementName);
IList <FilterSpecPlanPathTripletForge> triplets = new List <FilterSpecPlanPathTripletForge>(mapAll.Triplets);
var countUnassigned = mapAll.CountUnassignedExpressions();
if (countUnassigned != 0)
{
var triplet = MakeRemainingNode(mapAll.UnassignedExpressions, args);
triplets.Add(triplet);
}
// without conditions we are done
var tripletsArray = triplets.ToArray();
if (!hasControl)
{
return(new CombPermutationTriplets(tripletsArray, null));
}
var negatingNode = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(negatingPath);
var excluded = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(nvPerOr);
var merged = ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(negatingNode, excluded);
return(new CombPermutationTriplets(tripletsArray, merged));
}
