public void TrueTrueTest() { MockExpression leftExpression = new MockExpression(true); MockExpression rightExpression = new MockExpression(true); AndOperator expression = new AndOperator(leftExpression, rightExpression); Assert.IsTrue(expression.Evaluate(this.principal)); }
public void InstanceWithFalseInitialization() { var andOperator = new AndOperator(false); Assert.IsNotNull(andOperator); Assert.IsFalse(andOperator.Result); }
public void InstanceWithTrueInitialization() { var andOperator = new AndOperator(true); Assert.IsNotNull(andOperator); Assert.IsTrue(andOperator.Result); }
public void AndOrNotTestWithQuotedStrings() { Parser parser = new Parser(); BooleanExpression expression = parser.Parse( "(R:\"Human Resources\" OR R:\"General Managers\") AND NOT R:\"HR Specialist\""); Assert.AreEqual(typeof(AndOperator), expression.GetType()); AndOperator andOperator = (AndOperator)expression; Assert.AreEqual(typeof(OrOperator), andOperator.Left.GetType()); OrOperator orOperator = (OrOperator)andOperator.Left; Assert.AreEqual(typeof(RoleExpression), orOperator.Left.GetType()); RoleExpression hrRoleExpression = (RoleExpression)orOperator.Left; Assert.AreEqual("Human Resources", hrRoleExpression.Word.Value); Assert.AreEqual(typeof(RoleExpression), orOperator.Right.GetType()); RoleExpression gmRoleExpression = (RoleExpression)orOperator.Right; Assert.AreEqual("General Managers", gmRoleExpression.Word.Value); Assert.AreEqual(typeof(NotOperator), andOperator.Right.GetType()); NotOperator notOperator = (NotOperator)andOperator.Right; Assert.AreEqual(typeof(RoleExpression), notOperator.Expression.GetType()); RoleExpression specialistRoleExpression = (RoleExpression)notOperator.Expression; Assert.AreEqual("HR Specialist", specialistRoleExpression.Word.Value); }
public void AddFilterTest() { string expected = @"<?xml version=""1.0"" encoding=""utf-8""?>" + "<and>" + "<greaterthanorequalto>" + "<field>RECORDNO</field>" + "<value>1</value>" + "</greaterthanorequalto>" + "<lessthanorequalto>" + "<field>RECORDNO</field>" + "<value>100</value>" + "</lessthanorequalto>" + "</and>"; Stream stream = new MemoryStream(); XmlWriterSettings xmlSettings = new XmlWriterSettings { Encoding = Encoding.GetEncoding("UTF-8") }; IaXmlWriter xml = new IaXmlWriter(stream, xmlSettings); AndOperator andFilter = new AndOperator(null); andFilter.AddFilter((new Filter("RECORDNO")).SetGreaterThanOrEqualTo("1")); andFilter.AddFilter((new Filter("RECORDNO")).SetLessThanOrEqualTo("100")); andFilter.WriteXml(ref xml); xml.Flush(); stream.Position = 0; StreamReader reader = new StreamReader(stream); Assert.Equal(expected, reader.ReadToEnd()); }
public void FalseFalseTest() { MockExpression leftExpression = new MockExpression(false); MockExpression rightExpression = new MockExpression(false); AndOperator expression = new AndOperator(leftExpression, rightExpression); Assert.IsFalse(expression.Evaluate(principal)); }
public void Visit(AndOperator node) { builder.AppendLine($"And"); builder.Indent(); node.Left.Accept(this); node.Right.Accept(this); builder.Outdent(); }
public void TestTokenInheritance() { AndOperator andOp = new AndOperator(); Assert.IsTrue(andOp.value == '*'); Assert.IsInstanceOfType(andOp, typeof(AndOperator)); Assert.IsInstanceOfType(andOp, typeof(OperatorToken)); Assert.IsInstanceOfType(andOp, typeof(Token)); }
public void FalseTrueTest() { MockExpression leftExpression = new MockExpression(false); MockExpression rightExpression = new MockExpression(true); AndOperator expression = new AndOperator(leftExpression, rightExpression); Assert.IsFalse(expression.Evaluate(this.principal)); }
public override VariableValue Evaluate(IVariableStore variables) { var left = Left.Evaluate(variables); var right = Right.Evaluate(variables); var result = AndOperator.And(this, ref left, ref right); return(Assign(variables, ref result)); }
public void FilterOrWithAndConditionTest() { string expected = @"<?xml version=""1.0"" encoding=""utf-8""?> <function controlid=""unittest""> <query> <select> <field>BATCHNO</field> <field>RECORDNO</field> <field>STATE</field> </select> <object>GLBATCH</object> <filter> <or> <equalto> <field>JOURNAL</field> <value>APJ</value> </equalto> <and> <greaterthanorequalto> <field>BATCHNO</field> <value>1</value> </greaterthanorequalto> <equalto> <field>STATE</field> <value>Posted</value> </equalto> </and> </or> </filter> <options /> </query> </function>"; SelectBuilder builder = new SelectBuilder(); ISelect[] fields = builder.Fields(new[] { "BATCHNO", "RECORDNO", "STATE" }).GetFields(); AndOperator batchnoAndState = new AndOperator(new List <IFilter>()); batchnoAndState.AddFilter((new Filter("BATCHNO")).SetGreaterThanOrEqualTo("1")); batchnoAndState.AddFilter((new Filter("STATE")).SetEqualTo("Posted")); IFilter journal = new Filter("JOURNAL").SetEqualTo("APJ"); IFilter filter = new OrOperator(new List <IFilter>() { journal, batchnoAndState }); IQueryFunction query = new QueryFunction("unittest") { FromObject = "GLBATCH", SelectFields = fields, Filter = filter }; this.CompareXml(expected, query); }
public void AndApplyConstants() { Constant c1 = Constant.Word32(1); Constant c2 = Constant.Word32(2); BinaryOperator op = new AndOperator(); Constant c3 = op.ApplyConstants(c1, c2); Assert.AreEqual(0, c3.ToInt32()); }
public void Visit(AndOperator node) { VisitBinary(node); ITerminalWrapper leftWrapper = ReferenceTables.GetValue(node.Left); ITerminalWrapper rightWrapper = ReferenceTables.GetValue(node.Right); ReferenceTables.SetValue(node, ((dynamic)leftWrapper) & ((dynamic)rightWrapper)); }
public void PerformLogicWithFalseInitializationAndFalse() { var andOperator = new AndOperator(false); Assert.IsNotNull(andOperator); var result = andOperator.PerformLogic(false); Assert.IsFalse(andOperator.Result); Assert.AreEqual(andOperator.Result, result); }
public EvaluationTreeTestViewModel() { var node1 = new ComparisonOperator <string>("a", "b", BooleanOperatorTypeEnum.EqualOrLess); var node2 = new ComparisonOperator <string>("c", "d", BooleanOperatorTypeEnum.EqualOrGreater); var node3 = new AndOperator(node1, node2); Debug.WriteLine(string.Format("{0} = {1}", node1.GetNodeAsString(), node1.GetResult())); Debug.WriteLine(string.Format("{0} = {1}", node2.GetNodeAsString(), node2.GetResult())); Debug.WriteLine(string.Format("{0} = {1}", node3.GetNodeAsString(), node3.GetResult())); }
public void PerformLogicWithTrueInitializationAndTrue() { var andOperator = new AndOperator(true); Assert.IsNotNull(andOperator); var result = andOperator.PerformLogic(true); Assert.IsTrue(andOperator.Result); Assert.AreEqual(andOperator.Result, result); }
public void AndExpressionWithoutParentheses() { Parser parser = new Parser(); BooleanExpression expression = parser.Parse("R:Role1 and R:Role2"); Assert.AreEqual(typeof(AndOperator), expression.GetType()); AndOperator andOperator = (AndOperator)expression; Assert.AreEqual(typeof(RoleExpression), andOperator.Left.GetType()); Assert.AreEqual(typeof(RoleExpression), andOperator.Right.GetType()); Assert.AreEqual("Role1", ((RoleExpression)andOperator.Left).Word.Value); Assert.AreEqual("Role2", ((RoleExpression)andOperator.Right).Word.Value); }
public void ComplexExpressionTest() { AndOperator expression = new AndOperator(); expression.Left = new RoleExpression("Managers"); expression.Right = new NotOperator(new IdentityExpression("Bob")); GenericIdentity identity = new GenericIdentity("Bob"); string[] roles = new string[] {"Managers"}; GenericPrincipal principal = new GenericPrincipal(identity, roles); bool result = expression.Evaluate(principal); Assert.IsFalse(result); }
public void AndExpressionTest() { Parser parser = new Parser(); BooleanExpression expression = parser.Parse("(R:Role1 and R:Role2)"); Assert.AreEqual(typeof(AndOperator), expression.GetType()); AndOperator andOperator = (AndOperator)expression; Assert.IsNotNull(andOperator.Left); Assert.IsNotNull(andOperator.Right); Assert.AreEqual(typeof(RoleExpression), andOperator.Left.GetType()); Assert.AreEqual(typeof(RoleExpression), andOperator.Right.GetType()); Assert.AreEqual("Role1", ((RoleExpression)andOperator.Left).Word.Value); Assert.AreEqual("Role2", ((RoleExpression)andOperator.Right).Word.Value); }
public void AndOperator_ShouldPrint() { var ast = new AndOperator ( position: 0, left: new Identifier(0, "x"), right: new Identifier(0, "y") ); Assert.That(PrettyPrinter.ToString(ast), Is.EqualTo( @"And Identifier(x) Identifier(y) ")); }
public void ComplexExpressionTest() { AndOperator expression = new AndOperator(); expression.Left = new RoleExpression("Managers"); expression.Right = new NotOperator(new IdentityExpression("Bob")); GenericIdentity identity = new GenericIdentity("Bob"); string[] roles = new string[] { "Managers" }; GenericPrincipal principal = new GenericPrincipal(identity, roles); bool result = expression.Evaluate(principal); Assert.IsFalse(result); }
public void CanPerformMultiOperationalExpression(int a, int b, int c, int d) { Dictionary <string, bool> expectedAnswersMap = new Dictionary <string, bool> { { "0000", false }, { "1000", false }, { "0100", false }, { "0010", false }, { "0001", true }, { "1100", false }, { "1010", true }, { "1001", true }, { "0110", true }, { "0101", true }, { "0011", true }, { "1110", true }, { "0111", true }, { "1101", true }, { "1011", true }, { "1111", true }, }; LeafNode <int> A = new LeafNode <int>(a, SimpleValueExpressionFunction); LeafNode <int> B = new LeafNode <int>(b, SimpleValueExpressionFunction); LeafNode <int> C = new LeafNode <int>(c, SimpleValueExpressionFunction); LeafNode <int> D = new LeafNode <int>(d, SimpleValueExpressionFunction); List <Node> firstOrChildren = new List <Node> { A, B }; List <Node> middleAndChildren = new List <Node>(); List <Node> lastOrChildren = new List <Node>(); Operator andOp = new AndOperator(); Operator orOp = new OrOperator(); OperatorNode firstOr = new OperatorNode(firstOrChildren, orOp); middleAndChildren.Add(firstOr); middleAndChildren.Add(C); OperatorNode middleAnd = new OperatorNode(middleAndChildren, andOp); lastOrChildren.Add(middleAnd); lastOrChildren.Add(D); OperatorNode lastOr = new OperatorNode(lastOrChildren, orOp); Assert.Equal(lastOr.Evaluate(), expectedAnswersMap[$"{a}{b}{c}{d}"]); }
public void AndNotTest() { Parser parser = new Parser(); BooleanExpression expression = parser.Parse("R:Managers AND NOT I:Bob"); AndOperator andOperator = (AndOperator)expression; RoleExpression roleExpression = (RoleExpression)andOperator.Left; Assert.AreEqual("Managers", roleExpression.Word.Value); NotOperator notOperator = (NotOperator)andOperator.Right; IdentityExpression identityExpression = (IdentityExpression)notOperator.Expression; Assert.AreEqual("Bob", identityExpression.Word.Value); }
public void MultipleAndExpressionWithParentheses() { Parser parser = new Parser(); BooleanExpression expression = parser.Parse("R:Role1 and R:Role2 and I:User1"); Assert.AreEqual(typeof(AndOperator), expression.GetType()); AndOperator andOperator = (AndOperator)expression; Assert.IsNotNull(andOperator.Left); Assert.IsNotNull(andOperator.Right); Assert.AreEqual("User1", ((IdentityExpression)andOperator.Right).Word.Value); AndOperator leftAndOperator = (AndOperator)andOperator.Left; Assert.AreEqual("Role2", ((RoleExpression)leftAndOperator.Right).Word.Value); }
public void NullFilterTest() { Stream stream = new MemoryStream(); XmlWriterSettings xmlSettings = new XmlWriterSettings { Encoding = Encoding.GetEncoding("UTF-8") }; IaXmlWriter xml = new IaXmlWriter(stream, xmlSettings); IFilter andFilter = new AndOperator(null); var ex = Record.Exception(() => andFilter.WriteXml(ref xml)); Assert.IsType <IntacctException>(ex); Assert.Equal("Two or more IFilter objects required for and", ex.Message); }
/* Methods */ private void Tokenize() { tokens = new List<Token>(); Token prev = null; Token t = null; while (_inputReader.Peek() != -1) { char c = (char)_inputReader.Read(); switch (c) { case Token.AND: t = new AndOperator(); tokens.Add(t); break; case Token.OR: t = new OrOperator(); tokens.Add(t); break; case Token.LEFT_PAREN: // Insert implicit AND operators before ( if ((prev is RightParenthesis) || (prev is Literal) || (prev is NotOperator)) tokens.Add(new AndOperator()); t = new LeftParenthesis(); tokens.Add(t); break; case Token.RIGHT_PAREN: t = new RightParenthesis(); tokens.Add(t); break; case Token.NOT: t = new NotOperator(); tokens.Add(t); break; default: t = new Literal(c); // Insert implicit AND operators before Literals if ((prev is RightParenthesis) || (prev is Literal) || (prev is NotOperator)) tokens.Add(new AndOperator()); tokens.Add(t); break; } prev = t; } }
public void FilterAndConditionTest() { string expected = @"<?xml version=""1.0"" encoding=""utf-8""?> <function controlid=""unittest""> <query> <select> <field>CUSTOMERID</field> <field>RECORDNO</field> </select> <object>ARINVOICE</object> <filter> <and> <greaterthanorequalto> <field>RECORDNO</field> <value>1</value> </greaterthanorequalto> <lessthanorequalto> <field>RECORDNO</field> <value>100</value> </lessthanorequalto> </and> </filter> <options /> </query> </function>"; SelectBuilder builder = new SelectBuilder(); ISelect[] fields = builder.Fields(new[] { "CUSTOMERID", "RECORDNO" }).GetFields(); AndOperator filter = new AndOperator(new List <IFilter>()); filter.AddFilter((new Filter("RECORDNO")).SetGreaterThanOrEqualTo("1")); filter.AddFilter((new Filter("RECORDNO")).SetLessThanOrEqualTo("100")); IQueryFunction query = new QueryFunction("unittest") { FromObject = "ARINVOICE", SelectFields = fields, Filter = filter }; this.CompareXml(expected, query); }
public override string BuildSql(SqlOptions sqlOptions) { AndOperator andBlock; if (Entities.Count == 1 && Entities[0] is AndOperator andOperator) { andBlock = andOperator; } else { andBlock = new AndOperator(Entities); } andBlock.Indent = true; andBlock.NewLine = true; var conditions = andBlock.BuildSql(sqlOptions, FlowOptions.Construct(this)); var command = sqlOptions.Command("WHERE"); return($"{command}{sqlOptions.NewLine()}{sqlOptions.Indent(" ")}{conditions}"); }
public RuleFilter(AndOperator theAndOperator, string prefix, Tagging tag) { TheAndOperator = theAndOperator; if (string.IsNullOrWhiteSpace(prefix) || string.IsNullOrEmpty(prefix)) { Prefix = null; } else { Prefix = prefix; } if (tag != null && tag.TaggingSet.Tag.Count == 0) { tag = null; } else { Tag = tag; } }
public void SingleFilterTest() { Stream stream = new MemoryStream(); XmlWriterSettings xmlSettings = new XmlWriterSettings { Encoding = Encoding.GetEncoding("UTF-8") }; IaXmlWriter xml = new IaXmlWriter(stream, xmlSettings); List <IFilter> filters = new List <IFilter>(); filters.Add((new Filter("RECORDNO")).SetGreaterThanOrEqualTo("1")); IFilter andFilter = new AndOperator(filters); var ex = Record.Exception(() => andFilter.WriteXml(ref xml)); Assert.IsType <IntacctException>(ex); Assert.Equal("Two or more IFilter objects required for and", ex.Message); }
public void CreateExpressionTest1() { // Arrange var parameterExpression = Expression.Parameter(typeof(Employee), "sample"); var expressionProperty = Expression.Property(parameterExpression, nameof(Employee.FirstName)); var containsOperator = new ContainsOperator(); Expression leftExpression = containsOperator.CreateExpression(expressionProperty, Expression.Constant("xxx")); Expression rightExpression = containsOperator.CreateExpression(expressionProperty, Expression.Constant("yyy")); Expression expectedExpression = Expression.And(leftExpression, rightExpression); var _operator = new AndOperator(); // Act Expression resultExpression = _operator.CreateExpression(leftExpression, rightExpression); // Assert Assert.AreEqual(expectedExpression.ToString(), resultExpression.ToString(), "Expression not correct"); }
public void Visit(AndOperator and) { var falseLabel = MakeNewLabel(); var endLabel = MakeNewLabel(); and.Left.Accept(this); var leftOperand = tacs.Last().Result; tacs.Add(Tac.IfFalse(leftOperand, falseLabel)); and.Right.Accept(this); var rightOperand = tacs.Last().Result; tacs.Add(Tac.IfFalse(rightOperand, falseLabel)); var resultVariable = MakeNewTemp(); tacs.Add(Tac.Assign("1", resultVariable)); tacs.Add(Tac.Goto(endLabel)); tacs.Add(Tac.Label(falseLabel, resultVariable)); tacs.Add(Tac.Assign("0", resultVariable)); tacs.Add(Tac.Label(endLabel, resultVariable)); }
public void BuildSupplyPoint() { MarketDB.Instance.InsertByForce(); datalayer = PolicyDL.Instance; UsernameEqualsLeaf2 = new UsernameEquals(PolicyType.Global, "bla", "bla_bla", 1); UsernameEqualsLeaf = new UsernameEquals(PolicyType.Global, "bla", "bla_bla", 2); QuantityLessThanLeaf = new QuantityLessThan(PolicyType.Global, "bla", "bla_bla", 3); QuantityGreaterThanLeaf = new QuantityGreaterThan(PolicyType.Global, "bla", "bla_bla", 4); PriceLessThanLeaf = new PriceLessThan(PolicyType.Global, "bla", "bla_bla", 5); PriceGreaterThanLeaf = new PriceGreaterThan(PolicyType.Global, "bla", "bla_bla", 6); AddressEqualsLeaf = new AddressEquals(PolicyType.Global, "bla", "bla_bla", 7); AndHas0opSun = new AndOperator(PolicyType.Global, "bla", PriceGreaterThanLeaf, PriceLessThanLeaf, 8); AndHas1opSun = new AndOperator(PolicyType.Global, "bla", AndHas0opSun, UsernameEqualsLeaf2, 9); OrHas0opSun = new OrOperator(PolicyType.Global, "bla", QuantityLessThanLeaf, QuantityGreaterThanLeaf, 10); OrHas1opSun = new OrOperator(PolicyType.Global, "bla", OrHas0opSun, UsernameEqualsLeaf, 11); NotHasCondSun = new NotOperator(PolicyType.Global, "bla", AddressEqualsLeaf, null, 12); NotHasopSun = new NotOperator(PolicyType.Global, "bla", NotHasCondSun, null, 13); OrHas2opSuns = new OrOperator(PolicyType.Global, "bla", AndHas1opSun, OrHas1opSun, 14); ROOT_AndHas2opSuns = new AndOperator(PolicyType.Global, "bla", OrHas2opSuns, NotHasopSun, 15); BadInputLeaf = new UsernameEquals(PolicyType.Global, "bla", "bla'bla", 1); }
public void CanPerformSimpleAndTree() { List <Node> children = new List <Node> { new LeafNode <int>(0, SimpleValueExpressionFunction), new LeafNode <int>(0, SimpleValueExpressionFunction) }; Operator op = new AndOperator(); OperatorNode opNode00 = new OperatorNode(children, op); children = new List <Node> { new LeafNode <int>(0, SimpleValueExpressionFunction), new LeafNode <int>(1, SimpleValueExpressionFunction) }; OperatorNode opNode01 = new OperatorNode(children, op); children = new List <Node> { new LeafNode <int>(1, SimpleValueExpressionFunction), new LeafNode <int>(0, SimpleValueExpressionFunction) }; OperatorNode opNode10 = new OperatorNode(children, op); children = new List <Node> { new LeafNode <int>(1, SimpleValueExpressionFunction), new LeafNode <int>(1, SimpleValueExpressionFunction) }; OperatorNode opNode11 = new OperatorNode(children, op); Assert.False(opNode00.Evaluate()); Assert.False(opNode01.Evaluate()); Assert.False(opNode10.Evaluate()); Assert.True(opNode11.Evaluate()); }
public void AndOrNotTest() { Parser parser = new Parser(); BooleanExpression expression = parser.Parse( "(R:HumanSR OR R:GeneralManagers) AND NOT R:HRSpecialist"); AndOperator andOperator = (AndOperator)expression; OrOperator orOperator = (OrOperator)andOperator.Left; RoleExpression hrRoleExpression = (RoleExpression)orOperator.Left; Assert.AreEqual("HumanSR", hrRoleExpression.Word.Value); RoleExpression gmRoleExpression = (RoleExpression)orOperator.Right; Assert.AreEqual("GeneralManagers", gmRoleExpression.Word.Value); NotOperator notOperator = (NotOperator)andOperator.Right; RoleExpression specialistRoleExpression = (RoleExpression)notOperator.Expression; Assert.AreEqual("HRSpecialist", specialistRoleExpression.Word.Value); }
private static ExpTreeNode GetAsExpressionTree(this ParseTreeNode parsedNode, ExpTreeNode parentExpNode) { //The current node is a variable / value token. Create a value node and return it back if (!parsedNode.ChildNodes.Any()) { switch (parsedNode.Term.Name) { case "variable": { var varName = parsedNode.FindTokenAndGetValue <string>(); return(new VariableValue(varName, parentExpNode)); } case "boolean": return(new LiteralValue(parsedNode.FindTokenAndGetValue <bool>(), parentExpNode)); case "integer": case "decimal": return(new LiteralValue(parsedNode.FindTokenAndGetValue <double>(), parentExpNode)); case "SingleQuoteString": case "DoubleQuoteString": return(new LiteralValue(parsedNode.FindTokenAndGetValue <string>(), parentExpNode)); default: throw parsedNode.GetException($"Invalid token type '{parsedNode.Term.Name}' in expression"); } } // Look on the next node down else if (parsedNode.ChildNodes.Count == 1) { return(GetAsExpressionTree(parsedNode.ChildNodes[0], parentExpNode)); } //Ignore parenthesis, the middle non-terminal is what we want // Look on the next node down else if (parsedNode.ChildNodes.Count == 3 && parsedNode.ChildNodes[0]?.Token?.Text == "(") { return(GetAsExpressionTree(parsedNode.ChildNodes[1], parentExpNode)); } //Binary operator else if (parsedNode.ChildNodes.Count == 3) { BinaryOperatorBase binaryOp; var opStr = parsedNode.ChildNodes[1].FindToken().ValueString; switch (opStr) { // Math case "+": binaryOp = new AdditionOperator(parentExpNode); break; case "-": binaryOp = new SubtractionOperator(parentExpNode); break; case "*": binaryOp = new MultiplacationOperator(parentExpNode); break; case "/": binaryOp = new DivisionOperator(parentExpNode); break; case "%": binaryOp = new ModulusOperator(parentExpNode); break; case "^": binaryOp = new PowerOperator(parentExpNode); break; // Bool case "~==": binaryOp = new LooseEqualsOperator(parentExpNode); break; case "~!=": binaryOp = new LooseNotEqualsOperator(parentExpNode); break; case "==": binaryOp = new EqualsOperator(parentExpNode); break; case "!=": binaryOp = new NotEqualsOperator(parentExpNode); break; case "like": binaryOp = new LikeOperator(parentExpNode); break; case "match": binaryOp = new MatchOperator(parentExpNode); break; case ">": binaryOp = new GreaterThanOperator(parentExpNode); break; case ">=": binaryOp = new GreaterThanOrEqualOperator(parentExpNode); break; case "<": binaryOp = new LessThanOperator(parentExpNode); break; case "<=": binaryOp = new LessThanOrEqualOperator(parentExpNode); break; case "&&": binaryOp = new AndOperator(parentExpNode); break; case "||": binaryOp = new OrOperator(parentExpNode); break; default: throw parsedNode.ChildNodes[1].GetException($"Unrecognized operator '{opStr}'"); } binaryOp.LeftOperand = GetAsExpressionTree(parsedNode.ChildNodes[0], binaryOp); binaryOp.RightOperand = GetAsExpressionTree(parsedNode.ChildNodes[2], binaryOp); //Optimize if (binaryOp.LeftOperand is LiteralValue && binaryOp.RightOperand is LiteralValue) { return(new LiteralValue(binaryOp.Eval(), parentExpNode)); } return(binaryOp); } // Unary operator else if (parsedNode.ChildNodes.Count == 2) { var opVal = parsedNode.ChildNodes[0].FindToken().Value; UnaryOperatorBase unaryOp; if (parsedNode.ChildNodes[0].FindToken().Value is TypeCode convertType) { unaryOp = new TypeConversionOperator(convertType, parentExpNode); } else { var opStr = opVal.ToString(); switch (opStr) { case "!": unaryOp = new NotOperator(parentExpNode); break; //Property Checking case "lengthof": unaryOp = new LengthOperator(parentExpNode); break; case "typeof": unaryOp = new TypeOperator(parentExpNode); break; default: unaryOp = new GenericUnaryMathFunctionOperator(opStr, parentExpNode); break; } } unaryOp.Operand = GetAsExpressionTree(parsedNode.ChildNodes[1], unaryOp); //Optimize if (unaryOp.Operand is LiteralValue) { return(new LiteralValue(unaryOp.Eval(), parentExpNode)); } return(unaryOp); } else { throw parsedNode.GetException($"Invalid number of tokens ({parsedNode.ChildNodes.Count})"); } }
public void Visit(AndOperator node) { }
/// <summary> /// Processes the and operator. /// </summary> /// <param name="inputAndOperator">The input and operator.</param> /// <returns></returns> private static AndConditionOperator <LanguageUnderstandingResult> ProcessAndOperator(AndOperator inputAndOperator) { var andOperator = new CognitiveServices.LanguageUnderstanding.Conditions.AndConditionOperator <LanguageUnderstandingResult>(); var operators = ProcessSuboperators(inputAndOperator); andOperator.Operators = operators.ToArray(); return(andOperator); }