private void Calculate(IDictionary <MeasurementKey, IMeasurement> measurements)
{
m_expressionContext.Variables.Clear();
// Set the values of variables in the expression
foreach (MeasurementKey key in m_keyMapping.Keys)
{
string name = m_keyMapping[key];
if (measurements.TryGetValue(key, out IMeasurement measurement))
{
m_expressionContext.Variables[name] = measurement.AdjustedValue;
}
else
{
m_expressionContext.Variables[name] = m_sentinelValue;
}
}
// Handle special constants
m_expressionContext.Variables["TIME"] = RealTime.Value;
// Compile the expression if it has not been compiled already
if ((object)m_expression == null)
{
m_expression = m_expressionContext.CompileDynamic(m_aliasedExpressionText);
}
// Evaluate the expression and generate the measurement
HandleCalculatedValue(m_expression.Evaluate());
}
public object Execute(Context c)
{
m_scriptContext.ExecutionContext = c;
if (m_compiledExpression == null || m_scriptContext.HaveVariableTypesChanged(m_compiledExpression.Info.GetReferencedVariables(), m_types))
{
// Lazy compilation since when the game is loaded, we don't know what types of
// variables we have.
try
{
m_compiledExpression = m_scriptContext.ExpressionContext.CompileDynamic(m_expression);
m_scriptContext.PopulateVariableTypesCache(m_compiledExpression.Info.GetReferencedVariables(), m_types);
}
catch (Exception ex)
{
throw new Exception(string.Format("Error compiling expression '{0}': {1}", Utility.ConvertFleeFormatToVariables(m_expression), ex.Message), ex);
}
}
try
{
return(m_compiledExpression.Evaluate());
}
catch (Exception ex)
{
throw new Exception(string.Format("Error evaluating expression '{0}': {1}", Utility.ConvertFleeFormatToVariables(m_expression), ex.Message), ex);
}
}
/// <summary>
/// Gets the risk score for the given risk score type and expression parameters.
/// </summary>
///
/// <param name="type">The risk score type.</param>
/// <param name="parameters">The expression parameters.</param>
/// <returns>The calculated risk score.</returns>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="type"/> or <paramref name="parameters"/> is <c>null</c>.
/// </exception>
/// <exception cref="ArgumentException">
/// If <paramref name="type"/> or <paramref name="parameters"/> is empty.
/// </exception>
/// <exception cref="ServiceException">
/// If any other errors occur while performing this operation.
/// </exception>
public double GetRiskScore(string type, IDictionary <string, object> parameters)
{
return(Logger.Process(() =>
{
CommonHelper.ValidateArgumentNotNullOrEmpty(type, nameof(type));
CommonHelper.ValidateArgumentNotNullOrEmpty(parameters, nameof(parameters));
string expression;
if (!Expressions.TryGetValue(type, out expression))
{
throw new ServiceException(
$"The risk score type '{type}' is not configured in Expressions configuration property.");
}
var context = new ExpressionContext();
context.Imports.AddType(typeof(Math));
foreach (KeyValuePair <string, object> pair in parameters)
{
context.Variables[pair.Key] = pair.Value;
}
IDynamicExpression dynamicExpression = context.CompileDynamic(expression);
return Convert.ToDouble(dynamicExpression.Evaluate());
},
"retrieving risk score",
parameters: new object[] { type, parameters }));
}
public void TestMethod1()
{
ExpressionContext context = new ExpressionContext();
// Use string.format
context.Imports.AddType(typeof(string));
context.Imports.AddType(typeof(ProcessInstance));
context.Imports.AddType(typeof(Dictionary <string, object>));
context.Variables.Add("nextCode", "COMPLETE");
ProcessInstance pi = new ProcessInstance()
{
ProcessInstanceName = "Aiska", SuspensionState = ESuspensionState.ACTIVE
};
Dictionary <string, int> g = new Dictionary <string, int>();
g.Add("gaji", 10000000);
context.Variables.Add("gaji", 10000000);
context.Variables.Add("processInstance", pi);
context.Variables.Add("g", g);
context.Variables.Add("index", 0);
IDynamicExpression exp = context.CompileDynamic("nextCode.Equals(\"COMPLETE\")");
var result = exp.Evaluate();
exp = context.CompileDynamic("gaji > 1000000");
result = exp.Evaluate();
exp = context.CompileDynamic("processInstance.ProcessInstanceName.Equals(\"Aiska\") AND processInstance.ProcessInstanceName.Equals(1)");
result = exp.Evaluate();
exp = context.CompileDynamic("g[\"gaji\"] > 1000000");
result = exp.Evaluate();
}
/// <summary>
/// Publish <see cref="IFrame"/> of time-aligned collection of <see cref="IMeasurement"/> values that arrived within the
/// concentrator's defined <see cref="ConcentratorBase.LagTime"/>.
/// </summary>
/// <param name="frame"><see cref="IFrame"/> of measurements with the same timestamp that arrived within <see cref="ConcentratorBase.LagTime"/> that are ready for processing.</param>
/// <param name="index">Index of <see cref="IFrame"/> within a second ranging from zero to <c><see cref="ConcentratorBase.FramesPerSecond"/> - 1</c>.</param>
protected override void PublishFrame(IFrame frame, int index)
{
ConcurrentDictionary <MeasurementKey, IMeasurement> measurements;
IMeasurement measurement;
string name;
measurements = frame.Measurements;
m_expressionContext.Variables.Clear();
// Set the values of variables in the expression
foreach (MeasurementKey key in m_keyMapping.Keys)
{
name = m_keyMapping[key];
if (measurements.TryGetValue(key, out measurement))
{
m_expressionContext.Variables[name] = measurement.AdjustedValue;
}
else
{
m_expressionContext.Variables[name] = double.NaN;
}
}
// Compile the expression if it has not been compiled already
if ((object)m_expression == null)
{
m_expression = m_expressionContext.CompileDynamic(m_aliasedExpressionText);
}
// Evaluate the expression and generate the measurement
GenerateCalculatedMeasurement(m_expression.Evaluate() as IConvertible);
}
internal void UpdateVars(IDynamicExpression exp)
{
foreach (var item in Variables)
{
exp.Context.Variables[item.Key] = item.Value;
}
}
public void ExpressionEvaluationTest()
{
ExpressionContext context = new ExpressionContext();
context.Variables.Add("rand", new Random());
IDynamicExpression e = context.CompileDynamic("rand.nextDouble() + 100");
double result = (double)e.Evaluate();
//no LINQ
//var doc = new XDocument(new XElement("test",
// new XElement("val", "result1"),
// new XElement("val", "result2"),
// new XElement("val", "result3")
// ));
//context.Variables.Add("doc", doc);
//e = context.CompileDynamic("doc.Elements().First().Value");
//var r = e.Evaluate();
//no Dynamic
//dynamic expando = new ExpandoObject();
//expando.test = "Passed";
//context.Variables.Add("expando", expando);
//e = context.CompileDynamic("expando.test");
//var r = e.Evaluate();
}
public void Compile(ExpressionContext context)
{
// TODO: verify wheather the expression is a value (no need to compile)
bool isValue = false;
if (!isValue)
eDynamic = context.CompileDynamic(AssignmentExpression);
}
public void TestFastVariables()
{
//Test should take 200ms or less
const int expectedTime = 200;
const int iterations = 100000;
var context = new ExpressionContext();
var vars = context.Variables;
vars.DefineVariable("a", typeof(int));
vars.DefineVariable("b", typeof(int));
IDynamicExpression e = this.CreateDynamicExpression("a + b", context);
var sw = new Stopwatch();
sw.Start();
for (int i = 0; i < iterations - 1; i++)
{
vars["a"] = 200;
vars["b"] = 300;
var result = e.Evaluate();
}
sw.Stop();
this.PrintSpeedMessage("Fast variables", iterations, sw);
Assert.IsTrue(sw.ElapsedMilliseconds < expectedTime, $"Test time {sw.ElapsedMilliseconds} above expected value {expectedTime}");
}
static public string[] GetReferencedVariables(string expression, string[] variables)
{
if (String.IsNullOrWhiteSpace(expression))
{
return(null);
}
if ((variables == null) || (variables.Length < 1))
{
return(null);
}
ExpressionContext context = new ExpressionContext();
// Use string.format
context.Imports.AddType(typeof(string));
context.Imports.AddType(typeof(CustomFunctions));
for (int i = 0; i < variables.Length; i++)
{
context.Variables[variables[i]] = 1.0;
}
IDynamicExpression e = context.CompileDynamic(expression);
return(e.Info.GetReferencedVariables());
}
// Utils
public float EvaluateSlopeAtPoint(float x, float y)
{
this.context = new ExpressionContext();
if (this.equation.IndexOf("x") > -1)
{
this.context.Variables["x"] = x;
}
if (this.equation.IndexOf("y") > -1)
{
this.context.Variables["y"] = y;
}
IDynamicExpression eGeneric = context.CompileDynamic(this.equation);
float result = (float)eGeneric.Evaluate();
if (float.IsNaN(result))
{
Debug.LogWarning("Found NAN Slope");
return(0);
}
return(result);
}
protected void DoTest(IDynamicExpression e, string result, Type resultType, CultureInfo testCulture)
{
var flag = resultType == typeof(object);
if (flag)
{
var expectedType = Type.GetType(result, false, true);
var flag2 = expectedType == null;
if (flag2)
{
result = $"{this.GetType().Namespace}.{result}";
expectedType = this.GetType().Assembly.GetType(result, true, true);
}
var expressionResult = RuntimeHelpers.GetObjectValue(e.Evaluate());
var flag3 = expectedType == typeof(void);
if (flag3)
{
Assert.IsNull(RuntimeHelpers.GetObjectValue(expressionResult));
}
else
{
Assert.IsInstanceOf(expectedType, RuntimeHelpers.GetObjectValue(expressionResult));
}
}
else
{
var tc = TypeDescriptor.GetConverter(resultType);
var expectedResult = RuntimeHelpers.GetObjectValue(tc.ConvertFromString(null, testCulture, result));
var actualResult = RuntimeHelpers.GetObjectValue(e.Evaluate());
expectedResult = RuntimeHelpers.GetObjectValue(this.RoundIfReal(RuntimeHelpers.GetObjectValue(expectedResult)));
actualResult = RuntimeHelpers.GetObjectValue(this.RoundIfReal(RuntimeHelpers.GetObjectValue(actualResult)));
Assert.AreEqual(RuntimeHelpers.GetObjectValue(expectedResult), RuntimeHelpers.GetObjectValue(actualResult));
}
}
public IActionResult OnPost()
{
string formula = Request.Form["formula"];
//Test out the formula when you get it so that you know the formula is valid
//It will throw an exception if not and you can tell the user the formula is invalid
try
{
ExpressionContext context = new ExpressionContext();
context.Imports.AddType(typeof(System.Math));
context.Variables["c"] = 1m;
context.Variables["b"] = 2m;
context.Variables["a"] = 3m;
IDynamicExpression eDynamic = context.CompileDynamic(formula);
decimal result = (decimal)eDynamic.Evaluate();
}
catch (Exception ex)
{
this.alertMessage = "Please enter a valid formula";
return(Page());
}
Grade.UpdateFormula(formula);
this.alertMessage = "Formula updated";
return(Page());
}
public void RuntimeErrorCheck_DivisionByZero()
{
ExpressionContext context = new ExpressionContext();
IDynamicExpression e1 = context.CompileDynamic("1 = 1/0");
e1.Evaluate();
}
public void ArgumentInt_to_DoubleConversion()
{
ExpressionContext context = new ExpressionContext();
context.Imports.AddType(typeof(Math));
IDynamicExpression e1 = context.CompileDynamic("sqrt(16)");
Assert.AreEqual(4.0, e1.Evaluate());
}
/// <summary>
/// Transforms a dynamic <see cref="Expression"/> into an object of type <see cref="T"/>.
/// </summary>
/// <exception cref="NotSupportedException">The <paramref name="node"/> does not inherit <see cref="Expression"/> or cannot be reduced.</exception>
protected virtual T VisitDynamic(IDynamicExpression node)
{
if (node is Expression expr && expr.CanReduce)
{
return(Visit(expr.Reduce()));
}
throw new NotSupportedException();
}
public void NullIsNullCheck()
{
ExpressionContext context = new ExpressionContext();
context.Variables.Add("a", "stringObject");
IDynamicExpression e1 = context.CompileDynamic("null = null");
Assert.IsTrue((bool)e1.Evaluate());
}
public void getObject()
{
SqlConnection conn = konn.GetConn();
conn.Open();
string roboIp;
SqlCommand cmd = new SqlCommand("SELECT rumus3 from tbl_perumusan where id_kategoripupuk=9", conn);
// queryStr = "SELECT nama_pupuk from tbl_perumusan where id_kategoripupuk=9";
// cmd = new MySql.Data.MySqlClient.MySqlCommand(queryStr, conn);
var queryResult = cmd.ExecuteScalar();//Return an object so first check for null
if (queryResult != null)
{
// If we have result, then convert it from object to string.
roboIp = Convert.ToString(queryResult);
//txtOutput.Text = roboIp.ToString();
}
else
{
// Else make id = "" so you can later check it.
roboIp = "";
//txtOutput.Text = "GAGAL";
//txtOutput.Text = roboIp.Text;
}
//testtin Flee
ExpressionContext context = new ExpressionContext();
// Allow the expression to use all static public methods of System.Math
context.Imports.AddType(typeof(Math));
// Define an int variable
context.Variables["a"] = 100;
// Create a dynamic expression that evaluates to an Object
IDynamicExpression eDynamic = context.CompileDynamic("sqrt(a) + pi");
// Create a generic expression that evaluates to a double
context.Variables["a"] = 100;
context.Variables["b"] = 300;
context.Variables["c"] = 320;
IGenericExpression <double> eGeneric = context.CompileGeneric <double>(roboIp);
// Evaluate the expressions
double result = (double)eDynamic.Evaluate();
result = eGeneric.Evaluate();
// Update the value of our variable
// Evaluate again to get the updated result
result = eGeneric.Evaluate();
double hasilakhir = (double)result + 5;
txtOutput.Text = hasilakhir.ToString();
}
public void RuntimeErrorCheck_ParsingInvalidDate()
{
ExpressionContext context = new ExpressionContext();
context.Variables.Add("a", "stringObject");
context.Imports.AddType(typeof(DateTime));
IDynamicExpression e1 = context.CompileDynamic("Parse(a)");
e1.Evaluate();
}
public void CompareLongs()
{
// bug #83 test.
ExpressionContext context = new ExpressionContext();
IDynamicExpression e1 = context.CompileDynamic("2432696330L = 2432696330L AND 2432696330L > 0 AND 2432696330L < 2432696331L");
Assert.IsTrue((bool)e1.Evaluate());
e1 = context.CompileDynamic("2432696330L / 2");
Assert.AreEqual(1216348165L, e1.Evaluate());
}
public void Compile(Type modelType)
{
this.context = new ExpressionContext();
this.context.Variables.DefineVariable(this.ModelVariableName, modelType);
foreach (var variable in this.variables)
{
this.context.Variables.DefineVariable(variable.Key, variable.Value == null ? typeof(object) : variable.Value.GetType());
}
this.compiled = this.context.CompileDynamic(this.Expression);
}
public void Test_IfExpression_enUS()
{
ExpressionContext context = new ExpressionContext();
context.Options.ParseCulture = new System.Globalization.CultureInfo("en-US");
int resultWhenTrue = 3;
IDynamicExpression e = context.CompileDynamic("if(1<2, 3, 4)");
Assert.IsTrue((int)e.Evaluate() == resultWhenTrue);
}
protected double CalculateByPoint(string func)
{
try
{
dynamic = context.CompileDynamic(func);
return(Convert.ToDouble(dynamic.Evaluate()));
}
catch
{
return(0);
}
}
public override void Compile(bool recursive = false)
{
//Debug.Assert(InputFeatureType != null);
if (_text.LabelBox != null)
{
var renderer = _text.LabelBox.Renderer as IFeatureRenderer;
if (renderer != null)
{
renderer.InputFeatureType = InputFeatureType;
if (recursive)
renderer.Compile(true);
}
}
var context = Renderer.Context;
//var colorContext = context;
//var contentAlignmentContext = context;
//_resolver = new FeatureVariableResolver(InputFeatureType);
//_resolver.BindContext(context);
//_resolver.BindContext(colorContext);
//_resolver.BindContext(contentAlignmentContext);
var oldFeatureType = Renderer.FeatureVarResolver.FeatureType;
Renderer.FeatureVarResolver.FeatureType = InputFeatureType;
try
{
_contentEvaluator = CompileExpression(context, TextStyle.ContentField, _text.Content, ref _content);
_angleEvaluator = CompileDoubleExpression(context, TextStyle.AngleField, _text.Angle, ref _angle);
_sizeEvaluator = CompileDoubleExpression(context, TextStyle.SizeField, _text.Size, ref _size);
_alignEvaluator = CompileEnumExpression(context, TextStyle.AlignmentField, _text.Alignment, ref _alignment);
_fontEvaluator = CompileExpression<string>(context, TextStyle.FontField, _text.Font);
_colorEvaluator = CompileColorExpression(context, TextStyle.ColorField, _text.Color, ref _color);
_scaleXEvaluator = CompileDoubleExpression(context, TextStyle.ScaleXField, _text.ScaleX, ref _scaleX);
_scaleYvaluator = CompileDoubleExpression(context, TextStyle.ScaleYField, _text.ScaleY, ref _scaleY);
_opacityEvaluator = CompileFloatExpression(context, TextStyle.OpacityField, _text.Opacity, ref _opacity);
_overlapableEvaluator = CompileBoolExpression(context, TextStyle.OverlapableField, _text.Overlappable, ref _overlapable);
_allowOverlapEvaluator = CompileBoolExpression(context, TextStyle.AllowOverlapField, _text.AllowOverlap, ref _allowOverlap);
}
finally
{
Renderer.FeatureVarResolver.FeatureType = oldFeatureType;
}
//_labelBoxRenderer = _text.LabelBox != null && _text.LabelBox.Renderer != null && !string.IsNullOrWhiteSpace(_text.Content)
// ? _text.LabelBox.Renderer as IFeatureRenderer
// : null;
_labelBoxRenderer = _text.LabelBox != null ? new ContainerNodeRenderer(Renderer, _text.LabelBox, this) : null;
_compiled = true;
}
public void ProfileCompilationTime()
{
int expectedTime = 1000;
int iterations = 10;
var context = new ExpressionContext();
context.Variables.ResolveVariableType += Variables_ResolveVariableType;
context.Variables.ResolveVariableValue += Variables_ResolveVariableValue;
Stopwatch sw;
sw = new Stopwatch();
sw.Start();
for (int i = 0; i < iterations - 1; i++)
{
IDynamicExpression e = this.CreateDynamicExpression(BigExpression, context);
}
sw.Stop();
this.PrintSpeedMessage("Compile Big", iterations, sw);
Assert.Less(sw.ElapsedMilliseconds, expectedTime, "Test time above expected value");
iterations = 100;
expectedTime = 100;
sw = new Stopwatch();
sw.Start();
for (int i = 0; i < iterations - 1; i++)
{
IDynamicExpression e = this.CreateDynamicExpression(SmallExpression, context);
}
sw.Stop();
this.PrintSpeedMessage("Compile Small", iterations, sw);
Assert.Less(sw.ElapsedMilliseconds, expectedTime, "Test time above expected value");
iterations = 100;
expectedTime = 100;
sw = new Stopwatch();
sw.Start();
for (int i = 0; i < iterations - 1; i++)
{
IDynamicExpression e = this.CreateDynamicExpression(SmallExpression, context);
}
sw.Stop();
this.PrintSpeedMessage("Compile Small Branching", iterations, sw);
Assert.Less(sw.ElapsedMilliseconds, expectedTime, "Test time above expected value");
}
protected double CalculateByPoint(double x)
{
try
{
string tmpStr = CurrentFunction.Replace("x", x.ToString());
dynamic = context.CompileDynamic(tmpStr);
return(Convert.ToDouble(dynamic.Evaluate()));
}
catch
{
return(0);
}
}
public void Test_IfExpression_fiFI()
{
ExpressionContext context = new ExpressionContext();
context.Imports.AddType(typeof(Math));
context.Options.ParseCulture = new System.Globalization.CultureInfo("fi-FI");
int resultWhenFalse = 4;
IDynamicExpression e = context.CompileDynamic("if(1>2; 3; 4)");
Assert.IsTrue((int)e.Evaluate() == resultWhenFalse);
}
/// <summary>
/// Initialize dynamic expression
/// </summary>
/// <param name="expression"></param>
public void InitDynamicExpression(string expression)
{
if (m_contextExpression == null)
{
m_contextExpression = new ExpressionContext();
m_contextExpression.Imports.AddType(typeof(Math));
m_contextExpression.Variables["X"] = 0F;
m_contextExpression.Variables["Y"] = 0F;
m_contextExpression.Variables["Z"] = 0F;
}
// Create a dynamic expression that evaluates to an Object
m_eDynamicExpression = m_contextExpression.CompileDynamic(expression);
}
/// <summary>
/// Publish <see cref="IFrame"/> of time-aligned collection of <see cref="IMeasurement"/> values that arrived within the
/// concentrator's defined <see cref="ConcentratorBase.LagTime"/>.
/// </summary>
/// <param name="frame"><see cref="IFrame"/> of measurements with the same timestamp that arrived within <see cref="ConcentratorBase.LagTime"/> that are ready for processing.</param>
/// <param name="index">Index of <see cref="IFrame"/> within a second ranging from zero to <c><see cref="ConcentratorBase.FramesPerSecond"/> - 1</c>.</param>
protected override void PublishFrame(IFrame frame, int index)
{
ConcurrentDictionary <MeasurementKey, IMeasurement> measurements;
IMeasurement measurement;
string name;
long timestamp;
measurements = frame.Measurements;
m_expressionContext.Variables.Clear();
// Set the values of variables in the expression
foreach (MeasurementKey key in m_keyMapping.Keys)
{
name = m_keyMapping[key];
if (measurements.TryGetValue(key, out measurement))
{
m_expressionContext.Variables[name] = measurement.AdjustedValue;
}
else
{
m_expressionContext.Variables[name] = double.NaN;
}
}
// Compile the expression if it has not been compiled already
if ((object)m_expression == null)
{
m_expression = m_expressionContext.CompileDynamic(m_aliasedExpressionText);
}
// Get the timestamp of the measurement to be generated
switch (m_timestampSource)
{
default:
timestamp = frame.Timestamp;
break;
case TimestampSource.RealTime:
timestamp = RealTime;
break;
case TimestampSource.LocalClock:
timestamp = DateTime.UtcNow.Ticks;
break;
}
// Evaluate the expression and generate the measurement
GenerateCalculatedMeasurement(timestamp, m_expression.Evaluate() as IConvertible);
}
static void Main(string[] args)
{
ExpressionContext context = new ExpressionContext();
context.Imports.AddType(typeof(CustomFunctions));
IDynamicExpression e = context.CompileDynamic("sum(1,2,3,4,5,6)");
int result = (int)e.Evaluate();
Console.WriteLine("result: " + result);
Console.WriteLine("Done");
Console.ReadKey();
}
public void DerivedUnaryOperatorPlusOperator()
{
var m1 = new Derived {
Value = 2
};
ExpressionContext context = new ExpressionContext();
context.Variables.Add("m1", m1);
IDynamicExpression e1 = context.CompileDynamic("-m1 + m1");
Base negated = (Base)e1.Evaluate();
Assert.AreEqual(0, negated.Value);
}
internal void FixTemporaryHead(IDynamicExpression expression, ExpressionContext context, Type resultType)
{
var pairType = typeof(GenericExpressionResultPair <>);
pairType = pairType.MakeGenericType(resultType);
var pair = (ExpressionResultPair)Activator.CreateInstance(pairType);
var headName = context.CalcEngineExpressionName;
pair.SetName(headName);
pair.SetExpression(expression);
var oldPair = this.myNameNodeMap[headName];
this.myDependencies.ReplaceDependency(oldPair, pair);
this.myNameNodeMap[headName] = pair;
pair.Recalculate();
}
public void Compile(bool recursive = false)
{
//var context = FeatureRenderer.CreateContext();
//if (InputFeatureType != null)
//{
// _resolver = new FeatureVariableResolver(InputFeatureType);
// _resolver.BindContext(context);
//}
var _context = _renderer.Context;
_exprEval = FeatureRenderer.CompileExpression(_caseNode, _context, Case.ExpressionField, _caseNode.Expression, ref _caseValue);
_expressions = new List<IExpression>(_caseNode.Nodes.Count);
_whenValues = new ArrayList(_caseNode.Nodes.Count);
_renderers = new List<IBaseRenderer>(_caseNode.Nodes.Count);
foreach (ContainerNode child in _caseNode.Nodes)
{
var renderer = child.Renderer ?? (child.Renderer = _renderer.CreateRenderer(child, null, this));
if (renderer == null) continue;
var when = child as When;
if (when != null)
{
object whenValue = null;
var expr = when.Expression != null ?
_exprEval != null || _caseValue != null
? (IExpression)FeatureRenderer.CompileExpression(_caseNode, _context, When.ExpressionField, when.Expression, ref whenValue)
: FeatureRenderer.CompileExpression<bool>(_renderer, _caseNode, _context, When.ExpressionField, when.Expression)
: null;
_expressions.Add(expr);
_whenValues.Add(whenValue);
}
else if (!(child is Else))
continue;
_renderers.Add(renderer);
if (recursive)
renderer.Compile(true);
}
_compiled = true;
}
/// <summary>
/// Publish <see cref="IFrame"/> of time-aligned collection of <see cref="IMeasurement"/> values that arrived within the
/// concentrator's defined <see cref="ConcentratorBase.LagTime"/>.
/// </summary>
/// <param name="frame"><see cref="IFrame"/> of measurements with the same timestamp that arrived within <see cref="ConcentratorBase.LagTime"/> that are ready for processing.</param>
/// <param name="index">Index of <see cref="IFrame"/> within a second ranging from zero to <c><see cref="ConcentratorBase.FramesPerSecond"/> - 1</c>.</param>
protected override void PublishFrame(IFrame frame, int index)
{
ConcurrentDictionary<MeasurementKey, IMeasurement> measurements;
IMeasurement measurement;
string name;
long timestamp;
measurements = frame.Measurements;
m_expressionContext.Variables.Clear();
// Set the values of variables in the expression
foreach (MeasurementKey key in m_keyMapping.Keys)
{
name = m_keyMapping[key];
if (measurements.TryGetValue(key, out measurement))
m_expressionContext.Variables[name] = measurement.AdjustedValue;
else
m_expressionContext.Variables[name] = double.NaN;
}
// Compile the expression if it has not been compiled already
if ((object)m_expression == null)
m_expression = m_expressionContext.CompileDynamic(m_aliasedExpressionText);
// Get the timestamp of the measurement to be generated
switch (m_timestampSource)
{
default:
timestamp = frame.Timestamp;
break;
case TimestampSource.RealTime:
timestamp = RealTime;
break;
case TimestampSource.LocalClock:
timestamp = DateTime.UtcNow.Ticks;
break;
}
// Evaluate the expression and generate the measurement
GenerateCalculatedMeasurement(timestamp, m_expression.Evaluate() as IConvertible);
}
/// <summary>
/// Publish <see cref="IFrame"/> of time-aligned collection of <see cref="IMeasurement"/> values that arrived within the
/// concentrator's defined <see cref="ConcentratorBase.LagTime"/>.
/// </summary>
/// <param name="frame"><see cref="IFrame"/> of measurements with the same timestamp that arrived within <see cref="ConcentratorBase.LagTime"/> that are ready for processing.</param>
/// <param name="index">Index of <see cref="IFrame"/> within a second ranging from zero to <c><see cref="ConcentratorBase.FramesPerSecond"/> - 1</c>.</param>
protected override void PublishFrame(IFrame frame, int index)
{
ConcurrentDictionary<MeasurementKey, IMeasurement> measurements;
IMeasurement measurement;
string name;
measurements = frame.Measurements;
m_expressionContext.Variables.Clear();
// Set the values of variables in the expression
foreach (MeasurementKey key in m_keyMapping.Keys)
{
name = m_keyMapping[key];
if (measurements.TryGetValue(key, out measurement))
m_expressionContext.Variables[name] = measurement.AdjustedValue;
else
m_expressionContext.Variables[name] = double.NaN;
}
// Compile the expression if it has not been compiled already
if ((object)m_expression == null)
m_expression = m_expressionContext.CompileDynamic(m_aliasedExpressionText);
// Evaluate the expression and generate the measurement
GenerateCalculatedMeasurement(m_expression.Evaluate() as IConvertible);
}
public void Compile(ExpressionContext context)
{
if (_expression != string.Empty && _expression != "true" && _expression != "false")
eDynamic = context.CompileDynamic(_expression);
}
