/// <summary> /// Visits the condition expression tree /// </summary> /// <param name="exp"></param> public object VisitCondition(ConditionExpr exp) { _callBackOnNodeStart(exp); _callBackOnNodeStart(exp.Left); _callBackOnNodeStart(exp.Right); return(null); }
public static IQueryCondition Expression(ConditionExpr expr) { var queryCondition = (AbstractExpressionCondition)_factory.CreateCondition(QueryConditionExpressionType.Expression); queryCondition.Expr = expr; return(queryCondition); }
/// <summary> /// Evaluate > >= != == less less than /// </summary> /// <returns></returns> public object VisitCondition(ConditionExpr expr) { // Validate var op = expr.Op; if (op != Operator.And && op != Operator.Or) { throw new ArgumentException("Only && || supported"); } var result = false; var lhsVal = expr.Left.Evaluate(this); var rhsVal = expr.Right.Evaluate(this); var left = false; var right = false; if (lhsVal != null) { left = ((LBool)lhsVal).Value; } if (rhsVal != null) { right = ((LBool)rhsVal).Value; } if (op == Operator.Or) { result = left || right; } else if (op == Operator.And) { result = left && right; } return(new LBool(result)); }
/// <summary> /// Creates a unary expression with symbol scope, context, script refernce set. /// </summary> /// <param name="name"></param> /// <param name="token"></param> /// <returns></returns> public static Expr Condition(Expr left, Operator op, Expr right, TokenData token) { var exp = new ConditionExpr(left, op, right); SetupContext(exp, token); return(exp); }
public void AppendTo(StringBuilder sb) { sb.Append("for: "); foreach (var initExpr in InitExprs) { sb.Append("init="); initExpr.AppendTo(sb); } if (ConditionExpr != null) { sb.Append(" cond="); ConditionExpr.AppendTo(sb); } if (IncrementExpr != null) { sb.Append(" inc="); IncrementExpr.AppendTo(sb); } sb.AppendLine("{"); Expr.AppendTo(sb); sb.AppendLine("}"); }
private ConditionExpr ProcessConditionExpr(ActorBrain actorBrain, XmlNode node) { ConditionExpr condition = new ConditionExpr(actorBrain); // Log("ProcessConditionExpr.nodeName=" + node.Name + " / nodeVal="+ node.Value + " / nodeInnerText="+ node.InnerText + " / nodeInnerXml=" + node.InnerXml + " / nodeOuterXml=" + node.OuterXml); condition.SetPattern(node.InnerText); return(condition); }
public override void WriteToStream(IndentStream stream) { stream.Write("WHEN "); ConditionExpr.WriteToStream(stream); stream.WriteLine(); stream.Write("THEN "); ThenExpr.WriteToStream(stream); }
private Product LoadProductWithId(ITransaction transaction, int id) { var query = new SelectionQuery() .From(QueryFrom.EntityType(typeof(Product))) .Where(QueryCondition.Expression(ConditionExpr.Build().Field(typeof(Product), "ProductId").Eq().Value(id))) .Select(QuerySelection.EntityType(typeof(Product))).ToList(transaction); return(query.First() as Product); }
/// <summary> /// Creates a unary expression with symbol scope, context, script refernce set. /// </summary> /// <param name="name"></param> /// <param name="token"></param> /// <returns></returns> public static Expr Condition(Expr left, Operator op, Expr right, TokenData token) { var exp = new ConditionExpr(); exp.Left = left; exp.Op = op; exp.Right = right; SetupContext(exp, token); return(exp); }
protected override IType ValidateExpr(Environment env) { ConditionExpr.Validate(env); ConditionExpr.AssertType(new BooleanType()); TrueExpr.Validate(env); FalseExpr.Validate(env); FalseExpr.AssertType(TrueExpr.Type); return(TrueExpr.Type); }
public TMonad Evaluate(IContext <TMonad> context) { var c = ConditionExpr.Evaluate(context); return(Monad.Bind(c, BindC)); TMonad BindC(object res) { return(res is bool b ? (b ? TrueExpr.Evaluate(context) : FalseExpr.Evaluate(context)) : Monad.Unit); } }
public override void WriteToStream(IndentStream stream) { stream.Write("ELSE "); if (ConditionExpr != null) { stream.Write("IF "); ConditionExpr.WriteToStream(stream); stream.WriteLine(); } Body.WriteToStream(stream); }
/// <summary> /// The shunting yard algorithm that processes a postfix list of expressions/operators. /// </summary> /// <param name="context"></param> /// <param name="parser"></param> /// <param name="stack"></param> /// <returns></returns> public static Expr ProcessShuntingYardList(Context context, Parser parser, List <object> stack) { int index = 0; Expr finalExp = null; // Shunting yard algorithm handles POSTFIX operations. while (index < stack.Count && stack.Count > 0) { // Keep moving forward to the first operator * - + / && that is found // This is a postfix algorithm so it works by creating an expression // from the last 2 items behind an operator. if (!(stack[index] is TokenData)) { index++; continue; } // At this point... we hit an operator // So get the last 2 items on the stack ( they have to be expressions ) // left is 2 behind current position // right is 1 behind current position var left = stack[index - 2] as Expr; var right = stack[index - 1] as Expr; TokenData tdata = stack[index] as TokenData; Token top = tdata.Token; Operator op = Operators.ToOp(top.Text); Expr exp = null; if (Operators.IsMath(op)) { exp = new BinaryExpr(left, op, right); } else if (Operators.IsConditional(op)) { exp = new ConditionExpr(left, op, right); } else if (Operators.IsCompare(op)) { exp = new CompareExpr(left, op, right); } exp.Ctx = context; parser.SetScriptPosition(exp, tdata); stack.RemoveRange(index - 2, 2); index = index - 2; stack[index] = exp; index++; } finalExp = stack[0] as Expr; return(finalExp); }
/// <summary> /// Visits the condition expression tree /// </summary> /// <param name="exp"></param> public void Condition(ConditionExpr exp) { _callBack(exp); _callBack(exp.Left); _callBack(exp.Right); }
private IList <IEntity> QueryTest(IList <IEntity> items) { var newList = new List <IEntity>(); var sw = new Stopwatch(); sw.Start(); var tx = transactionFactory.CreateTransaction(); for (int i = 0; i < items.Count; i++) { var item = items[i]; var itemType = item.GetType(); if (itemType == typeof(Transaction)) { var trns = (Transaction)item; var loaded = new SelectionQuery() .From(QueryFrom.EntityType(item.GetType())) .Select(QuerySelection.EntityType(item.GetType())) .Where(QueryCondition.Expression(ConditionExpr.Build().Field(itemType, "TransactionId").Eq().Value(trns.TransactionId))) .ToList(tx).FirstOrDefault(); newList.Add((IEntity)loaded); } else if (itemType == typeof(Service)) { var svc = (Service)item; var loaded = new SelectionQuery() .From(QueryFrom.EntityType(item.GetType())) .Select(QuerySelection.EntityType(item.GetType())) .Where(QueryCondition.Expression(ConditionExpr.Build().Field(itemType, "ItemId").Eq().Value(svc.ItemId))) .ToList(tx).FirstOrDefault(); newList.Add((IEntity)loaded); } else if (itemType == typeof(Product)) { var product = (Product)item; var loaded = new SelectionQuery() .From(QueryFrom.EntityType(item.GetType())) .Select(QuerySelection.EntityType(item.GetType())) .Where(QueryCondition.Expression(ConditionExpr.Build().Field(itemType, "ItemId").Eq().Value(product.ItemId))) .ToList(tx).FirstOrDefault(); newList.Add((IEntity)loaded); } if (i % 100 == 0) { tx.Close(); tx = transactionFactory.CreateTransaction(); } } tx.Commit(); tx.Close(); sw.Stop(); var speed = items.Count * 1000 / sw.ElapsedMilliseconds; LoggerManager.GetLogger(Assembly.GetExecutingAssembly(), typeof(NDbGatePerformanceCounter)) .Log(typeof(NDbGatePerformanceCounter), Level.Warn, $"NDBGate Thread Query speed {speed} entities/second", null); return(newList); }
public double Evaluate(Dictionary <string, object> variables) { return(ConditionExpr.Evaluate(variables) ? LeftExpr.Evaluate(variables) : RightExpr.Evaluate(variables)); }