// NotExpression := 'not' SS PrimaryExpression private State DoParseNotExpression1Rule(State _state, List <Result> _outResults) { State _start = _state; List <Result> results = new List <Result>(); _state = DoSequence(_state, results, delegate(State s, List <Result> r) { return(DoParseLiteral(s, r, "not")); }, delegate(State s, List <Result> r) { return(DoParse(s, r, "SS")); }, delegate(State s, List <Result> r) { return(DoParse(s, r, "PrimaryExpression")); }); if (_state.Parsed) { Predicate value = results.Count > 0 ? results[0].Value : default(Predicate); value = new NotPredicate(results[1].Value); _outResults.Add(new Result(this, _start.Index, _state.Index - _start.Index, m_input, value)); } else { string expected; expected = "not expression"; if (expected != null) { _state = new State(_start.Index, false, ErrorSet.Combine(_start.Errors, new ErrorSet(_state.Errors.Index, expected))); } } return(_state); }
public string ConvertToString(TextPredicate predicate) { ContainsPhrase_Predicate contains = predicate as ContainsPhrase_Predicate; if (contains != null) { return(this.ConvertToString(contains)); } AndPredicate and = predicate as AndPredicate; if (and != null) { return(this.ConvertToString(and)); } OrPredicate or = predicate as OrPredicate; if (or != null) { return(this.ConvertToString(or)); } NotPredicate not = predicate as NotPredicate; if (not != null) { return(this.ConvertToString(not)); } throw new Exception("Unrecognized predicate: " + predicate); }
private void NotButton_Clicked(object sender, EventArgs e) { NotPredicate not = new NotPredicate(); this.openPredicates.Add(not); this.updateLayout(); }
public override void VisitLeave(NotPredicate expression) { IsMatchPredicate local = _matchStack.Pop(); _matchStack.Push( delegate(IInputIterator iterator) { _disableCapturingGroup.Push(true); _xmlDisableBackReferencePop.Push(true); Boolean result = true; Int32 savePosition = iterator.Index; if (!local(iterator)) { iterator.Index = savePosition; result &= true; } else { iterator.Index = savePosition; result &= false; } _xmlDisableBackReferencePop.Pop(); _disableCapturingGroup.Pop(); return(result); } ); }
public override void ExitNotPredicate(MiniSqlParserParser.NotPredicateContext context) { var operand = (Predicate)_stack.Pop(); var comments = this.GetComments(context.K_NOT()); var node = new NotPredicate(operand, comments); _stack.Push(node); }
public void NotPredicate_Constructor_SetsChildPredicate() { var expectedChildPredicate = new EqualsPredicate <TestPredicateFields>(new TestPredicateFields()); var predicate = new NotPredicate(expectedChildPredicate); Assert.AreEqual(expectedChildPredicate, predicate.ChildPredicate); }
public string ConvertToString(NotPredicate predicate) { StringBuilder content = new StringBuilder(); if (predicate.Child != null) { content.Append(this.ConvertToString(predicate.Child)); } return(this.ConvertToString(content.ToString(), this.Not_Tag)); }
public void TestGrammar1NotLetterA() { TestGrammar1 grammar = TestGrammar1.Create(); Nonterminal nonterminal = grammar.GetNonterminal(o => o.NotLetterA()); Assert.AreEqual("NotLetterA", nonterminal.Name); NotPredicate expression = (NotPredicate)nonterminal.Expression; Assert.AreEqual("LetterA", ((Nonterminal)expression.Operand).Name); }
public NotPredicate Read_NotPredicate(XmlNode nodeRepresentation) { NotPredicate predicate = new NotPredicate(); foreach (XmlNode childNode in nodeRepresentation.ChildNodes) { TextPredicate child = this.ReadTextPredicate(childNode); predicate.Child = child;; } return(predicate); }
public void NotPredicateTest3() { var expr = NotPredicate.Create(baseExpr, (index) => index + 1); var parser = Parser.Create(expr); { Assert.IsFalse(parser.Parse("123", out _, out _, out _)); } { Assert.IsTrue(parser.Parse("abc", out var ret, out _, out var end)); Assert.AreEqual(ret, 1); Assert.AreEqual(end, 0); } }
public void NotPredicateTest4() { var expr = NotPredicate.Create(baseExpr, (index) => index + 1, TestCustomException); var parser = Parser.Create(expr); { Assert.IsFalse(parser.Parse("123", out _, out var exceptions, out _)); Assert.AreEqual(exceptions[0].Exception.Message, "error: 0"); } { Assert.IsTrue(parser.Parse("abc", out var ret, out _, out var end)); Assert.AreEqual(ret, 1); Assert.AreEqual(end, 0); } }
// add the given predicate as a child of the leafmost existing predicate private void addChild(TextPredicate predicate) { if (this.openPredicates.Count < 1) { // no predicates already exist, this one becomes the primary one this.openPredicates.Add(predicate); return; } TextPredicate last = this.openPredicates.Last(); OrPredicate or = last as OrPredicate; if (or != null) { // we have a pending 'or'; add it here or.AddChild(predicate); return; } AndPredicate and = last as AndPredicate; if (and != null) { // we have a pending 'and'; add it here and.AddChild(predicate); return; } NotPredicate not = last as NotPredicate; if (not != null) { // we have a pending 'not'; add it here not.Child = predicate; return; } if (last == null) { // We have an empty spot to add this predicate to // This user is expected to attach this to a parent later // If the user doesn't attach this to a parent later, we will for them this.openPredicates.RemoveAt(this.openPredicates.Count - 1); this.openPredicates.Add(predicate); return; } // error; do nothing }
/// <summary> /// Parser for Predicate /// </summary> /// <returns>Parsed Predicate</returns> public Predicate ParsePredicate() { Predicate predicate = null; //Empty predicate if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "!") { //Not Predicate NotPredicate notPredicate = new NotPredicate(); //Skip ! token NextToken("!", "! predicate", '!'); //Parse predicate after ! notPredicate.SetPredicate(ParsePredicate()); predicate = notPredicate; } else { //Other predicates exists out of an expression Expression expression = expressionParser.ParseExpression(); if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ".") { //IsPredicate predicate = ParseIsPredicate(expression); } else { //ExpressionPredicate predicate = ParseExpressionPredicate(expression); } } //Check for && or || predicates if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "&" && TokenStream.Peek(2).GetValue().ToString() == "&") { //AndPredicate return(ParseAndPredicate(predicate)); } else if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "|" && TokenStream.Peek(2).GetValue().ToString() == "|") { //OrPredicate return(ParseOrPredicate(predicate)); } return(predicate); }
public override void VisitLeave(NotPredicate expression) { terminal.Peek().Append(")"); }
public virtual void Visit(NotPredicate expression, T context) { expression.Operand.Accept(this, context); }
/// <summary> /// Method which evaluates an predicate and returns true or false /// </summary> /// <param name="predicate">Predicate to evaluate</param> /// <returns>True if predicate is true, otherwise false</returns> private bool EvaluatePredicate(Predicate predicate) { if (predicate is IsPredicate) { //Evaluate Expression Predicate IsPredicate isPredicate = (IsPredicate)predicate; Expression expression = isPredicate.GetExpression(); //In case of VarExpression, get expression from symboltable if (expression is VarExpression) { expression = GetReferenceExpression((VarExpression)expression); if (expression == null) { return(false); } } //If right type return true, otherwise false if (isPredicate.GetType() is StringType) { return(expression is TextExpression); } else if (isPredicate.GetType() is ListType) { return(expression is ListExpression); } else if (isPredicate.GetType() is RecordType) { return(expression is RecordExpression); } else { //No match between types which could be checked, so false return(false); } } else if (predicate is ExpressionPredicate) { //Evaluate Expression Predicate ExpressionPredicate expressionPredicate = (ExpressionPredicate)predicate; Expression expression = expressionPredicate.GetExpression(); if (expression is FieldExpression) { //Check if specific field exists in record (not null) Expression expr = GetExpression((FieldExpression)expression); return(expr != null); } else if (expression is VarExpression) { //Check if specific variable is defined VarExpression varExpr = (VarExpression)expression; return(SymbolTable.ContainsVariable(varExpr.GetVariableIdentifier())); } else { //Other expressions are always true, because they doesn't refer to something return(true); } } else if (predicate is AndPredicate) { //Evaluate And Predicate AndPredicate andPredicate = (AndPredicate)predicate; return(EvaluatePredicate(andPredicate.GetLeftPredicate()) && EvaluatePredicate(andPredicate.GetLeftPredicate())); } else if (predicate is OrPredicate) { //Evaluate Or Predicate OrPredicate orPredicate = (OrPredicate)predicate; return(EvaluatePredicate(orPredicate.GetLeftPredicate()) || EvaluatePredicate(orPredicate.GetRightPredicate())); } else if (predicate is NotPredicate) { //Evaluate Not Predicate NotPredicate notPredicate = (NotPredicate)predicate; return(!EvaluatePredicate(notPredicate.GetPredicate())); } return(false); }
public abstract void VisitLeave(NotPredicate expression);
/** * Create a new Predicate that returns true if the specified predicate * returns false and vice versa. * * @see org.apache.commons.collections.functors.NotPredicate * * @param predicate the predicate to not * @return the <code>not</code> predicate * @throws IllegalArgumentException if the predicate is null */ public static Predicate notPredicate(Predicate predicate) { return(NotPredicate.getInstance(predicate)); }
public abstract void VisitEnter(NotPredicate expression);
public abstract void VisitExecute(NotPredicate expression);
public override void VisitEnter(NotPredicate expression) { }
public IPredicate <T> Build() { var predicate = new NotPredicate <T>(_innerPredicate.Build()); return(predicate); }
public void Visit(NotPredicate expression, Nonterminal context) { expression.Operand.Accept(this, context); }
public override void Visit(NotPredicate expression, object context) { expressions.Add(expression); base.Visit(expression, context); }
public override void VisitEnter(NotPredicate expression) { terminal.Peek().Append("!("); }
public override void VisitExecute(NotPredicate expression) { }
void IVisitor.VisitAfter(NotPredicate notPredicate) { this.ParentExists(notPredicate); }
void IVisitor.VisitBefore(NotPredicate notPredicate) { this.ParentExists(notPredicate); }
public virtual void Visit(NotPredicate predicate) { VisitSubNodes(predicate); }