/// <summary>
/// Checks whetever actions and observations in this query are consistent with those
/// </summary>
/// <param name="state"></param>
/// <param name="worldAction"></param>
/// <param name="time"></param>
/// <returns></returns>
public override QueryResult CheckCondition(World.State state, World.WorldAction worldAction, int time)
{
_logger.Info("Checking if scenario: " + this._scenario + " with parameters:\nstate: " + state + "\naction: " + worldAction);
var result = QueryResult.Undefined;
if (this._scenario.observations.Any(sor => sor.Time.Equals(time) && !sor.Expr.Evaluate(state)))
{
result = QueryResult.False;
}
if (result == QueryResult.True)
{
if (this._scenario.actions.Any(sar => sar.Time.Equals(time) && sar.CheckIfActiveAt(time) && !sar.WorldAction.Equals(worldAction)))
{
result = QueryResult.False;
}
}
string logResult = "Executable: " + result;
if (QueryResult.Undefined == result)
{
_logger.Warn(logResult);
}
else
{
_logger.Info(logResult);
}
return(result);
}
public override QueryResult CheckCondition(World.State state, World.WorldAction worldAction, int time)
{
_logger.Info("Checking Action: " + this._worldAction + "at time: " + this._time + "\nwith parameters:\nstate: " + state + "\naction: " + worldAction);
var result = QueryResult.Undefined;
if (time == _time || _time == -1)
{
if (this._worldAction == null)
{
if (worldAction == null)
{
result = QueryResult.True;
}
else
{
result = QueryResult.False;
}
}
else if (this._worldAction.Equals(worldAction))
{
result = QueryResult.True;
}
else
{
result = QueryResult.False;
}
}
else if (_time < time)
{
result = QueryResult.False;
}
else if (_time > time)
{
result = QueryResult.Undefined;
}
string logResult = "Method result: " + result;
if (QueryResult.Undefined == result)
{
_logger.Warn(logResult);
}
else
{
_logger.Info(logResult);
}
return(result);
}
/// <summary>
/// Checks given parameters with conditionAtTimeQuery and ExecutableScenarioQuery
/// </summary>
/// <param name="state"></param>
/// <param name="worldAction"></param>
/// <param name="time"></param>
/// <returns></returns>
public override QueryResult CheckCondition(World.State state, World.WorldAction worldAction, int time)
{
_logger.Info("Checking condition: " + this._condition + "\n accesible with parameters:\nstate: " + state + "\naction: " + worldAction);
QueryResult condAtTimeResult = CondAtTimeQuery.CheckCondition(state, worldAction, time);
QueryResult execResult = ExecQuery.CheckCondition(state, worldAction, time);
QueryResult result;
if (condAtTimeResult == QueryResult.Error || condAtTimeResult == QueryResult.Error)
{
result = QueryResult.Error;
}
else
{
if (condAtTimeResult == QueryResult.False || condAtTimeResult == QueryResult.False)
{
result = QueryResult.False;
}
else
{
if (condAtTimeResult == QueryResult.Undefined || condAtTimeResult == QueryResult.Undefined)
{
result = QueryResult.Undefined;
}
else
{
result = QueryResult.True;
}
}
}
string logResult = "Accesible: " + result;
if (QueryResult.Undefined == result)
{
_logger.Warn(logResult);
}
else
{
_logger.Info(logResult);
}
return(result);
}
public List <Vertex> CreateChildsBasedOnImplications(List <Implication> implications, World.WorldAction nextActionFromScenario, int nextTime)
{
List <Vertex> childs = new List <Vertex>();
if (ActualWorldAction != null)
{
if (ActualWorldAction.GetEndTime() < nextTime)
{
return(GetImpossibleChilds());
}
if (ActualWorldAction.GetEndTime() == nextTime)
{
ActualWorldAction = null;
}
}
WorldAction leafAction = ActualWorldAction;
if (NextActions.Count > 0)
{
SortActionsByStartTime(NextActions);
if (NextActions[0].StartAt < nextTime)
{
leafAction = NextActions[0];
}
}
foreach (var implication in implications)
{
Vertex child = new Vertex(this);
child.Root = this;
child.ActualState = implication.FutureState;
WorldAction actualAction = nextActionFromScenario;
if (actualAction != null)
{
actualAction.StartAt = nextTime;
}
if (implication.TriggeredActions.Count > 0)
{
WorldAction triggeredAction = implication.TriggeredActions[0];
foreach (var action in implication.TriggeredActions)
{
if (triggeredAction.StartAt > action.StartAt)
{
triggeredAction = (WorldAction)action.Clone();
}
}
if (nextActionFromScenario == null)
{
if (triggeredAction != null)
{
actualAction = triggeredAction;
}
}
else
{
if (triggeredAction != null && nextActionFromScenario.StartAt == triggeredAction.StartAt)
{
this.IsPossible = false;
return(childs);
}
}
}
child.ActualWorldAction = actualAction;
child.NextActions = new List <WorldAction>();
child.NextActions.AddRange(implication.TriggeredActions);
child.Time = nextTime;
child.IsPossible = child.ValidateActions();
childs.Add(child);
}
return(childs);
}
