/// <summary>
/// Represents method which is used for confirming assumption condition. Assumption can be declined - it means that we can prove, that condition CANNOT be ever satisfied.
/// </summary>
/// <returns>False if you can prove that condition cannot be ever satisfied, true otherwise.</returns>
public override bool ConfirmAssumption(FlowOutputSet outSet, AssumptionCondition condition, EvaluationLog log)
{
_outSet = outSet;
_log = log;
bool willAssume;
switch (condition.Form)
{
case ConditionForm.All:
willAssume = needsAll(outSet.Snapshot, condition.Parts);
break;
case ConditionForm.None:
//willAssume = needsNone(outSet.Snapshot, condition.Parts);
//break;
case ConditionForm.SomeNot:
willAssume = needsSomeNot(outSet.Snapshot, condition.Parts);
break;
default:
//we has to assume, because we can't disprove assumption
willAssume = true;
break;
}
if (willAssume)
{
processAssumption(condition);
}
return(willAssume);
}
/// <summary>
/// Initializes a new instance of the <see cref="AssumptionExecuter" /> class.
///
/// Note that astElement can be n-ary expression with n > 1.
/// However, it cannot be logical expression (and, or, xor). Logical expressions are eliminated
/// in the stage of control-flow graph generation.
/// </summary>
/// <param name="conditionForm">The condition form. See <see cref="ConditionForm"/> for more details.</param>
/// <param name="astElement">The AST element corresponding to the condition.</param>
/// <param name="log">The log of evaluation the astElement and its sub-expressions.</param>
/// <param name="flowOutputSet">The Output set of a program point.</param>
public AssumptionExecuter(ConditionForm conditionForm, LangElement astElement, EvaluationLog log, FlowOutputSet flowOutputSet)
{
this.flowOutputSet = flowOutputSet;
this.astElement = astElement;
this.conditionForm = conditionForm;
this.log = log;
}
/// <summary>
/// Insert new evaluation log when purchase user edit score.
/// </summary>
/// <param name="model">The evaluation log item information value.</param>
public ResultViewModel SavePurchaseEditScore(int evaluationId, IEnumerable <EvaluationLogItemViewModel> model)
{
var result = new ResultViewModel();
using (TransactionScope scope = new TransactionScope())
{
var evaAssign = _unitOfWork.GetRepository <EvaluationAssign>().Get(x => x.EvaluationId == evaluationId &&
x.UserType == ConstantValue.UserTypePurchasing).FirstOrDefault();
model = this.SumKpiGroupScore(evaluationId, model);
var evaluationLog = new EvaluationLog
{
EvaluationId = evaluationId,
ActionDate = DateTime.Now,
EmpNo = evaAssign.EmpNo,
AdUser = evaAssign.AdUser,
ActionBy = _token.AdUser,
ActionByUserCode = _token.EmpNo
};
_unitOfWork.GetRepository <EvaluationLog>().Add(evaluationLog);
_unitOfWork.Complete();
this.SaveItem(evaluationLog.Id, model);
this.IsEvaluationFinish(evaluationId);
_unitOfWork.Complete(scope);
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionPart" /> class.
/// </summary>
/// <param name="conditionPart">The definition of the part of the condition.</param>
/// <param name="log">The log of evaluation of the conditions' parts.</param>
/// <param name="flowOutputSet">The Output set of a program point.</param>
public ConditionPart(LangElement conditionPart, EvaluationLog log, FlowOutputSet flowOutputSet)
{
this.conditionPart = conditionPart;
this.log = log;
var snapshotEntry = log.ReadSnapshotEntry(conditionPart);
if (snapshotEntry != null)
{
MemoryEntry evaluatedPart = snapshotEntry.ReadMemory(flowOutputSet.Snapshot);
ConditionResult = GetConditionResult(flowOutputSet, evaluatedPart);
}
else
{
ConditionResult = PossibleValues.Unknown;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionParts" /> class.
/// </summary>
/// <param name="conditionForm">The condition form.</param>
/// <param name="flowOutputSet">Output set where condition will be assumed.</param>
/// <param name="log">The log of evaluation of the conditions' parts.</param>
/// <param name="conditionParts">The elements of the condition.</param>
public ConditionParts(ConditionForm conditionForm, FlowOutputSet flowOutputSet, EvaluationLog log, IEnumerable <ConditionPart> conditionParts)
{
this.flowOutputSet = flowOutputSet;
this.conditionParts.AddRange(conditionParts);
this.log = log;
this.conditionForm = conditionForm;
if (this.conditionParts.Count == 1)
{
if (conditionForm == ConditionForm.Some || conditionForm == ConditionForm.ExactlyOne)
{
this.conditionForm = ConditionForm.All;
}
else if (conditionForm == ConditionForm.SomeNot || conditionForm == ConditionForm.NotExactlyOne)
{
this.conditionForm = ConditionForm.None;
}
}
}
/// <summary>
/// Insert new evaluation log.
/// </summary>
/// <param name="model">The evaluation log item information value.</param>
public ResultViewModel Save(int evaluationId, IEnumerable <EvaluationLogItemViewModel> model)
{
var result = new ResultViewModel();
using (TransactionScope scope = new TransactionScope())
{
model = this.SumKpiGroupScore(evaluationId, model);
var evaluationLog = new EvaluationLog
{
EvaluationId = evaluationId,
ActionDate = DateTime.Now,
EmpNo = _token.EmpNo,
AdUser = _token.AdUser
};
this.SetIsAction(evaluationId);
_unitOfWork.GetRepository <EvaluationLog>().Add(evaluationLog);
_unitOfWork.Complete();
this.SaveItem(evaluationLog.Id, model);
this.IsEvaluationFinish(evaluationId);
_unitOfWork.Complete(scope);
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="MemoryContext"/> class.
/// </summary>
/// <param name="log">Evaluation log used for evaluating variables which are not yet in the memoryContext.</param>
/// <param name="valueFactory">ValueFactory used for creating value classes instances.</param>
public MemoryContext(EvaluationLog log, FlowOutputSet valueFactory)
{
this.log = log;
this.valueFactory = valueFactory;
}
/// <summary> /// Represents method which is used for confirming assumption condition. /// Assumption can be declined - it means that we can prove, that condition CANNOT be ever satisfied. /// </summary> /// <param name="outSet">Output set where condition will be assumed</param> /// <param name="condition">Assumed condition</param> /// <param name="log">Provide access to values computed during analysis</param> /// <returns>False if you can prove that condition cannot be ever satisfied, true otherwise.</returns> public abstract bool ConfirmAssumption(FlowOutputSet outSet, AssumptionCondition condition, EvaluationLog log);
/// <summary>
/// Initializes a new instance of the <see cref="ConditionParts" /> class.
/// </summary>
/// <param name="conditionForm">The condition form.</param>
/// <param name="flowOutputSet">Output set where condition will be assumed.</param>
/// <param name="log">The log of evaluation of the conditions' parts.</param>
/// <param name="conditionParts">The elements of the condition.</param>
public ConditionParts(ConditionForm conditionForm, FlowOutputSet flowOutputSet, EvaluationLog log, IEnumerable <Postfix> conditionParts)
: this(conditionForm, flowOutputSet, log, conditionParts.Select(a => a.SourceElement).ToArray())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionParts" /> class.
/// </summary>
/// <param name="conditionForm">The condition form.</param>
/// <param name="flowOutputSet">Output set where condition will be assumed.</param>
/// <param name="log">The log of evaluation of the conditions' parts.</param>
/// <param name="langElements">The elements of the condition.</param>
public ConditionParts(ConditionForm conditionForm, FlowOutputSet flowOutputSet, EvaluationLog log, params LangElement[] langElements)
: this(conditionForm, flowOutputSet, log, langElements.Select(a => new ConditionPart(a, log, flowOutputSet)))
{
}
/// <summary>
/// Represents method which is used for confirming assumption condition. Assumption can be declined - it means that we can prove, that condition CANNOT be ever satisfied.
/// </summary>
/// <param name="outSet">Output set where condition will be assumed</param>
/// <param name="condition">Assumed condition</param>
/// <param name="log">The evaluation log of the code constructs.</param>
/// <returns>
/// <c>false</c> if condition cannot be ever satisfied, true otherwise.
/// </returns>
public override bool ConfirmAssumption(FlowOutputSet outSet, AssumptionCondition condition, EvaluationLog log)
{
// Deprecated code that supported assumptions that are not decomposed using logical operators (&&, ||, xor)
// But it had very limited abstract state refinemend
/*
* AssumptionConditionExecuterDepr conditionParts = new AssumptionConditionExecuterDepr(condition.Form, outSet, log, condition.Parts);
* return conditionParts.MakeAssumption(null);
*/
// Non-primitive conditions in assumptions are now resolved on the level of control-flow graph
PHP.Core.Debug.Assert(condition.Parts.Count() == 1);
PHP.Core.Debug.Assert(condition.Form == ConditionForm.All || condition.Form == ConditionForm.None);
var assumptionExecuter = new AssumptionExecuter(condition.Form, condition.Parts.First().SourceElement, log, outSet);
AssumptionExecuter.PossibleValues enterAssumption = assumptionExecuter.IsSatisfied();
if (enterAssumption == AssumptionExecuter.PossibleValues.OnlyFalse)
{
return(false);
}
if (enterAssumption == AssumptionExecuter.PossibleValues.Unknown)
{
assumptionExecuter.RefineState();
}
return(true);
}
