/// <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));
}
