/// <summary>
/// The operation to evaluate the result of a query.
/// </summary>
/// <param name="options">The options object which contains extra information
/// which helps during the exeuction of this modus.</param>
public static void Start(EvaluateOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
Logger.Log(I_StartProc_Evaluate);
IRecordHolder <QueryResult> records = EvaluationCalculator;
QueryResult[] results = QueryHandler.LoadQueryResults(options.ShouldImport);
records.TakeSnapShot(results);
IRecordHolder holder = null;
switch (options.EvaluationMode)
{
case EvaluationMode.Individual:
holder = records;
break;
case EvaluationMode.Aggregated:
holder = RecordMerger.Merge(records);
break;
}
if (options.ShouldExport)
{
SaveEvaluation(holder);
}
Logger.Log(I_EndProc_Evaluate);
}
static int Evaluate(EvaluateOptions options)
{
_logger.LogDebug("Evaluating the applications in the configuration file.");
var _localizationRepository = LoggingHelper.GetLocalizationRepository(options.Language);
_logger.LogInformation(_localizationRepository.GetText("INFO00001", options.ToString()));
var declareConfigRepository = new DeclareConfigurationRepository(options.JsonFileLocation);
foreach (var app in declareConfigRepository.Apps())
{
_logger.LogInformation($"Starting evaluation for {app.application_name}");
_dscLogic.GetLatestStatus(app);
if (String.IsNullOrWhiteSpace(app.policy_schedule))
{
_logger.LogWarning($"There is no policy schedule configured for {app.application_name}");
}
else
{
_dscLogic.IsScanDueFromSchedule(app);
}
_logger.LogInformation($"Evaluation complete for {app.application_name}");
}
_logger.LogDebug($"Exiting {LoggingHelper.GetMyMethodName()} with value {1}");
return(1);
}
private static void RunEvaluation(EvaluateOptions opts)
{
ExampleSelection exampleSelection;
switch (opts.ExampleSelection)
{
case "random":
exampleSelection = new RandomSelection();
break;
case "chronological":
exampleSelection = new ChronologicalSelection();
break;
case "manual":
exampleSelection = new ManualSelection();
break;
default:
throw new ArgumentException("Selection mode should be either 'random', 'chronological' or 'manual'");
}
exampleSelection.IncludeAllInputs = opts.IncludeAllInputs;
exampleSelection.TestCount = opts.TestCount;
exampleSelection.LearningStepCount = opts.LearningStepCount;
var result = Evaluate <string>(opts.ProgramName, exampleSelection);
SaveEvaluationResult(result);
}
public RawExpressionVisitor(EvaluateOptions options)
{
_options = options;
Result = new StringBuilder();
_numberFormatInfo = new NumberFormatInfo {
NumberDecimalSeparator = "."
};
}
public Expression(LogicalExpression expression, EvaluateOptions options)
{
if (expression == null)
throw new
ArgumentException("Expression can't be null", "expression");
ParsedExpression = expression;
Options = options;
}
public EvaluationVisitor(EvaluateOptions options, ushort?time, uint?step, float?deltaTime, EvaluateParameterAsyncHandler evaluateParameterAsync, EvaluateFunctionAsyncHandler evaluateFunctionAsync)
{
_options = options;
_time = time;
_step = step;
_deltaTime = deltaTime;
_evaluateParameterAsync = evaluateParameterAsync;
_evaluateFunctionAsync = evaluateFunctionAsync;
}
public Expression(string expression, EvaluateOptions options)
{
if (String.IsNullOrEmpty(expression))
throw new
ArgumentException("Expression can't be empty", "expression");
OriginalExpression = expression;
Options = options;
}
public static object Evaluate(TokenList tokens, PipeValue value, EvaluateOptions options, out PipeExecutionException[] exceptions)
{
CommonHelper.ConfirmNotNull(tokens, "tokens");
CommonHelper.ConfirmNotNull(options, "options");
EvaluationContext context = new EvaluationContext(tokens, value, options);
object returnValue = context.Evaluate();
exceptions = context.Exceptions;
return(returnValue);
}
public Expression(LogicalExpression expression, EvaluateOptions options)
{
if (expression == null)
{
throw new
ArgumentException("Expression can't be null", "expression");
}
ParsedExpression = expression;
Options = options;
}
public Expression(LogicalExpression expression, EvaluateOptions options = EvaluateOptions.None) : this()
{
if (expression == null)
{
throw new ArgumentException("Expression can't be null", nameof(expression));
}
ParsedExpression = expression;
Options = options;
}
public Expression(string expression, EvaluateOptions options)
{
if (String.IsNullOrEmpty(expression))
{
throw new
ArgumentException("Expression can't be empty", "expression");
}
OriginalExpression = expression;
Options = options;
}
public Expression(string expression, EvaluateOptions options = EvaluateOptions.None)
{
if (String.IsNullOrEmpty(expression))
{
throw new
ArgumentException("Expression can't be empty", "expression");
}
OriginalExpression = expression;
Options = options;
Parameters["null"] = CalcNull.Value;
}
public LogicalExpression AnalyzeExpression(string expression)
{
Options = EvaluateOptions.IgnoreCase;
if (String.IsNullOrEmpty(expression))
{
return(null);
}
LogicalExpression lgRet = Compile(expression, (Options & EvaluateOptions.NoCache) == EvaluateOptions.NoCache);
//Return
return(lgRet);
}
public Expression(string expression, Func <EvaluateOptions, EvaluationVisitor> expressionVisitorFactory, EvaluateOptions options = EvaluateOptions.None)
{
if (String.IsNullOrEmpty(expression))
{
throw new
ArgumentException("Expression can't be empty", "expression");
}
OriginalExpression = expression;
Options = options;
ExpressionVisitorFactory = expressionVisitorFactory;
}
public Expression(LogicalExpression expression, Func <EvaluateOptions, EvaluationVisitor> expressionVisitorFactory, EvaluateOptions options = EvaluateOptions.None)
{
if (expression == null)
{
throw new
ArgumentException("Expression can't be null", "expression");
}
ParsedExpression = expression;
Options = options;
ExpressionVisitorFactory = expressionVisitorFactory;
}
public Expression(string expression, EvaluateOptions options = EvaluateOptions.None) : this()
{
if (string.IsNullOrEmpty(expression))
{
throw new ArgumentException("Expression can't be empty", nameof(expression));
}
// Fix: The original grammar doesn't allow double quotes for strings.
expression = expression.Replace('\"', '\'');
OriginalExpression = expression;
Options = options;
}
private EvaluationContext(TokenList tokens, PipeValue data, EvaluateOptions options)
{
CommonHelper.ConfirmNotNull(tokens, "tokens");
CommonHelper.ConfirmNotNull(options, "options");
this.Options = options;
this.tokens = tokens;
this.data = data;
objStack.Push(data);
if (options.OutputXml)
{
XmlDocument doc = new XmlDocument();
xmlStack.Push(doc.DocumentElement);
}
this.Globals = new PipeGlobal(options.Globals);
this.Globals["_"] = data;
}
public EvaluationVisitor(EvaluateOptions options)
{
_options = options;
}
public static bool RoundAwayFromZero(this EvaluateOptions opts)
{
return(opts.Has(EvaluateOptions.RoundAwayFromZero));
}
public static bool IterateParameters(this EvaluateOptions opts)
{
return(opts.Has(EvaluateOptions.IterateParameters));
}
public static bool NoCache(this EvaluateOptions opts)
{
return(opts.Has(EvaluateOptions.NoCache));
}
public static bool IgnoreCase(this EvaluateOptions opts)
{
return(opts.Has(EvaluateOptions.IgnoreCase));
}
public static object Evaluate(string template, PipeValue value, EvaluateOptions options, out PipeExecutionException[] exceptions)
{
TokenList tokens = TokenList.FromString(template);
return(Evaluate(tokens, value, options, out exceptions));
}
/// <summary>
/// 创建公式表达式构造器
/// </summary>
/// <param name="expression">表达式字符串</param>
/// <param name="options">求值设定</param>
public FormulaExpression(string expression, EvaluateOptions options)
: base(expression, options)
{
}
/// <summary>
/// 创建公式表达式构造器
/// </summary>
/// <param name="expression">逻辑表达式</param>
/// <param name="options">求值设定</param>
public FormulaExpression(LogicalExpression expression, EvaluateOptions options)
: base(expression, options)
{
}
public EvaluationVisitor(Flow flow, EvaluateOptions options)
{
this.flow = flow;
this.options = options;
}
public Expression(string expression, EvaluateOptions options)
{
OriginalExpression = string.IsNullOrEmpty(expression) ? "true" : expression;
Options = options;
}
public LambdaExpressionVistor(IDictionary <string, object> parameters, EvaluateOptions options)
{
_parameters = parameters;
_options = options;
}
public LambdaExpressionVistor(L.ParameterExpression context, EvaluateOptions options)
{
_context = context;
_options = options;
}
public EvaluationVisitor(EvaluateOptions options)
{
_options = options;
}
private static bool Has(this EvaluateOptions opts, EvaluateOptions flag)
{
return((opts & flag) == flag);
}
private EvaluationVisitor CreateEvaluationVisitor(EvaluateOptions options)
{
return(new EvaluationVisitor(options));
}
public EvaluationVisitor(EvaluateOptions options = EvaluateOptions.None)
{
this.options = options;
}
public static bool AllowNullParameter(this EvaluateOptions opts)
{
return(opts.Has(EvaluateOptions.AllowNullParameter));
}
