/// <summary>
/// Constructor for an explanation, based on a change
/// </summary>
/// <param name="element">The element for which this explanation part is created</param>
/// <param name="change">The change performed</param>
public ExplanationPart(ModelElement element, Change change)
{
Element = element;
Change = change;
SubExplanations = new List<ExplanationPart>();
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
// Explain what happens in this statement
explanation = ExplanationPart.CreateSubExplanation(explanation, this);
IVariable variable = ListExpression.GetVariable(context);
if (variable != null)
{
// HacK : ensure that the value is a correct rigth side
// and keep the result of the right side operation
ListValue listValue = variable.Value.RightSide(variable, false, false) as ListValue;
variable.Value = listValue;
if (listValue != null)
{
// Provide the state of the list before removing elements from it
ExplanationPart.CreateSubExplanation(explanation, "Input data = ", listValue);
ListValue newListValue = new ListValue(listValue.CollectionType, new List<IValue>());
int token = context.LocalScope.PushContext();
context.LocalScope.SetVariable(IteratorVariable);
int index = 0;
if (Position == PositionEnum.Last)
{
index = listValue.Val.Count - 1;
}
// Remove the element while required to do so
while (index >= 0 && index < listValue.Val.Count)
{
IValue value = listValue.Val[index];
index = NextIndex(index);
IteratorVariable.Value = value;
if (ConditionSatisfied(context, explanation))
{
if (Position != PositionEnum.All)
{
break;
}
}
else
{
InsertInResult(newListValue, value);
}
}
// Complete the list
while (index >= 0 && index < listValue.Val.Count)
{
IValue value = listValue.Val[index];
InsertInResult(newListValue, value);
index = NextIndex(index);
}
Change change = new Change(variable, variable.Value, newListValue);
changes.Add(change, apply, runner);
ExplanationPart.CreateSubExplanation(explanation, Root, change);
context.LocalScope.PopContext(token);
}
}
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
// Explain what happens in this statement
explanation = ExplanationPart.CreateSubExplanation(explanation, this);
IVariable variable = ListExpression.GetVariable(context);
if (variable != null)
{
// HacK : ensure that the value is a correct rigth side
// and keep the result of the right side operation
ListValue listValue = variable.Value.RightSide(variable, false, false) as ListValue;
variable.Value = listValue;
if (listValue != null)
{
ExplanationPart.CreateSubExplanation(explanation, "Input data = ", listValue);
IValue value = Value.GetExpressionValue(context, explanation);
if (value != null)
{
if (!listValue.Val.Contains(value))
{
ListValue newListValue = new ListValue(listValue);
int index = newListValue.Val.IndexOf(EfsSystem.Instance.EmptyValue);
if (index >= 0)
{
ExplanationPart.CreateSubExplanation(explanation, "Inserting", value);
newListValue.Val[index] = value;
}
else
{
// List is full, try to remove an element before inserting the new element
if (ReplaceElement != null)
{
IValue removeValue = ReplaceElement.GetExpressionValue(context, explanation);
ExplanationPart.CreateSubExplanation(explanation, "Replaced element", removeValue);
index = newListValue.Val.IndexOf(removeValue);
if (index >= 0)
{
ExplanationPart.CreateSubExplanation(explanation, "Replacing", value);
newListValue.Val[index] = value.RightSide(variable, true, true);
}
else
{
Root.AddError("Cannot remove replacing element " + removeValue.Name);
}
}
else
{
Root.AddError("Cannot add new element in list value : list is full");
}
}
Change change = new Change(variable, variable.Value, newListValue);
changes.Add(change, apply, runner);
ExplanationPart.CreateSubExplanation(explanation, Root, change);
}
else
{
ExplanationPart.CreateSubExplanation(explanation, "NOT added : Already present in collection", value);
}
}
else
{
Root.AddError("Cannot find value for " + Value);
}
}
else
{
Root.AddError("Variable " + ListExpression + " does not contain a list value");
}
}
else
{
Root.AddError("Cannot find variable for " + ListExpression);
}
}
/// <summary>
/// Creates a sub explanation for the explain provided as parameter
/// </summary>
/// <param name="explain"></param>
/// <param name="root"></param>
/// <param name="change"></param>
/// <returns></returns>
public static ExplanationPart CreateSubExplanation(ExplanationPart explain, ModelElement root, Change change)
{
ExplanationPart retVal = null;
if (explain != null)
{
retVal = new ExplanationPart(root, change);
explain.SubExplanations.Add(retVal);
}
return retVal;
}
/// <summary>
/// Adds a change to the list of changes
/// </summary>
/// <param name="change">The change to add</param>
/// <param name="apply">Indicates whether the change should be applied immediately</param>
/// <param name="runner"></param>
public void Add(Change change, bool apply, Runner runner)
{
Changes.Add(change);
if (apply)
{
// BUG: This is the case for procedure calls.
// In this case, computing the next changes induced by the procedure must be based on this changes.
// However, this contradicts a invariant : the state of the system does not change as long as all changes have not been computed
// To fix this, changes should be unapplied at the end of the procedure call change evaluation to be applied back
// during the activation application.
change.Apply(runner);
}
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
IVariable var = VariableIdentification.GetVariable(context);
if (var != null)
{
IValue value = Expression.GetExpressionValue(context, explanation);
if (value != null)
{
value = value.RightSide(var, true, true);
}
Range range = var.Type as Range;
if (range != null && range.convert(value) == null)
{
AddError("Value " + value + " is outside range");
}
else
{
Change change = new Change(var, var.Value, value);
changes.Add(change, apply, runner);
ExplanationPart.CreateSubExplanation(explanation, Root, change);
}
}
else
{
AddError("Cannot find variable " + VariableIdentification);
}
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
int index = context.LocalScope.PushContext();
context.LocalScope.setVariable(IteratorVariable);
IVariable variable = ListExpression.GetVariable(context);
if (variable != null)
{
// HacK : ensure that the value is a correct rigth side
// and keep the result of the right side operation
ListValue listValue = variable.Value.RightSide(variable, false, false) as ListValue;
variable.Value = listValue;
if (listValue != null)
{
ListValue newListValue = new ListValue(listValue);
int i = 0;
foreach (IValue current in newListValue.Val)
{
IteratorVariable.Value = current;
if (conditionSatisfied(context, explanation))
{
break;
}
i += 1;
}
if (i < newListValue.Val.Count)
{
IValue value = Value.GetValue(context, explanation);
if (value != null)
{
newListValue.Val[i] = value;
Change change = new Change(variable, variable.Value, newListValue);
changes.Add(change, apply, runner);
ExplanationPart.CreateSubExplanation(explanation, Root, change);
}
else
{
Root.AddError("Cannot find value for " + Value.ToString());
}
}
else
{
Root.AddError("Cannot find value in " + ListExpression.ToString() + " which satisfies " +
Condition.ToString());
}
}
else
{
Root.AddError("Variable " + ListExpression.ToString() + " does not contain a list value");
}
}
else
{
Root.AddError("Cannot find variable for " + ListExpression.ToString());
}
context.LocalScope.PopContext(index);
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
IVariable variable = ListExpression.GetVariable(context);
if (variable != null)
{
// HacK : ensure that the value is a correct rigth side
// and keep the result of the right side operation
ListValue listValue = variable.Value.RightSide(variable, false, false) as ListValue;
variable.Value = listValue;
if (listValue != null)
{
IValue value = Value.GetValue(context, explanation);
if (value != null)
{
if (!listValue.Val.Contains(value))
{
ListValue newListValue = new ListValue(listValue);
int index = newListValue.Val.IndexOf(EFSSystem.EmptyValue);
if (index >= 0)
{
newListValue.Val[index] = value;
}
else
{
// List is full, try to remove an element before inserting the new element
if (ReplaceElement != null)
{
IValue removeValue = ReplaceElement.GetValue(context, explanation);
index = newListValue.Val.IndexOf(removeValue);
if (index >= 0)
{
newListValue.Val[index] = value.RightSide(variable, true, true);
}
else
{
Root.AddError("Cannot remove replacing element " + removeValue.Name);
}
}
else
{
Root.AddError("Cannot add new element in list value : list is full");
}
}
Change change = new Change(variable, variable.Value, newListValue);
changes.Add(change, apply, runner);
ExplanationPart.CreateSubExplanation(explanation, Root, change);
}
else
{
AddError("Value " + value.LiteralName + " already present in list. It has not been added");
}
}
else
{
Root.AddError("Cannot find value for " + Value.ToString());
}
}
else
{
Root.AddError("Variable " + ListExpression.ToString() + " does not contain a list value");
}
}
else
{
Root.AddError("Cannot find variable for " + ListExpression.ToString());
}
}
/// <summary>
/// Adds a change to the list of changes
/// </summary>
/// <param name="change">The change to add</param>
/// <param name="apply">Indicates whether the change should be applied immediately</param>
public void Add(Change change, bool apply)
{
Changes.Add(change);
if (apply)
{
change.Apply();
}
}