private async Task OnEvaluateParameterAsync(string name, ParameterArgs args)
{
if (EvaluateParameterAsync != null)
{
await EvaluateParameterAsync(name, args);
}
}
private void OnEvaluateParameter(string name, ParameterArgs args)
{
if (EvaluateParameter != null)
{
EvaluateParameter(name, args);
}
}
private static void Expr_EvaluateParameter(string name, ParameterArgs args)
{
args.Result = name.Equals("pi", StringComparison.OrdinalIgnoreCase)
? Math.PI
: name.Equals("e", StringComparison.OrdinalIgnoreCase)
? Math.E
: args.Result;
}
public override void Visit(Identifier parameter)
{
object parameterValue;
if (Parameters.ContainsKey(parameter.Name))
{
// The parameter is defined in the hashtable
if (Parameters[parameter.Name] is Expression)
{
// The parameter is itself another Expression
var expression = (Expression)Parameters[parameter.Name];
// Overloads parameters
foreach (var p in Parameters)
{
expression.Parameters[p.Key] = p.Value;
}
expression.EvaluateFunction += EvaluateFunction;
expression.EvaluateParameter += EvaluateParameter;
parameterValue = ((Expression)Parameters[parameter.Name]).EvaluateRaw();
}
else
{
parameterValue = Parameters[parameter.Name];
}
}
else
{
// The parameter should be defined in a call back method
var args = new ParameterArgs();
// Calls external implementation
OnEvaluateParameter(parameter.Name, args);
if (!args.HasResult)
{
throw new ArgumentException("Parameter was not defined", parameter.Name);
}
parameterValue = args.Result;
}
if (parameterValue is RawIdentifierExpression)
{
(parameterValue as RawIdentifierExpression).Accept(this);
}
else if (parameterValue is RawExpression)
{
(parameterValue as RawExpression).Accept(this);
}
else
{
//Result.Append("[").Append(parameterValue.ToString()).Append("]");
Result.Append(parameterValue.ToString());
}
}
public override void Visit(IdentifierExpression parameter)
{
try
{
if (Parameters.ContainsKey(parameter.Name))
{
// The parameter is defined in the hashtable
if (Parameters[parameter.Name] is Expression)
{
// The parameter is itself another Expression
var expression = (Expression)Parameters[parameter.Name];
// Overloads parameters
foreach (var p in Parameters)
{
expression.Parameters[p.Key] = p.Value;
}
expression.EvaluateFunction += EvaluateFunction;
expression.EvaluateParameter += EvaluateParameter;
Result = ((Expression)Parameters[parameter.Name]).Evaluate();
}
else
{
Result = Parameters[parameter.Name];
}
}
else
{
// The parameter should be defined in a call back method
var args = new ParameterArgs();
// Calls external implementation
OnEvaluateParameter(parameter.Name, args);
//if (!args.HasResult)
// throw new ArgumentException("Parameter was not defined", parameter.Name);
if (args.HasResult)
{
Result = args.Result;
}
else
{
Result = parameter.Name;
}
}
}
catch (Exception ex)
{
Result = "Error: " + ex.Message;
}
finally
{
//saving result
parameter.objResult = Result;
}
}
//public MTSRuleResults EvalAsString(Dictionary<string, object> parameters)
//{
// Dictionary<string, object> validparams = ValidateParams(parameters);
// Dictionary<string, string> customfunction = new Dictionary<string, string>();
// ruleResult.Clear();
// string matchPattern = @"\[(.*?)\]";
// MatchCollection mc;
// foreach (var rule in this)
// {
// string reslt = rule.Value;
// //Remove Custom functions*******************
// foreach (var item in customFunctions)
// {
// mc = Regex.Matches(reslt, item, RegexOptions.IgnoreCase);
// foreach (Match m in mc)
// {
// string guid = Guid.NewGuid().ToString();
// customfunction.Add(guid, m.Groups[0].ToString());
// reslt = reslt.Replace(m.Groups[0].ToString(), guid);
// }
// }
// //Replace parametesrr
// mc = Regex.Matches(reslt, matchPattern);
// foreach (Match m in mc)
// {
// if (validparams[m.Groups[1].ToString()].ToString().Trim() != string.Empty)
// {
// reslt = reslt.Replace(string.Concat("[", m.Groups[1].ToString(), "]"), validparams[m.Groups[1].ToString()].ToString());
// }
// }
// //Add Custom functions back ;-)****************************
// foreach (var item in customfunction)
// {
// reslt = reslt.Replace(item.Key, item.Value);
// }
// Expression e = getExpression(reslt);
// e.Parameters = validparams;
// try
// {
// ruleResult.Add(rule.Key, new MTSRuleResult { Result = e.Evaluate(), Expressions = getPassedExpression(e) });
// }
// catch (Exception ex)
// {
// ruleResult.Add(rule.Key, new MTSRuleResult { Result = "Error", Expressions = string.Format("Error Rule Failed Expression:{0} Message:{1} ", getPassedExpression(e), ex.Message) });
// }
// }
// return ruleResult;
//}
#endregion Evals
#region PrameterHandler
public void ParameterHandler(string name, ParameterArgs args)
{
if (EvaluateParameter != null)
{
MTSParameterArgs mArgs = new MTSParameterArgs();
EvaluateParameter(name, mArgs);
args.Result = mArgs.Result;
}
}
public override async Task VisitAsync(Identifier parameter)
{
if (Parameters.ContainsKey(parameter.Name))
{
// The parameter is defined in the hashtable
if (Parameters[parameter.Name] is Expression expression)
{
// The parameter is itself another Expression
// Overloads parameters
foreach (var p in Parameters)
{
expression.Parameters[p.Key] = p.Value;
}
Result = await expression.EvaluateAsync(_evaluateParameterAsync, _evaluateFunctionAsync, _time, _step, _deltaTime);
}
else
{
Result = Parameters[parameter.Name];
}
}
else if (parameter.Name.EndsWith("_Time"))
{
Result = _time;
}
else if (parameter.Name.EndsWith("_Dt"))
{
Result = _deltaTime;
}
else
{
// The parameter should be defined in a call back method
var args = new ParameterArgs();
if (_evaluateParameterAsync != null)
{
var name = IgnoreCase ? parameter.Name.ToLower() : parameter.Name;
// Calls external implementations, which may be a MulticastDelegate which
// requires manual handling for async delegates.
foreach (var handler in _evaluateParameterAsync.GetInvocationList()
.Cast <EvaluateParameterAsyncHandler>())
{
await handler.Invoke(name, args);
}
}
if (!args.HasResult)
{
throw new ArgumentException("Parameter was not defined", parameter.Name);
}
Result = args.Result;
}
}
/// <summary>
/// extra parameters that requre additional stuff done go here
/// </summary>
/// <param name="name"></param>
/// <param name="args"></param>
private void NCalcPulsarParameters(string name, ParameterArgs args)
{
switch (name)
{
case "Mass":
MakeThisDependant(_designer.MassFormula);
args.Result = _designer.MassValue;
break;
case "Volume":
MakeThisDependant(_designer.VolumeFormula);
args.Result = _designer.VolumeFormula;
break;
case "Crew":
MakeThisDependant(_designer.CrewFormula);
args.Result = _designer.CrewReqValue;
break;
case "HTK":
MakeThisDependant(_designer.HTKFormula);
args.Result = _designer.HTKValue;
break;
case "ResearchCost":
MakeThisDependant(_designer.ResearchCostFormula);
args.Result = _designer.ResearchCostValue;
break;
case "MineralCosts":
foreach (var formula in _designer.MineralCostFormulas.Values)
{
MakeThisDependant(formula);
}
args.Result = _designer.MineralCostValues;
break;
case "CreditCost":
MakeThisDependant(_designer.CreditCostFormula);
args.Result = _designer.ResearchCostValue;
break;
case "GuidDict":
Dictionary <Guid, double> dict = new Dictionary <Guid, double>();
foreach (var kvp in _designAttribute.GuidDictionary)
{
//MakeThisDependant(kvp.Value);
dict.Add((Guid.Parse(kvp.Key.ToString())), kvp.Value.DResult);
}
args.Result = dict;
break;
}
}
private void _expression_EvaluateParameter(string name, ParameterArgs args)
{
args.Result = 0; // este valor é ignorado propositalmente
_formula = _formula.Replace(name, $"{name}(x{_functors.Count})");
var functionRepository = new FunctionRepository();
var functor = functionRepository.getFormulaByFunctionName(name);
this.AddFunction(functor);
}
static void EvaluateParameter(string p_name, ParameterArgs p_args, IParameterResolver p_resolver, IAttributeDataCollection p_collection, bool p_referenced)
{
//Debug.Log("EvaluateParameter: "+p_name);
p_args.Result = p_resolver.Resolve(p_name, p_collection, p_referenced);
// Only log first error
if (!hasErrorInEvaluation && p_resolver.hasErrorInResolving)
{
errorMessage = p_resolver.errorMessage;
}
hasErrorInEvaluation = hasErrorInEvaluation || p_resolver.hasErrorInResolving;
}
private void Exp_EvaluateParameter(string name, ParameterArgs args)
{
if (name.ToLower() == "pi")
{
args.Result = Math.PI;
}
if (name.ToLower() == "e")
{
args.Result = Math.E;
}
}
public override void Visit(Identifier parameter)
{
if (Parameters.ContainsKey(parameter.Name))
{
// The parameter is defined in the hashtable
if (Parameters[parameter.Name] is Expression)
{
// The parameter is itself another Expression
var expression = (Expression)Parameters[parameter.Name];
{
// foreach(var p in Parameters)
var __enumerator2 = (Parameters).GetEnumerator();
while (__enumerator2.MoveNext())
{
var p = __enumerator2.Current;
{
expression.Parameters[p.Key] = p.Value;
}
}
}
expression.EvaluateFunction += EvaluateFunction;
expression.EvaluateParameter += EvaluateParameter;
Result = ((Expression)Parameters[parameter.Name]).Evaluate();
}
else
{
Result = Parameters[parameter.Name];
}
}
else
{
// The parameter should be defined in a call back method
var args = new ParameterArgs();
// Calls external implementation
OnEvaluateParameter(parameter.Name, args);
if (!args.HasResult)
{
throw new ArgumentException("Parameter was not defined", parameter.Name);
}
if (args.Result == null)
{
throw new ArgumentException("Parameter was null", parameter.Name);
}
Result = args.Result;
}
}
private static void Expr_EvaluateParameter(string name, ParameterArgs args)
{
switch (name.ToLowerInvariant())
{
case "pi":
args.Result = Math.PI;
break;
case "e":
args.Result = Math.E;
break;
}
}
// Calc Parameters
public static void Parameters(string name, ParameterArgs parameterArgs)
{
// add Pi (Kreiszahl)
if (name == "Pi")
{
parameterArgs.Result = Math.PI;
}
// add e (Eulerzahl)
if (name == "e")
{
parameterArgs.Result = Math.E;
}
}
/// <summary>
/// extra parameters that requre additional stuff done go here
/// </summary>
/// <param name="name"></param>
/// <param name="args"></param>
private void NCalcPulsarParameters(string name, ParameterArgs args)
{
if (name == "Mass")
{
MakeThisDependant(_design.MassFormula);
args.Result = _design.MassValue;
}
if (name == "Volume")
{
MakeThisDependant(_design.VolumeFormula);
args.Result = _design.VolumeFormula;
}
if (name == "Crew")
{
MakeThisDependant(_design.CrewFormula);
args.Result = _design.CrewReqValue;
}
if (name == "HTK")
{
MakeThisDependant(_design.HTKFormula);
args.Result = _design.HTKValue;
}
if (name == "ResearchCost")
{
MakeThisDependant(_design.ResearchCostFormula);
args.Result = _design.ResearchCostValue;
}
if (name == "MineralCosts")
{
foreach (var formula in _design.MineralCostFormulas.Values)
{
MakeThisDependant(formula);
}
args.Result = _design.MineralCostValues;
}
if (name == "CreditCost")
{
MakeThisDependant(_design.CreditCostFormula);
args.Result = _design.ResearchCostValue;
}
if (name == "GuidDict")
{
Dictionary <Guid, double> dict = new Dictionary <Guid, double>();
foreach (var kvp in _designAbility.GuidDictionary)
{
//MakeThisDependant(kvp.Value);
dict.Add((Guid.Parse(kvp.Key.ToString())), kvp.Value.DResult);
}
args.Result = dict;
}
}
private void EvaluateParameter(string name, ParameterArgs args)
{
try
{
if (name.Contains("."))
{
var parts = name.Split('.'); // 2.2 or 2.3.1
if (parts.Length == 2)
{
args.Result = PsnParamValueExtractor.GetBitValueFromBytes(_cmdPartContext, _startByte, int.Parse(parts[0]), int.Parse(parts[1])) ? 1.0 : 0.0;
args.HasResult = true;
}
else if (parts.Length == 3)
{
args.Result = PsnParamValueExtractor.GetMultibitUnsignedValueFromBytes(_cmdPartContext, _startByte, int.Parse(parts[0]), int.Parse(parts[1]), int.Parse(parts[2]));
args.HasResult = true;
}
else
{
args.HasResult = false;
}
}
else
{
// else we have "u1" or "s19" or "r20" - byte or sbyte value or random beetween 0 and 20;
if (name.StartsWith("u"))
{
args.Result = (int)(PsnParamValueExtractor.GetByteValueFromBytes(_cmdPartContext, _startByte, int.Parse(name.Substring(1))));
args.HasResult = true;
}
else if (name.StartsWith("s"))
{
args.Result = (int)(PsnParamValueExtractor.GetSByteValueFromBytes(_cmdPartContext, _startByte, int.Parse(name.Substring(1))));
args.HasResult = true;
}
else if (name.StartsWith("r"))
{
args.Result = PsnParamValueExtractor.GetRandomIntValue(int.Parse(name.Substring(1)));
args.HasResult = true;
}
else
{
args.HasResult = false;
}
}
}
catch {
args.HasResult = false;
}
}
public override void Visit(Identifier parameter)
{
if (Parameters.ContainsKey(parameter.Name))
{
// The parameter is defined in the hashtable
if (Parameters[parameter.Name] is Expression)
{
// The parameter is itself another Expression
var expression = (Expression)Parameters[parameter.Name];
// Overloads parameters
foreach (var p in Parameters)
{
expression.Parameters[p.Key] = p.Value;
}
expression.EvaluateFunction += EvaluateFunction;
expression.EvaluateParameter += EvaluateParameter;
Result = ((Expression)Parameters[parameter.Name]).Evaluate();
}
else
{
Result = Parameters[parameter.Name];
}
}
else
{
// The parameter should be defined in a call back method
var args = new ParameterArgs();
// Calls external implementation
OnEvaluateParameter(parameter.Name, args);
if (args.HasResult)
{
Result = args.Result;
}
else if (parameter.Name.Equals("null", StringComparison.InvariantCulture))
{
Result = null;
}
else
{
throw new ArgumentException("Parameter was not defined", parameter.Name);
}
}
}
private void CheckParameter(string param, ParameterArgs args)
{
if (Sequence.current.ContainsVariable(param))
{
args.HasResult = true;
args.Result = Sequence.current.GetVariable(param);
}
else if (IsoSwitchesManager.getInstance().getIsoSwitches().containsSwitch(param))
{
args.HasResult = true;
args.Result = IsoSwitchesManager.getInstance().getIsoSwitches().consultSwitch(param);
}
else
{
args.HasResult = false;
paramError = "Missing parameter \"" + param + "\"";
}
}
public async override Task VisitAsync(Identifier parameter)
{
if (Parameters.ContainsKey(parameter.Name))
{
// The parameter is defined in the hashtable
if (Parameters[parameter.Name] is Expression)
{
// The parameter is itself another Expression
var expression = (Expression)Parameters[parameter.Name];
// Overloads parameters
foreach (var p in Parameters)
{
expression.Parameters[p.Key] = p.Value;
}
expression.EvaluateFunctionAsync += EvaluateFunctionAsync;
expression.EvaluateParameterAsync += EvaluateParameterAsync;
Result = await((Expression)Parameters[parameter.Name]).EvaluateAsync();
}
else
{
Result = Parameters[parameter.Name];
}
}
else
{
// The parameter should be defined in a call back method
var args = new ParameterArgs();
// Calls external implementation
await OnEvaluateParameterAsync(parameter.Name, args);
if (!args.HasResult)
{
throw new ArgumentException("Parameter was not defined", parameter.Name);
}
Result = args.Result;
}
}
/// <summary>
/// Parameter evaluator called off by function EvaluateExpression so as to elimiate the need of trying to cast the expression parameters to a more defined type.
/// Additionally it adds the possibility that an expression parameter itself can be of complex type.
/// </summary>
/// <param name="name">name of the parameter</param>
/// <param name="args">ParameterArgs object where to store the evaluation result</param>
private void EvaluateParam(string name, ParameterArgs args)
{
if (this._definesHandler.SubstitutionTokens.ContainsKey(name))
{
object substituionText;
this._definesHandler.SubstitutionTokens.TryGetValue(name, out substituionText);
Expression parameterExpression = new Expression((string)substituionText);
parameterExpression.EvaluateParameter += EvaluateParam;
try
{
args.Result = parameterExpression.Evaluate();
}
catch (EvaluationException)
{
//in case an exception occurred we do not set args and hence the evaluation will be undefined
}
}
//in case the key is not found we do not set args and hence the evaluation will be undefined
}
private void CheckParameter(string param, ParameterArgs args)
{
if (Database.Instance.attributes.Any(x => x.id == param))
{
args.HasResult = true;
AttributeValue attrValue = attributes.Find(x => x.attribute.id == param);
if (attrValue != null)
{
args.Result = attrValue.value;
}
else
{
args.Result = 0;
}
}
else
{
args.HasResult = false;
paramError = "Missing parameter \"" + param + "\"";
}
}
private void OnSelected(object sender, ParameterArgs e)
{
m_Args = e;
try
{
Parameter para = null;
for (int iLoop = 0; iLoop < parameterListGrid.Children.Count; iLoop++)
{
if (parameterListGrid.Children[iLoop] is Parameter)
{
para = parameterListGrid.Children[iLoop] as Parameter;
if (para.IsChecked && para.PumpType != e.m_PumpType)
{
para.SetCheckedStatus(false);
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public override void Visit(Parameter parameter)
{
if (parameters.Contains(parameter.Name))
{
// The parameter is defined in the hashtable
if (parameters[parameter.Name] is Expression)
{
// The parameter is itself another Expression
Expression expression = (Expression)parameters[parameter.Name];
expression.Parameters = parameters;
expression.EvaluateFunction += EvaluateFunction;
expression.EvaluateParameter += EvaluateParameter;
result = ((Expression)parameters[parameter.Name]).Evaluate();
}
else
{
result = parameters[parameter.Name];
}
}
else
{
// The parameter should be defined in a call back method
ParameterArgs args = new ParameterArgs();
// Calls external implementation
OnEvaluateParameter(parameter.Name, args);
if (args.Result == null)
{
throw new ArgumentException("Parameter was not defined", parameter.Name);
}
result = args.Result;
}
}
private object GetValue(Identifier parameter)
{
var args = new ParameterArgs();
// Calls external implementation
OnEvaluateParameter(parameter.Name, args);
if (!args.HasResult)
throw new ArgumentException("Parameter was not defined", parameter.Name);
return args.Result;
}
public override void Visit(Identifier parameter)
{
if (Parameters.ContainsKey(parameter.Name))
{
// The parameter is defined in the hashtable
if (Parameters[parameter.Name] is Expression)
{
// The parameter is itself another Expression
var expression = (Expression)Parameters[parameter.Name];
// Overloads parameters
foreach (var p in Parameters)
{
expression.Parameters[p.Key] = p.Value;
}
expression.EvaluateFunction += EvaluateFunction;
expression.EvaluateParameter += EvaluateParameter;
Result = ((Expression)Parameters[parameter.Name]).Evaluate();
}
else
Result = Parameters[parameter.Name];
}
else
{
// The parameter should be defined in a call back method
var args = new ParameterArgs();
// Calls external implementation
OnEvaluateParameter(parameter.Name, args);
if (!args.HasResult)
throw new ArgumentException("Parameter was not defined", parameter.Name);
Result = args.Result;
}
}
private void OnEvaluateParameter(string name, ParameterArgs args)
{
if (EvaluateParameter != null)
EvaluateParameter(name, args);
}
