/// <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); } } }