/// <summary> /// Checks the statement for semantical errors /// </summary> public override void CheckStatement() { if (ListExpression != null) { ListExpression.CheckExpression(); Collection listExpressionType = ListExpression.GetExpressionType() as Collection; if (listExpressionType == null) { Root.AddError("Target does not references a list"); } } else { Root.AddError("List should be specified"); } if (ConditionExpression != null) { ConditionExpression.CheckExpression(); } if (AppliedStatement != null) { AppliedStatement.CheckStatement(); } else { Root.AddError("Procedure should be specified in the APPLY statement"); } }
public void TestRefactorStructureName() { Dictionary test = CreateDictionary("Test"); NameSpace n1 = CreateNameSpace(test, "N1"); Collection collection = CreateCollection(n1, "Col", "Integer", 10); Variable v = CreateVariable(n1, "V", "Col"); v.setDefaultValue("[]"); RuleCondition rc1 = CreateRuleAndCondition(n1, "Rule1"); Action a1 = CreateAction(rc1, "INSERT 1 IN V"); RuleCondition rc2 = CreateRuleAndCondition(n1, "Rule2"); Action a2 = CreateAction(rc2, "INSERT 2 IN V"); // ReSharper disable once UseObjectOrCollectionInitializer Runner runner = new Runner(false); runner.CheckForCompatibleChanges = true; runner.Cycle(); ListValue listValue = v.Value as ListValue; Assert.IsNotNull(listValue); Assert.AreEqual(2, listValue.Val.Count); Assert.AreEqual(0, a1.Messages.Count); Assert.AreEqual(0, a2.Messages.Count); }
/// <summary> /// Checks the statement for semantical errors /// </summary> public override void CheckStatement() { if (ListExpression != null) { if (ListExpression.Ref is Parameter) { Root.AddError("Cannot change the list value which is a parameter (" + ListExpression + ")"); } Collection targetListType = ListExpression.GetExpressionType() as Collection; if (targetListType != null) { if (Condition != null) { Condition.CheckExpression(); BoolType conditionType = Condition.GetExpressionType() as BoolType; if (conditionType == null) { Root.AddError("Condition does not evaluates to boolean"); } } } else { Root.AddError("Cannot determine type of " + ListExpression); } } else { Root.AddError("List should be specified"); } }
/// <summary> /// Performs the semantic analysis of the statement /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(INamable instance = null) { bool retVal = base.SemanticAnalysis(instance); if (retVal) { // ListExpression if (ListExpression != null) { ListExpression.SemanticAnalysis(instance); StaticUsage.AddUsages(ListExpression.StaticUsage, Usage.ModeEnum.ReadAndWrite); Collection collectionType = ListExpression.GetExpressionType() as Collection; if (collectionType != null) { IteratorVariable.Type = collectionType.Type; } } else { AddError("List expression not provided", RuleChecksEnum.SemanticAnalysisError); } // Condition if (Condition != null) { Condition.SemanticAnalysis(instance); StaticUsage.AddUsages(Condition.StaticUsage, Usage.ModeEnum.Read); } } 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> /// <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; Collection collection = var.Type as Collection; if (range != null && range.convert(value) == null) { AddError("Value " + value + " is outside range", RuleChecksEnum.ExecutionFailed); } else if (collection != null && collection.convert(value) == null) { AddError("Value " + value + " cannot be assigned to variable", RuleChecksEnum.ExecutionFailed); } 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, RuleChecksEnum.ExecutionFailed); } }
public override Collection createCollection() { Collection retVal = new Types.Collection(); _defaultValueSetter.SetDefaultValue(retVal); return(retVal); }
/// <summary> /// Checks the statement for semantical errors /// </summary> public override void CheckStatement() { if (ListExpression != null) { if (ListExpression.Ref is Parameter) { Root.AddError("Cannot change the list value which is a parameter (" + ListExpression + ")"); } Collection targetListType = ListExpression.GetExpressionType() as Collection; if (targetListType != null) { Type elementType = Value.GetExpressionType(); if (elementType != targetListType.Type) { Root.AddError("Inserted element type does not corresponds to list type"); } if (Condition != null) { Condition.CheckExpression(); BoolType conditionType = Condition.GetExpressionType() as BoolType; if (conditionType == null) { Root.AddError("Condition does not evaluates to boolean"); } } else { Root.AddError("Condition should be provided"); } } else { Root.AddError("Cannot determine collection type of " + ListExpression); } } else { Root.AddError("List should be specified"); } if (Value != null) { Value.CheckExpression(); } else { Root.AddError("Value should be specified"); } }
/// <summary> /// Performs the semantic analysis of the expression /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <param name="expectation">Indicates the kind of element we are looking for</param> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(INamable instance, BaseFilter expectation) { bool retVal = base.SemanticAnalysis(instance, expectation); if (retVal) { Type elementType = null; if (ListElements != null) { foreach (Expression expr in ListElements) { expr.SemanticAnalysis(instance, expectation); StaticUsage.AddUsages(expr.StaticUsage, null); Type current = expr.GetExpressionType(); if (elementType == null) { elementType = current; } else { if (!current.Match(elementType)) { AddError("Cannot mix types " + current + " and " + elementType + "in collection", RuleChecksEnum.SemanticAnalysisError); } } } } if (elementType != null) { ExpressionType = (Collection)acceptor.getFactory().createCollection(); ExpressionType.Type = elementType; ExpressionType.Name = "ListOf_" + elementType.FullName; ExpressionType.Enclosing = Root.EFSSystem; ExpressionType.setMaxSize(ListElements.Count); StaticUsage.AddUsage(elementType, Root, Usage.ModeEnum.Type); } else { ExpressionType = new GenericCollection(EfsSystem.Instance); } } return(retVal); }
/// <summary> /// Constructor /// </summary> /// <param name="panel"></param> /// <param name="model"></param> public CollectionModelControl(ModelDiagramPanel panel, Collection model) : base(panel, model) { }
public override Collection createCollection() { Collection retVal = new Types.Collection(); _defaultValueSetter.SetDefaultValue(retVal); return retVal; }
/// <summary> /// Performs the semantic analysis of the statement /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(INamable instance = null) { bool retVal = base.SemanticAnalysis(instance); if (retVal) { // ListExpression Collection collectionType = null; if (ListExpression != null) { ListExpression.SemanticAnalysis(instance); StaticUsage.AddUsages(ListExpression.StaticUsage, Usage.ModeEnum.ReadAndWrite); collectionType = ListExpression.GetExpressionType() as Collection; if (collectionType != null) { IteratorVariable.Type = collectionType.Type; } else { AddError("Cannot determine collection type", RuleChecksEnum.SemanticAnalysisError); } } else { AddError("List expression not provided", RuleChecksEnum.SemanticAnalysisError); } // Value if (Value != null) { Value.SemanticAnalysis(instance); StaticUsage.AddUsages(Value.StaticUsage, Usage.ModeEnum.Read); Type valueType = Value.GetExpressionType(); if (valueType != null) { if (collectionType != null && !valueType.Match(collectionType.Type)) { AddError("Type of " + Value + " does not match collection type " + collectionType, RuleChecksEnum.SemanticAnalysisError); } } else { AddError("Cannot determine type of " + Value, RuleChecksEnum.SemanticAnalysisError); } } else { AddError("Replacement value not provided", RuleChecksEnum.SemanticAnalysisError); } // Condition if (Condition != null) { Condition.SemanticAnalysis(instance); StaticUsage.AddUsages(Condition.StaticUsage, Usage.ModeEnum.Read); } } 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 static void FillStructure(NameSpace aNameSpace, ArrayList fields, ref int currentIndex, StructureValue aStructure) { EfsSystem system = EfsSystem.Instance; int j = 0; while (currentIndex < fields.Count) { DBField field = fields[currentIndex] as DBField; KeyValuePair <string, IVariable> pair = aStructure.SubVariables.ElementAt(j); IVariable variable = pair.Value; // conditional variables can be missing in the database fields, but present in our structure => skip them while (!variable.Name.StartsWith(field.Variable) && j < aStructure.SubVariables.Count - 1) { j++; pair = aStructure.SubVariables.ElementAt(j); variable = pair.Value; } // We use StartsWith and not Equals because we can have N_ITER_1 and N_ITER if (variable.Name.StartsWith(field.Variable)) { if (variable.Type is Enum) { Enum type = variable.Type as Enum; foreach (EnumValue enumValue in type.Values) { int value = int.Parse(enumValue.getValue()); int other = int.Parse(field.Value); if (value == other) { variable.Value = enumValue; j++; break; } } } else if (variable.Type is Range) { Range type = variable.Type as Range; object v = VariableConverter.INSTANCE.Convert(variable.Name, field.Value); string stringValue = v as string; if (stringValue != null) { int intValue; if (int.TryParse(stringValue, out intValue)) { v = intValue; } } variable.Value = new IntValue(type, (int)v); j++; } else if (variable.Type is StringType) { StringType type = variable.Type as StringType; variable.Value = new StringValue(type, field.Value); j++; } else { throw new Exception("Unhandled variable type"); } if (variable.Name.StartsWith("N_ITER")) // we have to create a sequence { KeyValuePair <string, IVariable> sequencePair = aStructure.SubVariables.ElementAt(j); IVariable sequenceVariable = sequencePair.Value; Collection collectionType = (Collection)system.FindType(aNameSpace, sequenceVariable.TypeName); ListValue sequence = new ListValue(collectionType, new List <IValue>()); int value = int.Parse(field.Value); for (int k = 0; k < value; k++) { currentIndex++; Structure structureType = (Structure)system.FindType(aNameSpace, sequence.CollectionType.Type.FullName); StructureValue structureValue = new StructureValue(structureType); FillStructure(aNameSpace, fields, ref currentIndex, structureValue); sequence.Val.Add(structureValue); } sequenceVariable.Value = sequence; j++; } } // Special case for X_TEXT if ("Sequence1".Equals(variable.Name) && "X_TEXT".Equals(field.Variable)) { KeyValuePair <string, IVariable> sequencePair = aStructure.SubVariables.ElementAt(j); IVariable sequenceVariable = sequencePair.Value; Collection collectionType = (Collection)system.FindType(aNameSpace, sequenceVariable.TypeName); ListValue sequence = new ListValue(collectionType, new List <IValue>()); while (field != null && "X_TEXT".Equals(field.Variable)) { if (string.IsNullOrEmpty(field.Value)) { field.Value = " "; } Structure structureType = (Structure)system.FindType(aNameSpace, sequence.CollectionType.Type.FullName); StructureValue structureValue = new StructureValue(structureType); FillStructure(aNameSpace, fields, ref currentIndex, structureValue); sequence.Val.Add(structureValue); currentIndex += 1; if (currentIndex < fields.Count) { field = fields[currentIndex] as DBField; } else { field = null; } } sequenceVariable.Value = sequence; j++; } // if all the fields of the structue are filled, we terminated if (j == aStructure.SubVariables.Count) { break; } else { currentIndex += 1; } } }
private static ListValue get_message_packets(DBMessage message, NameSpace nameSpace, EfsSystem system) { ListValue retVal; Collection collectionType = (Collection)system.FindType(nameSpace, "Collection1"); Structure subStructure1Type = (Structure)system.FindType(nameSpace, "SubStructure1"); string packetLocation = "Messages.PACKET."; if (nameSpace.FullName.Contains("TRAIN_TO_TRACK")) { packetLocation += "TRAIN_TO_TRACK.Message"; } else { packetLocation += "TRACK_TO_TRAIN.Message"; } Structure packetStructureType = (Structure)system.FindType(nameSpace, packetLocation); retVal = new ListValue(collectionType, new List <IValue>()); foreach (DBPacket packet in message.Packets) { DBField nidPacketField = packet.Fields[0] as DBField; if (nidPacketField.Value != "255") // 255 means "end of information" { int packetId = int.Parse(nidPacketField.Value); StructureValue subStructure = FindStructure(packetId); int currentIndex = 0; FillStructure(nameSpace, packet.Fields, ref currentIndex, subStructure); StructureValue subStructure1 = new StructureValue(subStructure1Type); // For Balise messages, we have an extra level of information to fill, so here we define StructureVal in one of two ways StructureValue structureVal; if (subStructure1.SubVariables.Count == 1 && subStructure1.SubVariables.ContainsKey("TRACK_TO_TRAIN")) { // For a Balise message, we have an extra level of structures for TRACK_TO_TRAIN structureVal = new StructureValue(packetStructureType); subStructure1.SubVariables["TRACK_TO_TRAIN"].Value = structureVal; } else { // For RBC, the collection directly holds the different packet types structureVal = subStructure1; } // Find the right variable in the packet to add the structure we just created foreach (KeyValuePair <string, IVariable> pair in structureVal.SubVariables) { string variableName = pair.Key; if (subStructure.Structure.FullName.Contains(variableName)) { pair.Value.Value = subStructure; retVal.Val.Add(subStructure1); break; } } } } return(retVal); }
/// <summary> /// Performs the semantic analysis of the expression /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <param name="expectation">Indicates the kind of element we are looking for</param> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(INamable instance, BaseFilter expectation) { bool retVal = base.SemanticAnalysis(instance, expectation); if (retVal) { Type elementType = null; if (ListElements != null) { foreach (Expression expr in ListElements) { expr.SemanticAnalysis(instance, expectation); StaticUsage.AddUsages(expr.StaticUsage, null); Type current = expr.GetExpressionType(); if (elementType == null) { elementType = current; } else { if (!current.Match(elementType)) { AddError("Cannot mix types " + current + " and " + elementType + "in collection"); } } } } if (elementType != null) { ExpressionType = (Collection) acceptor.getFactory().createCollection(); ExpressionType.Type = elementType; ExpressionType.Name = "ListOf_" + elementType.FullName; ExpressionType.Enclosing = Root.EFSSystem; ExpressionType.setMaxSize(ListElements.Count); StaticUsage.AddUsage(elementType, Root, Usage.ModeEnum.Type); } else { ExpressionType = new GenericCollection(EfsSystem.Instance); } } return retVal; }
/// <summary> /// Constructor /// </summary> /// <param name="source"></param> /// <param name="target"></param> /// <param name="model"></param> public CollectionTypeArrow(Collection source, Type target, Collection model) : base(source, target, "of " + source.getMaxSize(), model) { }