public override void Visit(OrExpression expression) { _expressionString.Append(" ("); Visit(expression.Left); _expressionString.Append(" || "); Visit(expression.Right); _expressionString.Append(") "); }
public virtual void Visit(OrExpression expression) { expression.Left().Accept(this); var left = _constraint; expression.Right().Accept(this); left.Or(_constraint); _constraint = left; }
private Expression CreateExpression(List <Token> tokens) { Expression currExpression = null; if (mTokenIdx >= tokens.Count) { return(currExpression); } if (tokens[mTokenIdx].mType == eTokenType.TOK_CONDITION) { currExpression = new ConditionExpression(tokens[mTokenIdx].mIndex); mExpressions.Add(currExpression); } else if (tokens[mTokenIdx].mType == eTokenType.TOK_OPEN_PAREN) { mTokenIdx += 1; currExpression = CreateExpression(tokens); } else if (tokens[mTokenIdx].mType == eTokenType.TOK_NOT) { mTokenIdx += 1; Expression childExpression = CreateExpression(tokens); Expression expression = new NotExpression(childExpression); mExpressions.Add(expression); currExpression = expression; } // Right Expressions if (mTokenIdx + 1 >= tokens.Count) { return(currExpression); } mTokenIdx += 1; if (tokens[mTokenIdx].mType == eTokenType.TOK_AND) { mTokenIdx += 1; Expression childA = currExpression; Expression childB = CreateExpression(tokens); Expression expression = new AndExpression(childA, childB); mExpressions.Add(expression); currExpression = expression; } else if (tokens[mTokenIdx].mType == eTokenType.TOK_OR) { mTokenIdx += 1; Expression childA = currExpression; Expression childB = CreateExpression(tokens); Expression expression = new OrExpression(childA, childB); mExpressions.Add(expression); currExpression = expression; } return(currExpression); }
public void TestRightTrueEvaluate() { var expression = new OrExpression( Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)false), Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)true), ExpressiveOptions.None); Assert.AreEqual(true, expression.Evaluate(null)); }
public override IList GetDataSource() { ICriteria crit = DBConnection.Session.CreateCriteria(PersistentType); if (tipos == null || tipos.Count == 0) { crit.Add(new EqExpression("Supertipo", tipo)); } else if (tipos.Count == 1) { crit.Add(new EqExpression("Supertipo", tipos[0])); } else { if (tipos.Count > 1) { OrExpression orExp = null; ICriterion eqTipo1; EqExpression eqTipo2; int i = 0; for (int j = 0; j < tipos.Count - 1; j++) { if (orExp == null) { eqTipo1 = new EqExpression("Supertipo", tipos[j]); } else { eqTipo1 = orExp; } eqTipo2 = new EqExpression("Supertipo", tipos[j + 1]); orExp = new OrExpression(eqTipo1, eqTipo2); } crit.Add(orExp); /*EqExpression eqTipo1 = new EqExpression("Supertipo", tipo); * EqExpression eqTipoNC = new EqExpression("Supertipo", TiposComprobantesList.NotaCredito); * OrExpression orExp = new OrExpression(eqTipo1, eqTipoNC); * crit.Add(orExp);*/ } } if (!String.IsNullOrEmpty(estado)) { crit.Add(new EqExpression("Estado", estado)); } if (emisionHoy) { DateTime fechaDesde = DateTime.Now.Date; DateTime fechaHasta = DateTime.Now.Date.AddDays(1); crit.Add(Expression.Between("Emision", fechaDesde, fechaHasta)); } emisionHoy = false; return(crit.List()); }
private void DoTestEvaluate(IExpression a, IExpression b, bool expected) { // Arrange IExpression expression = new OrExpression(a, b); // Act bool result = expression.Evaluate(null); // Assert Assert.AreEqual(expected, result); }
private static PythonNode Wrap(OrExpression exp, PythonNode parent) { var result = new OrExpressionNode(exp) { Parent = parent }; result.AddChild(Wrap(exp.Left, result)); result.AddChild(Wrap(exp.Right, result)); return(result); }
public void ParseAndOrExpression() { IExpression expression = ParseExpression("k==1 && l==1 || j==1"); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(OrExpression)); OrExpression orexpr = (OrExpression)expression; Assert.IsInstanceOfType(orexpr.LeftExpression, typeof(AndExpression)); Assert.IsInstanceOfType(orexpr.RightExpression, typeof(CompareExpression)); }
public void Implements_IsEquivalentTo_Correctly(OrExpression first, FilterExpression other, bool expected, string reason) { _outputHelper.WriteLine($"First instance : {first}"); _outputHelper.WriteLine($"Second instance : {other}"); // Act bool actual = first.IsEquivalentTo(other); // Assert actual.Should() .Be(expected, reason); }
public void Should_parse_OrExpression(string input, OrExpression expected) { // Arrange _outputHelper.WriteLine($"input : '{input}'"); TokenList <FilterToken> tokens = _tokenizer.Tokenize(input); // Act OrExpression expression = FilterTokenParser.Or.Parse(tokens); // Assert AssertThatShould_parse(expression, expected); }
public Expression VisitAndConvert(IExpression expression) { return(expression switch { AndExpression andExpression => VisitAndConvert(andExpression), CompareExpression compareExpression => VisitAndConvert(compareExpression), InExpression inExpression => VisitAndConvert(inExpression), NotExpression notExpression => VisitAndConvert(notExpression), OrExpression orExpression => VisitAndConvert(orExpression), AssignExpression assignExpression => VisitAndConvert(assignExpression), _ => null });
public void Equals_should_behave_has_expected(OrExpression first, object other, bool expected, string reason) { _outputHelper.WriteLine($"First instance : {first}"); _outputHelper.WriteLine($"Second instance : {other}"); // Act bool actual = first.Equals(other); // Assert actual.Should() .Be(expected, reason); }
public void Visit(OrExpression expression) { var parentArgs = _visitStack.Peek() as QueryPhaseArgs; var leftArts = new QueryPhaseArgs(); VisitChild(expression.Left, leftArts); var rightArgs = new QueryPhaseArgs(); VisitChild(expression.Right, rightArgs); parentArgs.RowResult = leftArts.RowResult || rightArgs.RowResult; }
public virtual object Walk(OrExpression node) { if (Enter(node)) { node.LeftExpression.Accept(this); if (node.RightExpression != null) { node.RightExpression.Accept(this); } } Exit(node); return(null); }
public void TestShortCircuit() { var rightHandMock = new Mock <IExpression>(); var expression = new OrExpression( Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)true), rightHandMock.Object, new Context(ExpressiveOptions.None)); expression.Evaluate(null); rightHandMock.Verify(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()), Times.Never); }
public void Visit(OrExpression expression) { foreach (var queryExpression in expression.Expressions) { var matcher = new InMemoryRowMatcher(_row, queryExpression, _tableIdentifier); if (matcher.IsMatch()) { return; } } _isMatch = false; }
/// <summary> /// Serialize the <see cref="OrExpression"/> /// </summary> /// <param name="orExpression">The <see cref="OrExpression"/> to serialize</param> /// <returns>The <see cref="JObject"/></returns> private JObject Serialize(OrExpression orExpression) { var jsonObject = new JObject(); jsonObject.Add("classKind", this.PropertySerializerMap["classKind"](Enum.GetName(typeof(CDP4Common.CommonData.ClassKind), orExpression.ClassKind))); jsonObject.Add("excludedDomain", this.PropertySerializerMap["excludedDomain"](orExpression.ExcludedDomain.OrderBy(x => x, this.guidComparer))); jsonObject.Add("excludedPerson", this.PropertySerializerMap["excludedPerson"](orExpression.ExcludedPerson.OrderBy(x => x, this.guidComparer))); jsonObject.Add("iid", this.PropertySerializerMap["iid"](orExpression.Iid)); jsonObject.Add("modifiedOn", this.PropertySerializerMap["modifiedOn"](orExpression.ModifiedOn)); jsonObject.Add("revisionNumber", this.PropertySerializerMap["revisionNumber"](orExpression.RevisionNumber)); jsonObject.Add("term", this.PropertySerializerMap["term"](orExpression.Term.OrderBy(x => x, this.guidComparer))); jsonObject.Add("thingPreference", this.PropertySerializerMap["thingPreference"](orExpression.ThingPreference)); return(jsonObject); }
/// <see cref="IUsuarioDao.BuscarUsuarios(Usuario)" /> public IList BuscarUsuarios(Usuario templateUsuario) { ICriteria criteria = this.HibernateTemplate.Session.CreateCriteria(typeof(Usuario)); OrExpression orExpression = new OrExpression( new LikeExpression("nombre", templateUsuario.Nombre, MatchMode.Anywhere), new OrExpression( new LikeExpression("apodo", templateUsuario.Nombre, MatchMode.Anywhere), new LikeExpression("nombreCompleto", templateUsuario.Nombre, MatchMode.Anywhere) ) ); criteria.Add(orExpression); criteria.AddOrder(new Order("nombre", true)); return(criteria.List()); }
public void Constructor() { var termA = new FuzzyTerm("TermA", new MembershipFunction()); var termB = new FuzzyTerm("TermB", new MembershipFunction()); var varA = new FuzzyVariable("Variable A", null, termA); var varB = new FuzzyVariable("Variable B", null, termB); var exprA = new ValueExpression(varA, termA); var exprB = new ValueExpression(varB, termB); var sut = new OrExpression(exprA, exprB); Assert.AreEqual(exprA, sut.LeftExpression); Assert.AreEqual(exprB, sut.RightExpression); }
public ExprNode ParseLogicalOrExpression() { var exp = new OrExpression { Token = Next(), LeftExpression = ParseLogicalAndExpression() }; if (Next().IsNot(TokenType.LogicalOr)) { return(exp.LeftExpression); } Match(TokenType.LogicalOr); exp.RightExpression = ParseLogicalOrExpression(); return(exp); }
public void It_Should_OR_Two_Arguments(bool expected, bool expr1, bool expr2) { // Arrange var expr = new OrExpression(); // Act var result = expr.Eval(new TemplateContext(), new List <Option <ILiquidValue> >() { new LiquidBoolean(expr1), new LiquidBoolean(expr2) }).SuccessValue <LiquidBoolean>().BoolValue; // Assert Assert.That(result, Is.EqualTo(expected)); }
private IExpression ParseOrLogicalExpression() { IExpression expr = this.ParseAndLogicalExpression(); if (expr == null) { return(null); } while (this.TryParseToken(TokenType.Name, "or")) { expr = new OrExpression(expr, this.ParseAndLogicalExpression()); } return(expr); }
private IExpression GetExpression <T>(string expressionOne, string expressionTwo) { IExpression expression = null; var eOne = new TerminalExpression(expressionOne); var eTwo = new TerminalExpression(expressionTwo); if (typeof(T) == typeof(AndExpression)) { expression = new AndExpression(eOne, eTwo); } else if (typeof(T) == typeof(OrExpression)) { expression = new OrExpression(eOne, eTwo); } return(expression); }
public void Main() { IExpression person1 = new TerminalExpression.TerminalExpression("Kushagra"); IExpression person2 = new TerminalExpression.TerminalExpression("Lokesh"); IExpression isSingle = new OrExpression(person1, person2); IExpression vikram = new TerminalExpression.TerminalExpression("Vikram"); IExpression committed = new TerminalExpression.TerminalExpression("Committed"); IExpression isCommitted = new AndExpression(vikram, committed); Console.WriteLine(isSingle.Interpret("Kushagra")); Console.WriteLine(isSingle.Interpret("Lokesh")); Console.WriteLine(isSingle.Interpret("Achint")); Console.WriteLine(isCommitted.Interpret("Committed, Vikram")); Console.WriteLine(isCommitted.Interpret("Single, Vikram")); }
public void Reduce_OrWithRightConstantOperand() { var expr = new OrExpression(0, 1, new AttributeAccessExpression(0, 0, "a"), new ConstantExpression(0, 2, new IntValue(1))); var reduced = expr.Accept(_visitor); Assert.IsInstanceOfType(reduced, typeof(ConstantExpression)); var constant = (ConstantExpression)reduced; Assert.IsFalse(constant.Value.IsNull); Assert.AreEqual(0, constant.Line); Assert.AreEqual(2, constant.Column); }
public void Reduce_OrWithBothOperandsNull() { var expr = new OrExpression(0, 1, new ConstantExpression(0, 0, new IntValue(null)), new ConstantExpression(0, 2, new IntValue(null))); var reduced = expr.Accept(_visitor); Assert.IsInstanceOfType(reduced, typeof(ConstantExpression)); var constant = (ConstantExpression)reduced; Assert.IsTrue(constant.Value.IsNull); Assert.AreEqual(0, constant.Line); Assert.AreEqual(0, constant.Column); }
public void Disjunction_of_multiple_equality_comparisons_is_parsed_into_OrExpression_with_corresponding_property_names_and_values() { var pageCount = 123; var expression = _parser.Parse <Book>( x => x.AuthorName == "An author name" || x.Title == GetTitle() || x.PageCount == pageCount || x.Isbn == "123-456-789"); var expectedExpression = new OrExpression( new EqualsExpression(new PropertyExpression("AuthorName", typeof(string)), new ValueExpression("An author name")), new EqualsExpression(new PropertyExpression("Title", typeof(string)), new ValueExpression("a title")), new EqualsExpression(new PropertyExpression("PageCount", typeof(int)), new ValueExpression(123)), new EqualsExpression(new PropertyExpression("Isbn", typeof(string)), new ValueExpression("123-456-789"))); Assert.AreEqual(expectedExpression, expression); }
private static QueryExpression ParseOr(EntityConfiguration configuration, Tokenizer tokenizer) { if (tokenizer.Current == null) { throw new InvalidOperationException("Invalid expression!"); } var expression = ParseAnd(configuration, tokenizer); while (tokenizer.Current?.Type == TokenType.Or) { tokenizer.MoveNext(); expression = new OrExpression(expression, ParseAnd(configuration, tokenizer)); } return(expression); }
public void OrBoolean__CorrectValuesReturned(bool lhsValue, bool rhsValue, bool expected) { BooleanLiteralExpression lhs = Utilities.GetBoolLitExpression(lhsValue); BooleanLiteralExpression rhs = Utilities.GetBoolLitExpression(rhsValue); OrExpression orExpr = new OrExpression(lhs, rhs, 0, 0); IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>(); parent.DispatchBoolean(lhs, Arg.Any <List <object> >()).Returns(lhsValue); parent.DispatchBoolean(rhs, Arg.Any <List <object> >()).Returns(rhsValue); BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent); bool res = booleanHelper.OrBoolean(orExpr, new List <object>()); Assert.AreEqual(expected, res); }
public override Element VisitBoolStatementExp(SqlParser.BoolStatementExpContext context) { var left = Visit(context.l); int x = 2; while (x < context.ChildCount) { var right = Visit(context.GetChild(x)); left = new OrExpression(CreateParseInfo(context)) { Left = left, Right = right }; x += 2; } return(left); }
void IExpressionVisitor.Visit(OrExpression expression) { Label labelTrue = generator.DefineLabel(); Label labelEnd = generator.DefineLabel(); expression.LeftChildExpression.AcceptInternal(this); if (expression.ResultType != DataType.Logic) { expression.TrueValue.AcceptInternal(this); generator.Emit(OpCodes.Ceq); } generator.IfTrueGoto(labelTrue); expression.RightChildExpression.AcceptInternal(this); generator.Goto(labelEnd); generator.MarkLabel(labelTrue); expression.TrueValue.AcceptInternal(this); generator.MarkLabel(labelEnd); }
public void GetAndEvaluateOrExpression() { OrExpression expression = OrExpression.Instance; Assert.IsNotNull(expression); Machine machine = new Machine(); machine.Push(true); machine.Push(true); expression.Evaluate(machine); Assert.AreEqual(1, machine.StackCount); Assert.IsTrue((bool)machine.Pop()); Assert.AreEqual(0, machine.StackCount); machine.Push(true); machine.Push(false); expression.Evaluate(machine); Assert.AreEqual(1, machine.StackCount); Assert.IsTrue((bool)machine.Pop()); Assert.AreEqual(0, machine.StackCount); machine.Push(false); machine.Push(true); expression.Evaluate(machine); Assert.AreEqual(1, machine.StackCount); Assert.IsTrue((bool)machine.Pop()); Assert.AreEqual(0, machine.StackCount); machine.Push(false); machine.Push(false); expression.Evaluate(machine); Assert.AreEqual(1, machine.StackCount); Assert.IsFalse((bool)machine.Pop()); Assert.AreEqual(0, machine.StackCount); }
public void VisitOr() { var valueExpr1 = new ValueExpression( new FuzzyVariable("MyFuzzyVariable1", new NumericVariable("MyNumVariable1")), new FuzzyTerm("MyTerm1", new MembershipFunction())); var valueExpr2 = new ValueExpression( new FuzzyVariable("MyFuzzyVariable2", new NumericVariable("MyNumVariable2")), new FuzzyTerm("MyTerm2", new MembershipFunction())); var orExpr = new OrExpression(valueExpr1, valueExpr2); var sut = new ToStringVisitor(); var result = sut.Visit(orExpr); Assert.AreEqual("MyFuzzyVariable1=MyTerm1 || MyFuzzyVariable2=MyTerm2", result); result = orExpr.Accept(sut); Assert.AreEqual("MyFuzzyVariable1=MyTerm1 || MyFuzzyVariable2=MyTerm2", result); }
public void Accept() { var termA = new FuzzyTerm("TermA", new MembershipFunction()); var termB = new FuzzyTerm("TermB", new MembershipFunction()); var varA = new FuzzyVariable("Variable A", null, termA); var varB = new FuzzyVariable("Variable B", null, termB); var mocks = new MockRepository(); var visitor = mocks.StrictMock<IExpressionVisitor<int>>(); var sut = new OrExpression(new ValueExpression(varA, termA), new ValueExpression(varB, termB)); Expect.Call(visitor.Visit(sut)).Return(42); mocks.ReplayAll(); var result = sut.Accept(visitor); Assert.AreEqual(42, result); mocks.VerifyAll(); }
public virtual object Walk(OrExpression node) { if (Enter(node)) { node.LeftExpression.Accept(this); if (node.RightExpression != null) node.RightExpression.Accept(this); } Exit(node); return null; }
public SingleExpression(TextReader reader) { while (reader.Peek() != -1) { char c = (char)reader.Peek(); if (c == '(') { reader.Read(); Expression = new SingleExpression(reader); if ((char)reader.Read() != ')') throw new Exception("Expected )"); } else if (c == ')') { return; } else if (c == '[') { reader.Read(); Expression = new RangeExpression(reader); if ((char)reader.Read() != ']') throw new Exception("Expected ]"); } else if (c == '{') { reader.Read(); Expression = new RepeatExpression(reader) { Expression = Expression }; if ((char)reader.Read() != '}') throw new Exception("Expected }"); } else if (c == '|') { reader.Read(); Expression = new OrExpression { Left = Expression, Right = new SingleExpression(reader) }; } else if (c == '.') { reader.Read(); Expression = new ConcatExpression { Left = Expression, Right = new SingleExpression(reader).Expression }; } else if (c == '*') { reader.Read(); Expression = new StarExpression { Expression = Expression }; } else if (c == '+') { reader.Read(); Expression = new PlusExpression { Expression = Expression }; } else { throw new Exception("Unexpected " + c); } } }
public void VisitOr() { var variable1 = new FuzzyVariable("MyFuzzyVariable1", new NumericVariable("MyNumVariable1")); var variable2 = new FuzzyVariable("MyFuzzyVariable2", new NumericVariable("MyNumVariable2")); var valueExpr1 = new ValueExpression( variable1, new FuzzyTerm("MyTerm1", new MembershipFunction())); var valueExpr2 = new ValueExpression( variable2, new FuzzyTerm("MyTerm2", new MembershipFunction())); var orExpr = new OrExpression(valueExpr1, valueExpr2); var sut = new GetInvolvedVariables(); var result = sut.Visit(orExpr); Assert.AreEqual(2, result.Count); Assert.IsTrue(result.Contains(variable1)); Assert.IsTrue(result.Contains(variable2)); result = orExpr.Accept(sut); Assert.AreEqual(2, result.Count); Assert.IsTrue(result.Contains(variable1)); Assert.IsTrue(result.Contains(variable2)); }
public virtual void PostWalk(OrExpression node) { }
public override void PostWalk(OrExpression node) { }
public override void Exit(OrExpression node) { level--; }
public virtual void Exit(OrExpression node) { }
private Expression CreateExpression(List<Token> tokens) { Expression currExpression = null; if (mTokenIdx >= tokens.Count) { return currExpression; } if (tokens[mTokenIdx].mType == eTokenType.TOK_CONDITION) { currExpression = new ConditionExpression(tokens[mTokenIdx].mIndex); mExpressions.Add(currExpression); } else if (tokens[mTokenIdx].mType == eTokenType.TOK_OPEN_PAREN) { mTokenIdx += 1; currExpression = CreateExpression(tokens); } else if (tokens[mTokenIdx].mType == eTokenType.TOK_NOT) { mTokenIdx += 1; Expression childExpression = CreateExpression(tokens); Expression expression = new NotExpression(childExpression); mExpressions.Add(expression); currExpression = expression; } // Right Expressions if (mTokenIdx + 1 >= tokens.Count) { return currExpression; } mTokenIdx += 1; if (tokens[mTokenIdx].mType == eTokenType.TOK_AND) { mTokenIdx += 1; Expression childA = currExpression; Expression childB = CreateExpression(tokens); Expression expression = new AndExpression(childA, childB); mExpressions.Add(expression); currExpression = expression; } else if (tokens[mTokenIdx].mType == eTokenType.TOK_OR) { mTokenIdx += 1; Expression childA = currExpression; Expression childB = CreateExpression(tokens); Expression expression = new OrExpression(childA, childB); mExpressions.Add(expression); currExpression = expression; } return currExpression; }
public ExprNode ParseLogicalOrExpression() { var exp = new OrExpression { Token = Next(), LeftExpression = ParseLogicalAndExpression() }; if (Next().IsNot(TokenType.LogicalOr)) return exp.LeftExpression; Match(TokenType.LogicalOr); exp.RightExpression = ParseLogicalOrExpression(); return exp; }
// OrExpression public override bool Walk(OrExpression node) { return Location >= node.StartIndex && Location <= node.EndIndex; }
public override object Walk(OrExpression node) { var lv = node.LeftExpression.Accept(this); Func<object> rvThunk = () => node.RightExpression.Accept(this); return OpOr(lv, rvThunk); }
private string GetExpression(OrExpression expression, ref List<OleDbParameter> parameters) { return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " OR " + GetExpressionDispatch(expression.Children[1], ref parameters) + " ) "; }
internal DateTime AllowAccess(string portName, string moduleName, string username) { AssertionExpression resourceAccessAssertion = new AssertionExpression( new AtomicAssertion( localAuthority, new AtomicClaim( new ResourceAccessFact( new StringPrincipal("port:" + portName), new StringPrincipal("mod:" + moduleName), new PrincipalVariable("$grp"), new IntegerVariable("$from"), new IntegerVariable("$to"), new IntegerVariable("$day"), new VerbVariable("$amode"), new IntegerVariable("prio"))))); AssertionExpression groupMembershipAssertion = new AssertionExpression( new AtomicAssertion( localAuthority, new AtomicClaim( new UserGroupMembershipFact( new StringPrincipal("usr:"******"$grp"))))); DateTime currTime = DateTime.Now; int currMinute = currTime.Hour * 100 | currTime.Minute; Expression minutesMoreThanFrom = new ConstraintExpression(new LessThanOrEqualConstraint(new IntegerVariable("$from"), new IntegerHolder(currMinute))); Expression minutesLessThanTo = new ConstraintExpression(new LessThanOrEqualConstraint(new IntegerHolder(currMinute), new IntegerVariable("$to"))); Expression minutesInRange = new AndExpression(minutesMoreThanFrom, minutesLessThanTo); int currDayOfWeek = (int) currTime.DayOfWeek; Expression noDayOfWeekRestriction = new NotExpression(new ConstraintExpression(new InequalityConstraint(new IntegerVariable("$day"), new IntegerHolder(-1)))); Expression dayOfWeekMatches = new NotExpression(new ConstraintExpression(new InequalityConstraint(new IntegerVariable("$day"), new IntegerHolder(currDayOfWeek)))); Expression dayOfWeekAllowed = new OrExpression(noDayOfWeekRestriction, dayOfWeekMatches); Query query = new Query( new AndExpression( resourceAccessAssertion, groupMembershipAssertion, minutesInRange, dayOfWeekAllowed)); QueryContext context = new QueryContext(localAuthority, policyAssertions, query, DateTime.UtcNow, new PrincipalIdentifier[] { }, new Uri[] { }, 0, false); ReadOnlyCollection<Answer> answers = new Microsoft.Secpal.Authorization.QueryEngine().ExecuteQuery(context); //logger.Log("\nquery: " + query + "\n"); //logger.Log("answers: {0}", answers.Count.ToString()); //foreach (Answer answer in answers) // logger.Log(answer.Substitution.ToString()); return (answers.Count > 0) ? DateTime.MaxValue : DateTime.MinValue; }
public virtual bool Enter(OrExpression node) { return true; }
public void Disjunction_of_multiple_equality_comparisons_is_parsed_into_OrExpression_with_corresponding_property_names_and_values() { var pageCount = 123; var expression = _parser.Parse<Book>( x => x.AuthorName == "An author name" || x.Title == GetTitle() || x.PageCount == pageCount || x.Isbn == "123-456-789"); var expectedExpression = new OrExpression( new EqualsExpression(new PropertyExpression("AuthorName", typeof(string)), new ValueExpression("An author name")), new EqualsExpression(new PropertyExpression("Title", typeof(string)), new ValueExpression("a title")), new EqualsExpression(new PropertyExpression("PageCount", typeof(int)), new ValueExpression(123)), new EqualsExpression(new PropertyExpression("Isbn", typeof(string)), new ValueExpression("123-456-789"))); Assert.AreEqual(expectedExpression, expression); }
public override bool Enter(OrExpression node) { Print("OrExpression"); level++; return true; }
IExpression OrExpression(IBlockNode Scope = null) { var left = XorExpression(Scope); if (laKind != BitwiseOr) return left; Step(); var ae = new OrExpression(); ae.LeftOperand = left; ae.RightOperand = OrExpression(Scope); return ae; }
// OrExpression public override bool Walk(OrExpression node) { return false; }
IExpression ParseAsmOrExpression(IBlockNode Scope, IStatement Parent) { var left = ParseAsmXorExpression(Scope, Parent); while (laKind == BitwiseOr) { Step(); var e = new OrExpression(); e.LeftOperand = left; e.RightOperand = ParseAsmXorExpression(Scope, Parent); left = e; } return left; }
// OrExpression public virtual bool Walk(OrExpression node) { return true; }
public ISymbolValue Visit(OrExpression x) { return E_MathOp(x); }
private static AstExpression ParseExpression(Dictionary<string, Pivots.Pivot> pivotVsPivotValues, GetChoiceDelegate get_choice_fn, string expression) { AstExpression result = null; var rxResult = Pivots.ExpressionRx.Match(expression); if (rxResult.Success) { var state = ExpressionState.None; AstExpression current = null; bool invert = false; foreach (var item in rxResult.Groups[1].Captures.Cast<Capture>().Select(each => each.Value.Trim()).Where(each => !string.IsNullOrEmpty(each))) { switch (item[0]) { case '!': if (result != null && state == ExpressionState.None) { throw new ClrPlusException("Invalid expression. (not expression must be separated from previous expression with an operator)"); } if (item.Length % 2 != 0) invert = !invert; continue; case '&': case ',': case '\\': case '/': if (state != ExpressionState.None) { throw new ClrPlusException("Invalid expression. (May not state two operators in a row)"); } if (result == null) { throw new ClrPlusException("Invalid expression. (may not start with an operator)"); } state = ExpressionState.HasAnd; continue; case '|': case '+': if (state != ExpressionState.None) { throw new ClrPlusException("Invalid expression. (May not state two operators in a row)"); } if (result == null) { throw new ClrPlusException("Invalid expression. (may not start with an operator)"); } state = ExpressionState.HasOr; continue; case '(': if (result != null && state == ExpressionState.None) { throw new ClrPlusException("Invalid expression. (nested expression must be separated from previous expression with an operator)"); } if (item.EndsWith(")")) { // parse nested expression. current = ParseExpression(pivotVsPivotValues, get_choice_fn, item.Substring(1, item.Length - 2)); break; } throw new ClrPlusException("Mismatched '(' in expression"); default: if (!Pivots.WordRx.IsMatch(item)) { throw new ClrPlusException("Invalid characters in expression"); } if (result != null && state == ExpressionState.None) { throw new ClrPlusException("Invalid expression. (expression must be separated from previous expression with an operator)"); } // otherwise, it's the word we're looking for. // string choice; string pivot; if (get_choice_fn(item, out choice, out pivot)) { current = new PivotExpression(pivot, choice, false); break; } else if (item.ToLowerInvariant() == "true") { current = TrueExpression.instance; break; } else if (item.ToLowerInvariant() == "false") { current = FalseExpression.instance; break; } throw new ClrPlusException(string.Format("Unmatched configuration choice '{0}", item)); } if (invert) current = current.Invert(); switch (state) { case ExpressionState.None: result = current; continue; case ExpressionState.HasAnd: result = new AndExpression(result, current); break; case ExpressionState.HasOr: result = new OrExpression(result, current); break; } current = null; state = ExpressionState.None; } } if (result == null) result = TrueExpression.instance; return result; }
public void Visit(OrExpression x) { }