public INodesCollection Transform(INodesCollection nodes) { var newNodes = new NodesCollection(); var boolType = typeof (bool); for (var i = 0; i < nodes.Count; i++) { var memberNode = nodes[i] as MemberNode; if(memberNode == null || memberNode.MemberType != boolType) { newNodes.AddNode(nodes[i]); continue; } var firstNextNode = nodes.GetItemOrNullByIndex(i + 1) as OperatorNode; var secondNextNode = nodes.GetItemOrNullByIndex(i + 2) as ValueNode; var memberNodeIsPartOfCompleteBoolExpression = firstNextNode != null && secondNextNode != null && secondNextNode.Value is bool; if (memberNodeIsPartOfCompleteBoolExpression) newNodes.AddNode(memberNode); else newNodes.AddNodes(memberNode, new OperatorNode(Operator.Equal()), new ValueNode(true)); } return newNodes; }
protected virtual IParsedLambda CreateParsedLambda() { //PERF: This ugly processing of nodes for boht transformers in one loop is for performance. Perhaps move bach to older cleaner solution var nullableNodeTransformer = new NullableNodeTransformer(); var boolNodeTransformer = new BoolNodeTransformer(); var newNodes = new NodesCollection(); var maxIndex = Nodes.Count; for (var i = 0; i < Nodes.Count; i++) { var nullableNodes = nullableNodeTransformer.Transform(maxIndex, ref i, Nodes[i], Nodes); var merged = nullableNodes.MergeWith(Nodes.Skip(i + 1)).ToArray(); var maxIndexInner = nullableNodes.Length; for (var iInner = 0; iInner < maxIndexInner; iInner++) { var boolNodes = boolNodeTransformer.Transform(maxIndexInner, ref iInner, merged[iInner], new NodesCollection(merged)); newNodes.AddNodes(boolNodes); } } return new ParsedLambda(newNodes.ToArray()); }
public INodesCollection Transform(INodesCollection nodes) { if (!nodes.OfType<NullableMemberNode>().Any(n => n.IsForHasValueCheck)) return nodes; var maxIndex = nodes.Count - 1; var newNodes = new NodesCollection(); for (var i = 0; i < nodes.Count; i++) { var nullableNode = nodes[i] as NullableMemberNode; if (nullableNode == null || !nullableNode.IsForHasValueCheck) { newNodes.AddNode(nodes[i]); continue; } if (i == maxIndex) { newNodes.AddNodes(nullableNode, new OperatorNode(Operator.IsNot()), new NullNode()); continue; } var rightOperator = nodes[i + 1] as OperatorNode; var rightValue = nodes[i + 2] as ValueNode; if (rightOperator == null || rightValue == null) { newNodes.AddNodes(nullableNode, new OperatorNode(Operator.IsNot()), new NullNode()); continue; } var operatorType = rightOperator.Operator.OperatorType; var hasValueIs = (bool)rightValue.Value; var shouldBeIsNotNullNodes = (operatorType == Operator.Types.Equal && hasValueIs) || (operatorType == Operator.Types.NotEqual && hasValueIs == false); var shouldBeIsNullNodes = (operatorType == Operator.Types.Equal && hasValueIs == false) || (operatorType == Operator.Types.Equal && hasValueIs == false); if (shouldBeIsNotNullNodes) { newNodes.AddNodes(nullableNode, new OperatorNode(Operator.IsNot()), new NullNode()); i += 2; continue; } if (shouldBeIsNullNodes) { newNodes.AddNodes(nullableNode, new OperatorNode(Operator.Is()), new NullNode()); i += 2; continue; } } return newNodes; }