/// <summary>
/// Provides the value associated to this Expression
/// </summary>
/// <param name="context">The context on which the value must be found</param>
/// <returns></returns>
public override Values.IValue GetValue(InterpretationContext context)
{
Values.ListValue retVal = null;
Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue;
if (value != null)
{
int token = PrepareIteration(context);
retVal = new Values.ListValue((Types.Collection)GetExpressionType(), new List <Values.IValue>());
foreach (Values.IValue v in value.Val)
{
if (v != EFSSystem.EmptyValue)
{
IteratorVariable.Value = v;
if (conditionSatisfied(context))
{
retVal.Val.Add(IteratorExpression.GetValue(context));
}
}
NextIteration();
}
EndIteration(context, token);
}
return(retVal);
}
/// <summary>
/// Provides the value associated to this Expression
/// </summary>
/// <param name="context">The context on which the value must be found</param>
/// <returns></returns>
public override Values.IValue GetValue(InterpretationContext context)
{
Values.IValue retVal = EFSSystem.EmptyValue;
Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue;
if (value != null)
{
int token = PrepareIteration(context);
for (int i = value.Val.Count - 1; i >= 0; i--)
{
Values.IValue v = value.Val[i];
if (v != EFSSystem.EmptyValue)
{
IteratorVariable.Value = v;
if (conditionSatisfied(context))
{
retVal = IteratorVariable.Value;
break;
}
}
NextIteration();
}
EndIteration(context, token);
}
return(retVal);
}
/// <summary>
/// Provides the value associated to this Expression
/// </summary>
/// <param name="context">The context on which the value must be found</param>
/// <returns></returns>
public override Values.IValue GetValue(InterpretationContext context)
{
int count = 0;
Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue;
if (value != null)
{
int token = PrepareIteration(context);
foreach (Values.IValue v in value.Val)
{
if (v != EFSSystem.EmptyValue)
{
IteratorVariable.Value = v;
if (conditionSatisfied(context))
{
count += 1;
}
}
NextIteration();
}
EndIteration(context, token);
}
return(new Values.IntValue(EFSSystem.IntegerType, count));;
}
public override bool Contains(Values.IValue first, Values.IValue other)
{
bool retVal = false;
Values.ListValue listValue = first as Values.ListValue;
if (listValue != null)
{
foreach (Values.IValue value in listValue.Val)
{
StateMachine stateMachine = value.Type as StateMachine;
if (stateMachine != null)
{
if (stateMachine.Contains(value, other))
{
retVal = true;
break;
}
}
else
{
if (value.Type.CompareForEquality(value, other))
{
retVal = true;
break;
}
}
}
}
return(retVal);
}
/// <summary>
/// Provides the value associated to this Expression
/// </summary>
/// <param name="context">The context on which the value must be found</param>
/// <returns></returns>
public override Values.IValue GetValue(InterpretationContext context)
{
Values.IValue retVal = EFSSystem.BoolType.True;
Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue;
if (value != null)
{
int token = PrepareIteration(context);
if (Condition != null)
{
foreach (Values.IValue v in value.Val)
{
if (v != EFSSystem.EmptyValue)
{
IteratorVariable.Value = v;
if (!conditionSatisfied(context))
{
retVal = EFSSystem.BoolType.False;
break;
}
}
NextIteration();
}
}
EndIteration(context, token);
}
return(retVal);
}
/// <summary>
/// Provides the value associated to this Expression
/// </summary>
/// <param name="context">The context on which the value must be found</param>
/// <returns></returns>
public override Values.IValue GetValue(InterpretationContext context)
{
Values.IValue retVal = null;
Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue;
if (value != null)
{
int token = PrepareIteration(context);
context.LocalScope.setVariable(AccumulatorVariable);
AccumulatorVariable.Value = InitialValue.GetValue(context);
foreach (Values.IValue v in value.Val)
{
if (v != EFSSystem.EmptyValue)
{
IteratorVariable.Value = v;
if (conditionSatisfied(context))
{
AccumulatorVariable.Value = IteratorExpression.GetValue(context);
}
}
NextIteration();
}
EndIteration(context, token);
retVal = AccumulatorVariable.Value;
}
else
{
AddError("Cannot evaluate list value " + ListExpression.ToString());
}
return(retVal);
}
/// <summary>
/// Inserts a value in the result set
/// </summary>
/// <param name="newListValue"></param>
/// <param name="value"></param>
private void InsertInResult(Values.ListValue newListValue, Values.IValue value)
{
if (Position == PositionEnum.Last)
{
newListValue.Val.Insert(0, value);
}
else
{
newListValue.Val.Add(value);
}
}
/// <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>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply)
{
Variables.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
Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue;
variable.Value = listValue;
if (listValue != null)
{
Values.ListValue newListValue = new Values.ListValue(listValue);
int i = 0;
foreach (Values.IValue current in newListValue.Val)
{
IteratorVariable.Value = current;
if (conditionSatisfied(context))
{
break;
}
i += 1;
}
if (i < newListValue.Val.Count)
{
Values.IValue value = Value.GetValue(context);
if (value != null)
{
newListValue.Val[i] = value;
Rules.Change change = new Rules.Change(variable, variable.Value, newListValue);
changes.Add(change, apply);
explanation.SubExplanations.Add(new ExplanationPart(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());
}
}
/// <summary>
/// Provides the value of the function
/// </summary>
/// <param name="instance">the instance on which the function is evaluated</param>
/// <param name="actuals">the actual parameters values</param>
/// <param name="localScope">the values of local variables</param>
/// <returns>The value for the function application</returns>
public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary <Variables.Actual, Values.IValue> actuals)
{
Values.IValue retVal = EFSSystem.BoolType.False;
int token = context.LocalScope.PushContext();
AssignParameters(context, actuals);
Values.ListValue collection = context.findOnStack(Collection).Value as Values.ListValue;
if (collection != null)
{
Values.IValue expectedFirst = context.findOnStack(ExpectedFirst).Value;
if (expectedFirst != null)
{
int firstIndex = collection.Val.IndexOf(expectedFirst);
if (firstIndex >= 0)
{
Values.IValue expectedSecond = context.findOnStack(ExpectedSecond).Value;
if (expectedSecond != null)
{
int secondIndex = collection.Val.IndexOf(expectedSecond);
if (secondIndex >= 0)
{
if (firstIndex < secondIndex)
{
retVal = EFSSystem.BoolType.True;
}
}
else
{
Collection.AddError("Cannot find " + expectedSecond.FullName + " in " + collection.ToString() + " to evaluate " + Name);
}
}
else
{
Collection.AddError("Cannot evaluate second element to evaluate " + Name);
}
}
else
{
Collection.AddError("Cannot find " + expectedFirst.FullName + " in " + collection.ToString() + " to evaluate " + Name);
}
}
else
{
Collection.AddError("Cannot evaluate first element to evaluate " + Name);
}
}
context.LocalScope.PopContext(token);
return(retVal);
}
/// <summary>
/// Coputes targets from the function and adds them to the collection
/// </summary>
/// <param name="function">Function containing targets</param>
/// <param name="collection">Collection to be filled with targets</param>
private void ComputeTargets(Function function, Values.ListValue collection)
{
if (function != null)
{
Graph graph = function.Graph;
if (graph != null && graph.Segments.Count > 1)
{
double prevSpeed = Double.MaxValue;
for (int i = 1; i < graph.Segments.Count; i++)
{
Graph.Segment s = graph.Segments[i];
Types.Structure structureType = (Types.Structure)EFSSystem.findType(OverallNameSpaceFinder.INSTANCE.findByName(EFSSystem.Dictionaries[0], "Kernel.SpeedAndDistanceMonitoring.TargetSupervision"), "Kernel.SpeedAndDistanceMonitoring.TargetSupervision.Target");
Values.StructureValue value = new Values.StructureValue(structureType, structureType.NameSpace);
Variables.Variable speed = (Variables.Variable)DataDictionary.Generated.acceptor.getFactory().createVariable();
speed.Type = EFSSystem.findType(OverallNameSpaceFinder.INSTANCE.findByName(EFSSystem.Dictionaries[0], "Default.BaseTypes"), "Default.BaseTypes.Speed");
speed.Name = "Speed";
speed.Mode = Generated.acceptor.VariableModeEnumType.aInternal;
speed.Default = "0.0";
speed.Enclosing = value;
speed.Value = new Values.DoubleValue(EFSSystem.DoubleType, s.Val(s.Start));
value.set(speed);
Variables.Variable location = (Variables.Variable)DataDictionary.Generated.acceptor.getFactory().createVariable();
location.Type = EFSSystem.findType(OverallNameSpaceFinder.INSTANCE.findByName(EFSSystem.Dictionaries[0], "Default.BaseTypes"), "Default.BaseTypes.Distance");
location.Name = "Location";
location.Mode = Generated.acceptor.VariableModeEnumType.aInternal;
location.Default = "0.0";
location.Enclosing = value;
location.Value = new Values.DoubleValue(EFSSystem.DoubleType, s.Start);
value.set(location);
Variables.Variable length = (Variables.Variable)DataDictionary.Generated.acceptor.getFactory().createVariable();
length.Type = EFSSystem.findType(OverallNameSpaceFinder.INSTANCE.findByName(EFSSystem.Dictionaries[0], "Default.BaseTypes"), "Default.BaseTypes.Length");
length.Name = "Length";
length.Mode = Generated.acceptor.VariableModeEnumType.aInternal;
length.Default = "0.0";
length.Enclosing = value;
length.Value = new Values.DoubleValue(EFSSystem.DoubleType, s.End);
value.set(length);
if (s.Val(s.Start) < prevSpeed)
{
collection.Val.Add(value);
}
prevSpeed = s.Val(s.Start);
}
}
}
}
/// <summary>
/// Provides the surface of this function if it has been statically defined
/// </summary>
/// <param name="context">the context used to create the surface</param>
/// <param name="xParam">The X axis of this surface</param>
/// <param name="yParam">The Y axis of this surface</param>
/// <returns>The surface which corresponds to this expression</returns>
public override Functions.Surface createSurface(Interpreter.InterpretationContext context, Parameter xParam, Parameter yParam)
{
Functions.Surface retVal = base.createSurface(context, xParam, yParam);
Functions.Surface surface = InitialValue.createSurface(context, xParam, yParam);
if (surface != null)
{
Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue;
if (value != null)
{
int token = PrepareIteration(context);
AccumulatorVariable.Value = surface.Function;
foreach (Values.IValue v in value.Val)
{
if (v != EFSSystem.EmptyValue)
{
IteratorVariable.Value = v;
if (conditionSatisfied(context))
{
AccumulatorVariable.Value = IteratorExpression.GetValue(context);
}
}
NextIteration();
}
Functions.Function function = AccumulatorVariable.Value as Functions.Function;
if (function != null)
{
retVal = function.Surface;
}
else
{
throw new Exception("Expression does not reduces to a function");
}
EndIteration(context, token);
}
}
else
{
throw new Exception("Cannot create surface for initial value " + InitialValue.ToString());
}
retVal.XParameter = xParam;
retVal.YParameter = yParam;
return(retVal);
}
/// <summary>
/// Creates the graph associated to this expression, when the given parameter ranges over the X axis
/// </summary>
/// <param name="context">The interpretation context</param>
/// <param name="parameter">The parameters of *the enclosing function* for which the graph should be created</param>
/// <returns></returns>
public override Functions.Graph createGraph(InterpretationContext context, Parameter parameter)
{
Functions.Graph retVal = base.createGraph(context, parameter);
Functions.Graph graph = InitialValue.createGraph(context, parameter);
if (graph != null)
{
Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue;
if (value != null)
{
int token = PrepareIteration(context);
AccumulatorVariable.Value = graph.Function;
foreach (Values.IValue v in value.Val)
{
if (v != EFSSystem.EmptyValue)
{
IteratorVariable.Value = v;
if (conditionSatisfied(context))
{
AccumulatorVariable.Value = IteratorExpression.GetValue(context);
}
}
NextIteration();
}
Functions.Function function = AccumulatorVariable.Value as Functions.Function;
if (function != null)
{
retVal = function.Graph;
}
else
{
retVal = Functions.Function.createGraphForValue(AccumulatorVariable.Value);
}
EndIteration(context, token);
}
}
else
{
throw new Exception("Cannot create graph for initial value " + InitialValue.ToString());
}
return(retVal);
}
/// <summary>
/// Provides the value of the function
/// </summary>
/// <param name="instance">the instance on which the function is evaluated</param>
/// <param name="actuals">the actual parameters values</param>
/// <returns>The value for the function application</returns>
public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary <Variables.Actual, Values.IValue> actuals)
{
Values.IValue retVal = null;
int token = context.LocalScope.PushContext();
AssignParameters(context, actuals);
Types.Collection collectionType = (Types.Collection)EFSSystem.findType(OverallNameSpaceFinder.INSTANCE.findByName(EFSSystem.Dictionaries[0], "Kernel.SpeedAndDistanceMonitoring.TargetSupervision"), "Kernel.SpeedAndDistanceMonitoring.TargetSupervision.Targets");
Values.ListValue collection = new Values.ListValue(collectionType, new List <Values.IValue>());
// compute targets from the MRSP
Function function1 = context.findOnStack(Targets1).Value as Functions.Function;
if (function1 != null && !function1.Name.Equals("EMPTY"))
{
Graph graph1 = createGraphForValue(context, function1);
ComputeTargets(graph1.Function, collection);
}
// compute targets from the MA
Function function2 = context.findOnStack(Targets2).Value as Functions.Function;
if (function2 != null && !function2.Name.Equals("EMPTY"))
{
Graph graph2 = createGraphForValue(context, function2);
ComputeTargets(graph2.Function, collection);
}
// compute targets from the SR
Function function3 = context.findOnStack(Targets3).Value as Functions.Function;
if (function3 != null && !function3.Name.Equals("EMPTY"))
{
Graph graph3 = createGraphForValue(context, function3);
ComputeTargets(graph3.Function, collection);
}
context.LocalScope.PopContext(token);
retVal = collection;
return(retVal);
}
/// <summary>
/// Provides the value associated to this Expression
/// </summary>
/// <param name="context">The context on which the value must be found</param>
/// <returns></returns>
public override Values.IValue GetValue(InterpretationContext context)
{
List <IValue> elements = new List <IValue>();
foreach (Expression expr in ListElements)
{
IValue val = expr.GetValue(context);
if (val != null)
{
elements.Add(val);
}
else
{
AddError("Cannot evaluate " + expr.ToString());
}
}
Values.IValue retVal = new Values.ListValue(ExpressionType, elements);
return(retVal);
}
/// <summary>
/// Compares two lists for equality
/// </summary>
/// <param name="first"></param>
/// <param name="other"></param>
/// <returns></returns>
public override bool CompareForEquality(Values.IValue first, Values.IValue other)
{
bool retVal = false;
Values.ListValue list1 = first as Values.ListValue;
Values.ListValue list2 = other as Values.ListValue;
if (list1 != null && list2 != null)
{
if (list1.ElementCount == list2.ElementCount)
{
retVal = true;
foreach (Values.IValue val1 in list1.Val)
{
if (!(val1 is Values.EmptyValue))
{
bool found = false;
foreach (Values.IValue val2 in list2.Val)
{
if (val1.Type.CompareForEquality(val1, val2))
{
found = true;
break;
}
}
if (!found)
{
retVal = false;
break;
}
}
}
}
}
return(retVal);
}
/// <summary>
/// Provides the value of the function
/// </summary>
/// <param name="instance">the instance on which the function is evaluated</param>
/// <param name="actuals">the actual parameters values</param>
/// <param name="localScope">the values of local variables</param>
/// <returns>The value for the function application</returns>
public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary <Variables.Actual, Values.IValue> actuals)
{
Values.IValue retVal = null;
int token = context.LocalScope.PushContext();
AssignParameters(context, actuals);
Values.ListValue value = context.findOnStack(Collection) as Values.ListValue;
if (value != null)
{
Types.Collection collectionType = value.Type as Types.Collection;
if (collectionType != null && collectionType.Type != null)
{
Types.Type elementType = collectionType.Type;
int i = 0;
while (i < value.Val.Count && value.Val[i] != EFSSystem.EmptyValue)
{
i += 1;
}
if (i < value.Val.Count)
{
retVal = elementType.DefaultValue;
value.Val[i] = retVal;
}
else
{
AddError("Cannot allocate element in list : list full");
}
}
}
context.LocalScope.PopContext(token);
return(retVal);
}
/// <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>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply)
{
Variables.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
Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue;
variable.Value = listValue;
if (listValue != null)
{
int token = context.LocalScope.PushContext();
context.LocalScope.setVariable(IteratorVariable);
foreach (Values.IValue value in listValue.Val)
{
if (value != EFSSystem.EmptyValue)
{
IteratorVariable.Value = value;
if (conditionSatisfied(context))
{
Call.GetChanges(context, changes, explanation, apply);
}
}
}
context.LocalScope.PopContext(token);
}
else
{
Root.AddError("List expression does not evaluate to a list value");
}
}
else
{
Root.AddError("Cannot find variable for " + ListExpression.ToString());
}
}
/// <summary>
/// Provides the value associated to this Expression
/// </summary>
/// <param name="context">The context on which the value must be found</param>
/// <returns></returns>
public override Values.IValue GetValue(InterpretationContext context)
{
Values.IValue retVal = null;
Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue;
if (value != null)
{
int token = PrepareIteration(context);
context.LocalScope.setVariable(AccumulatorVariable);
Types.Type resultType = GetExpressionType();
if (resultType != null)
{
AccumulatorVariable.Value = resultType.getValue("0");
foreach (Values.IValue v in value.Val)
{
if (v != EFSSystem.EmptyValue)
{
IteratorVariable.Value = v;
if (conditionSatisfied(context))
{
AccumulatorVariable.Value = Accumulator.GetValue(context);
}
}
NextIteration();
}
}
EndIteration(context, token);
retVal = AccumulatorVariable.Value;
}
return(retVal);
}
private string format_eurobalise_message(DBElements.DBMessage message)
{
DataDictionary.Types.NameSpace nameSpace = OverallNameSpaceFinder.INSTANCE.findByName(EFSSystem.Dictionaries[0], "Messages");
Types.Structure structureType = (Types.Structure)EFSSystem.findType(nameSpace, "Messages.EUROBALISE.Message");
Values.StructureValue structure = new Values.StructureValue(structureType, nameSpace);
int index = 0;
FillStructure(nameSpace, message.Fields, ref index, structure); // fills the message fields
// then we fill the packets
KeyValuePair<string, Variables.IVariable> subSequencePair = structure.SubVariables.ElementAt(structure.SubVariables.Count - 1);
Variables.IVariable subSequenceVariable = subSequencePair.Value;
Types.Collection collectionType = (Types.Collection)EFSSystem.findType(nameSpace, "Messages.EUROBALISE.Collection1");
Values.ListValue collection = new Values.ListValue(collectionType, new List<Values.IValue>());
Types.Structure subStructure1Type = (Types.Structure)EFSSystem.findType(nameSpace, "Messages.EUROBALISE.SubStructure1");
Values.StructureValue subStructure1 = new Values.StructureValue(subStructure1Type, nameSpace);
Types.Structure packetStructure = (Types.Structure)EFSSystem.findType(nameSpace, "Messages.PACKET.TRACK_TO_TRAIN.Message");
Values.StructureValue packetValue = new Values.StructureValue(packetStructure, nameSpace);
// will contain the list of all packets of the message and then be added to the structure packetValue
ArrayList subStructures = new ArrayList();
foreach (DBElements.DBPacket packet in message.Packets)
{
Tests.DBElements.DBField nidPacketField = packet.Fields[0] as Tests.DBElements.DBField;
if (nidPacketField.Value != 255) // 255 means "end of information"
{
Values.StructureValue subStructure = FindStructure(nidPacketField.Value);
index = 0;
FillStructure(nameSpace, packet.Fields, ref index, subStructure);
subStructures.Add(subStructure);
}
}
// the collection of the message packets is copied to the structure packetValue
int i = 0;
foreach (KeyValuePair<string, Variables.IVariable> pair in packetValue.SubVariables)
{
if (i == subStructures.Count)
{
break;
}
string variableName = pair.Key;
Values.StructureValue structureValue = subStructures[i] as Values.StructureValue;
if (structureValue.Structure.FullName.Contains(variableName))
{
Variables.IVariable variable = pair.Value;
variable.Value = structureValue;
i++;
}
}
subStructure1.SubVariables.ElementAt(0).Value.Value = packetValue;
collection.Val.Add(subStructure1);
subSequenceVariable.Value = collection;
return structure.Name;
}
/// <summary>
/// Provides the value associated to this Expression
/// </summary>
/// <param name="context">The context on which the value must be found</param>
/// <returns></returns>
public override Values.IValue GetValue(InterpretationContext context)
{
Values.ListValue retVal = null;
Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue;
if (value != null)
{
int token = PrepareIteration(context);
retVal = new Values.ListValue((Types.Collection)GetExpressionType(), new List<Values.IValue>());
foreach (Values.IValue v in value.Val)
{
if (v != EFSSystem.EmptyValue)
{
IteratorVariable.Value = v;
if (conditionSatisfied(context))
{
retVal.Val.Add(IteratorExpression.GetValue(context));
}
}
NextIteration();
}
EndIteration(context, token);
}
return retVal;
}
/// <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>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply)
{
Variables.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
Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue;
variable.Value = listValue;
if (listValue != null)
{
Values.ListValue newListValue = new Values.ListValue(listValue);
int i = 0;
foreach (Values.IValue current in newListValue.Val)
{
IteratorVariable.Value = current;
if (conditionSatisfied(context))
{
break;
}
i += 1;
}
if (i < newListValue.Val.Count)
{
Values.IValue value = Value.GetValue(context);
if (value != null)
{
newListValue.Val[i] = value;
Rules.Change change = new Rules.Change(variable, variable.Value, newListValue);
changes.Add(change, apply);
explanation.SubExplanations.Add(new ExplanationPart(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());
}
}
/// <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>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply)
{
Variables.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
Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue;
variable.Value = listValue;
if (listValue != null)
{
Values.IValue value = Value.GetValue(context);
if (value != null)
{
Values.ListValue newListValue = new Values.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)
{
Values.IValue removeValue = ReplaceElement.GetValue(context);
index = newListValue.Val.IndexOf(removeValue);
if (index >= 0)
{
newListValue.Val[index] = value;
}
else
{
Root.AddError("Cannot remove replacing element " + removeValue.Name);
}
}
else
{
Root.AddError("Cannot add new element in list value : list is full");
}
}
Rules.Change change = new Rules.Change(variable, variable.Value, newListValue);
changes.Add(change, apply);
explanation.SubExplanations.Add(new ExplanationPart(Root, change));
}
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>
/// 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>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply)
{
Variables.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
Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue;
variable.Value = listValue;
if (listValue != null)
{
Values.IValue value = Value.GetValue(context);
if (value != null)
{
Values.ListValue newListValue = new Values.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)
{
Values.IValue removeValue = ReplaceElement.GetValue(context);
index = newListValue.Val.IndexOf(removeValue);
if (index >= 0)
{
newListValue.Val[index] = value;
}
else
{
Root.AddError("Cannot remove replacing element " + removeValue.Name);
}
}
else
{
Root.AddError("Cannot add new element in list value : list is full");
}
}
Rules.Change change = new Rules.Change(variable, variable.Value, newListValue);
changes.Add(change, apply);
explanation.SubExplanations.Add(new ExplanationPart(Root, change));
}
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>
/// Provides the value associated to this Expression
/// </summary>
/// <param name="context">The context on which the value must be found</param>
/// <returns></returns>
public override Values.IValue GetValue(InterpretationContext context)
{
List<IValue> elements = new List<IValue>();
foreach (Expression expr in ListElements)
{
IValue val = expr.GetValue(context);
if (val != null)
{
elements.Add(val);
}
else
{
AddError("Cannot evaluate " + expr.ToString());
}
}
Values.IValue retVal = new Values.ListValue(ExpressionType, elements);
return retVal;
}
/// <summary>
/// Provides the value of the function
/// </summary>
/// <param name="instance">the instance on which the function is evaluated</param>
/// <param name="actuals">the actual parameters values</param>
/// <returns>The value for the function application</returns>
public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary<Variables.Actual, Values.IValue> actuals)
{
Values.IValue retVal = null;
int token = context.LocalScope.PushContext();
AssignParameters(context, actuals);
Types.Collection collectionType = (Types.Collection)EFSSystem.findType(OverallNameSpaceFinder.INSTANCE.findByName(EFSSystem.Dictionaries[0], "Kernel.SpeedAndDistanceMonitoring.TargetSupervision"), "Kernel.SpeedAndDistanceMonitoring.TargetSupervision.Targets");
Values.ListValue collection = new Values.ListValue(collectionType, new List<Values.IValue>());
// compute targets from the MRSP
Function function1 = context.findOnStack(Targets1).Value as Functions.Function;
if (function1 != null && !function1.Name.Equals("EMPTY"))
{
Graph graph1 = createGraphForValue(context, function1);
ComputeTargets(graph1.Function, collection);
}
// compute targets from the MA
Function function2 = context.findOnStack(Targets2).Value as Functions.Function;
if (function2 != null && !function2.Name.Equals("EMPTY"))
{
Graph graph2 = createGraphForValue(context, function2);
ComputeTargets(graph2.Function, collection);
}
// compute targets from the SR
Function function3 = context.findOnStack(Targets3).Value as Functions.Function;
if (function3 != null && !function3.Name.Equals("EMPTY"))
{
Graph graph3 = createGraphForValue(context, function3);
ComputeTargets(graph3.Function, collection);
}
context.LocalScope.PopContext(token);
retVal = collection;
return retVal;
}
/// <summary>
/// Fills the given structure with the values provided from the database
/// </summary>
/// <param name="aNameSpace">Namespace of the structure</param>
/// <param name="fields">Fields to be copied into the structure</param>
/// <param name="index">Index (of fields list) from which we have to start copying</param>
/// <param name="aStructure">The structure to be filled</param>
private void FillStructure(Types.NameSpace aNameSpace, ArrayList fields, ref int index, Values.StructureValue aStructure)
{
int j = 0;
for (int i = index; i < fields.Count; i++)
{
Tests.DBElements.DBField field = fields[i] as Tests.DBElements.DBField;
KeyValuePair<string, Variables.IVariable> pair = aStructure.SubVariables.ElementAt(j);
Variables.IVariable variable = pair.Value;
if (variable.Name.StartsWith(field.Variable)) // we use StartsWith and not Equals because we can have N_ITER_1 and N_ITER
{
if (variable.Type is Types.Enum)
{
Types.Enum type = variable.Type as Types.Enum;
foreach (DataDictionary.Constants.EnumValue enumValue in type.Values)
{
int value = Int32.Parse(enumValue.getValue());
if (value == field.Value)
{
variable.Value = enumValue;
j++;
break;
}
}
}
else if (variable.Type is Types.Range)
{
Types.Range type = variable.Type as Types.Range;
variable.Value = new Values.IntValue(type, (decimal)field.Value);
j++;
}
else
{
throw new Exception("Unhandled variable type");
}
if (field.Variable.Equals("N_ITER")) // we have to create a sequence
{
KeyValuePair<string, Variables.IVariable> sequencePair = aStructure.SubVariables.ElementAt(j);
Variables.IVariable sequenceVariable = sequencePair.Value;
Types.Collection collectionType = (Types.Collection)EFSSystem.findType(aNameSpace, sequenceVariable.TypeName);
Values.ListValue sequence = new Values.ListValue(collectionType, new List<Values.IValue>());
for (int k = 0; k < field.Value; k++)
{
Types.Structure structureType = (Types.Structure)EFSSystem.findType(aNameSpace, sequence.CollectionType.Type.FullName);
Values.StructureValue structureValue = new Values.StructureValue(structureType, structureType.NameSpace);
FillStructure(aNameSpace, fields, ref index, structureValue);
sequence.Val.Add(structureValue);
}
sequenceVariable.Value = sequence;
j++;
}
}
// if all the fields of the structue are filled, we terminated
if (j == aStructure.SubVariables.Count)
{
index = i;
break;
}
}
}
/// <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>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply)
{
Variables.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
Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue;
variable.Value = listValue;
if (listValue != null)
{
Values.ListValue newListValue = new Values.ListValue(listValue.CollectionType, new List <Values.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)
{
Values.IValue value = listValue.Val[index];
index = nextIndex(index);
if (value == EFSSystem.EmptyValue)
{
InsertInResult(newListValue, value);
}
else
{
IteratorVariable.Value = value;
if (conditionSatisfied(context))
{
if (Position != PositionEnum.All)
{
break;
}
}
else
{
InsertInResult(newListValue, value);
}
}
}
// Complete the list
while (index >= 0 && index < listValue.Val.Count)
{
Values.IValue value = listValue.Val[index];
InsertInResult(newListValue, value);
index = nextIndex(index);
}
// Fill the gap
while (newListValue.Val.Count < listValue.Val.Count)
{
newListValue.Val.Add(EFSSystem.EmptyValue);
}
Rules.Change change = new Rules.Change(variable, variable.Value, newListValue);
changes.Add(change, apply);
explanation.SubExplanations.Add(new ExplanationPart(Root, change));
context.LocalScope.PopContext(token);
}
}
}
private string format_eurobalise_message(DBElements.DBMessage message)
{
DataDictionary.Types.NameSpace nameSpace = OverallNameSpaceFinder.INSTANCE.findByName(EFSSystem.Dictionaries[0], "Messages");
Types.Structure structureType = (Types.Structure)EFSSystem.findType(nameSpace, "Messages.EUROBALISE.Message");
Values.StructureValue structure = new Values.StructureValue(structureType, nameSpace);
int index = 0;
FillStructure(nameSpace, message.Fields, ref index, structure); // fills the message fields
// then we fill the packets
KeyValuePair <string, Variables.IVariable> subSequencePair = structure.SubVariables.ElementAt(structure.SubVariables.Count - 1);
Variables.IVariable subSequenceVariable = subSequencePair.Value;
Types.Collection collectionType = (Types.Collection)EFSSystem.findType(nameSpace, "Messages.EUROBALISE.Collection1");
Values.ListValue collection = new Values.ListValue(collectionType, new List <Values.IValue>());
Types.Structure subStructure1Type = (Types.Structure)EFSSystem.findType(nameSpace, "Messages.EUROBALISE.SubStructure1");
Values.StructureValue subStructure1 = new Values.StructureValue(subStructure1Type, nameSpace);
Types.Structure packetStructure = (Types.Structure)EFSSystem.findType(nameSpace, "Messages.PACKET.TRACK_TO_TRAIN.Message");
Values.StructureValue packetValue = new Values.StructureValue(packetStructure, nameSpace);
// will contain the list of all packets of the message and then be added to the structure packetValue
ArrayList subStructures = new ArrayList();
foreach (DBElements.DBPacket packet in message.Packets)
{
Tests.DBElements.DBField nidPacketField = packet.Fields[0] as Tests.DBElements.DBField;
if (nidPacketField.Value != 255) // 255 means "end of information"
{
Values.StructureValue subStructure = FindStructure(nidPacketField.Value);
index = 0;
FillStructure(nameSpace, packet.Fields, ref index, subStructure);
subStructures.Add(subStructure);
}
}
// the collection of the message packets is copied to the structure packetValue
int i = 0;
foreach (KeyValuePair <string, Variables.IVariable> pair in packetValue.SubVariables)
{
if (i == subStructures.Count)
{
break;
}
string variableName = pair.Key;
Values.StructureValue structureValue = subStructures[i] as Values.StructureValue;
if (structureValue.Structure.FullName.Contains(variableName))
{
Variables.IVariable variable = pair.Value;
variable.Value = structureValue;
i++;
}
}
subStructure1.SubVariables.ElementAt(0).Value.Value = packetValue;
collection.Val.Add(subStructure1);
subSequenceVariable.Value = collection;
return(structure.Name);
}
/// <summary>
/// Fills the given structure with the values provided from the database
/// </summary>
/// <param name="aNameSpace">Namespace of the structure</param>
/// <param name="fields">Fields to be copied into the structure</param>
/// <param name="index">Index (of fields list) from which we have to start copying</param>
/// <param name="aStructure">The structure to be filled</param>
private void FillStructure(Types.NameSpace aNameSpace, ArrayList fields, ref int index, Values.StructureValue aStructure)
{
int j = 0;
for (int i = index; i < fields.Count; i++)
{
Tests.DBElements.DBField field = fields[i] as Tests.DBElements.DBField;
KeyValuePair <string, Variables.IVariable> pair = aStructure.SubVariables.ElementAt(j);
Variables.IVariable variable = pair.Value;
if (variable.Name.StartsWith(field.Variable)) // we use StartsWith and not Equals because we can have N_ITER_1 and N_ITER
{
if (variable.Type is Types.Enum)
{
Types.Enum type = variable.Type as Types.Enum;
foreach (DataDictionary.Constants.EnumValue enumValue in type.Values)
{
int value = Int32.Parse(enumValue.getValue());
if (value == field.Value)
{
variable.Value = enumValue;
j++;
break;
}
}
}
else if (variable.Type is Types.Range)
{
Types.Range type = variable.Type as Types.Range;
variable.Value = new Values.IntValue(type, (decimal)field.Value);
j++;
}
else
{
throw new Exception("Unhandled variable type");
}
if (field.Variable.Equals("N_ITER")) // we have to create a sequence
{
KeyValuePair <string, Variables.IVariable> sequencePair = aStructure.SubVariables.ElementAt(j);
Variables.IVariable sequenceVariable = sequencePair.Value;
Types.Collection collectionType = (Types.Collection)EFSSystem.findType(aNameSpace, sequenceVariable.TypeName);
Values.ListValue sequence = new Values.ListValue(collectionType, new List <Values.IValue>());
for (int k = 0; k < field.Value; k++)
{
Types.Structure structureType = (Types.Structure)EFSSystem.findType(aNameSpace, sequence.CollectionType.Type.FullName);
Values.StructureValue structureValue = new Values.StructureValue(structureType, structureType.NameSpace);
FillStructure(aNameSpace, fields, ref index, structureValue);
sequence.Val.Add(structureValue);
}
sequenceVariable.Value = sequence;
j++;
}
}
// if all the fields of the structue are filled, we terminated
if (j == aStructure.SubVariables.Count)
{
index = i;
break;
}
}
}
/// <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>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply)
{
Variables.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
Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue;
variable.Value = listValue;
if (listValue != null)
{
Values.ListValue newListValue = new Values.ListValue(listValue.CollectionType, new List<Values.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)
{
Values.IValue value = listValue.Val[index];
index = nextIndex(index);
if (value == EFSSystem.EmptyValue)
{
InsertInResult(newListValue, value);
}
else
{
IteratorVariable.Value = value;
if (conditionSatisfied(context))
{
if (Position != PositionEnum.All)
{
break;
}
}
else
{
InsertInResult(newListValue, value);
}
}
}
// Complete the list
while (index >= 0 && index < listValue.Val.Count)
{
Values.IValue value = listValue.Val[index];
InsertInResult(newListValue, value);
index = nextIndex(index);
}
// Fill the gap
while (newListValue.Val.Count < listValue.Val.Count)
{
newListValue.Val.Add(EFSSystem.EmptyValue);
}
Rules.Change change = new Rules.Change(variable, variable.Value, newListValue);
changes.Add(change, apply);
explanation.SubExplanations.Add(new ExplanationPart(Root, change));
context.LocalScope.PopContext(token);
}
}
}
