/// <summary> /// Converts the value provided as an EFS value /// </summary> /// <returns></returns> public override IValue ConvertBack(Type type) { IValue retVal = type.getValue(Value.ToString()); CheckReturnValue(retVal, type); return retVal; }
/// <summary> /// Gets the reference of the designator if it covers the position given /// </summary> /// <param name="designator"></param> protected override void VisitDesignator(Designator designator) { if (ShouldCheck(designator)) { Type type = designator.Ref as Type; if (Context == null && type != null) { Context = type; } ITypedElement element = designator.Ref as ITypedElement; if (Context == null && element != null) { Context = element; } ICallable callable = designator.Ref as ICallable; if (Context == null && callable != null) { Context = callable; } NameSpace nameSpace = designator.Ref as NameSpace; if (Context == null && nameSpace != null) { Context = nameSpace; } } }
private void CheckActualAgainstFormal(Dictionary <string, Expression> actuals, Expression expression, Parameter parameter) { actuals[parameter.Name] = expression; expression.CheckExpression(); Type argumentType = expression.GetExpressionType(); if (argumentType == null) { AddError("Cannot evaluate argument type for argument " + expression, RuleChecksEnum.SemanticAnalysisError); } else { if (parameter.Type == null) { AddError("Cannot evaluate formal parameter type for " + parameter.Name, RuleChecksEnum.SemanticAnalysisError); } else { if (!parameter.Type.Match(argumentType)) { AddError("Invalid argument " + expression + " type, expected " + parameter.Type.FullName + ", actual " + argumentType.FullName, RuleChecksEnum.SemanticAnalysisError); } } } }
/// <summary> /// Provides the callable that is called by this expression /// </summary> /// <param name="context"></param> /// <param name="explain"></param> /// <returns></returns> public override ICallable GetCalled(InterpretationContext context, ExplanationPart explain) { ICallable retVal; Call calledFunction = Called as Call; if (calledFunction != null) { retVal = Called.GetValue(context, explain) as ICallable; } else { retVal = Called.GetCalled(context, explain); if (retVal == null) { Type type = Called.GetExpressionType(); if (type != null) { retVal = type.CastFunction; } if (retVal == null) { retVal = Called.GetValue(context, explain) as ICallable; } } } return(retVal); }
/// <summary> /// Checks an expression associated to a model element /// </summary> /// <param name="model">The model element on which the expression is defined</param> /// <param name="expression">The expression to check</param> /// <returns>the expression parse tree</returns> private Interpreter.Expression checkExpression(ModelElement model, string expression) { Interpreter.Expression retVal = null; Interpreter.Parser parser = model.EFSSystem.Parser; try { retVal = parser.Expression(model, expression); if (retVal != null) { retVal.checkExpression(); Types.Type type = retVal.GetExpressionType(); if (type == null) { model.AddError("Cannot determine expression type (5) for " + retVal.ToString()); } } else { model.AddError("Cannot parse expression"); } } catch (Exception exception) { model.AddException(exception); } return(retVal); }
/// <summary> /// Applied to all nodes of the tree /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(Generated.Namable obj, bool visitSubNodes) { Namable namable = (Namable)obj; if (obj is Types.ITypedElement) { Types.ITypedElement typedElement = obj as Types.ITypedElement; Types.Type type = typedElement.Type; if (type == null) { namable.AddError("Cannot find type " + typedElement.TypeName); } else if (!(typedElement is Parameter) && !(type is Types.StateMachine)) { Types.ITypedElement enclosingTypedElement = Utils.EnclosingFinder <Types.ITypedElement> .find(typedElement); while (enclosingTypedElement != null) { if (enclosingTypedElement.Type == type) { namable.AddError("Recursive types are not allowed for " + type.Name); enclosingTypedElement = null; } else { enclosingTypedElement = Utils.EnclosingFinder <Types.ITypedElement> .find(enclosingTypedElement); } } } } base.visit(obj, visitSubNodes); }
public override void visit(Generated.Case obj, bool visitSubNodes) { Functions.Case cas = obj as Functions.Case; try { Interpreter.Expression expression = cas.Expression; if (expression != null) { expression.checkExpression(); Types.Type expressionType = cas.Expression.GetExpressionType(); if (expressionType != null) { if (!cas.EnclosingFunction.ReturnType.Match(expressionType)) { cas.AddError("Expression type (" + expressionType.FullName + ") does not match function return type (" + cas.EnclosingFunction.ReturnType.Name + ")"); } } else { cas.AddError("Cannot determine expression type (6) for " + cas.Expression.ToString()); } } else { cas.AddError("Cannot evaluate expression " + cas.ExpressionText); } } catch (Exception e) { cas.AddException(e); } base.visit(obj, visitSubNodes); }
/// <summary> /// Converts the value provided as an EFS value /// </summary> /// <returns></returns> public override IValue ConvertBack(Type type) { IValue retVal = type.getValue(Name); CheckReturnValue(retVal, type); return retVal; }
public override void visit(Generated.Type obj, bool visitSubNodes) { Types.Type type = obj as Types.Type; if (type != null) { if (type is Types.StateMachine) { // Ignore state machines } else { if (!(type is Types.Structure) && !(type is Functions.Function)) { if (Utils.Utils.isEmpty(type.getDefault())) { type.AddError("Types should define their default value"); } else { if (type.DefaultValue == null) { type.AddError("Invalid default value"); } } if (type is Types.Range) { Types.Range range = type as Types.Range; if (range.getPrecision() == Generated.acceptor.PrecisionEnum.aIntegerPrecision && range.Default.IndexOf('.') > 0 || range.getPrecision() == Generated.acceptor.PrecisionEnum.aDoublePrecision && range.Default.IndexOf('.') <= 0) { type.AddError("Default value's precision does not correspond to the type's precision"); } foreach (Constants.EnumValue specValue in range.SpecialValues) { String value = specValue.getValue(); if (range.getPrecision() == Generated.acceptor.PrecisionEnum.aDoublePrecision && value.IndexOf('.') <= 0 || range.getPrecision() == Generated.acceptor.PrecisionEnum.aIntegerPrecision && value.IndexOf('.') > 0) { type.AddError("Precision of the special value + " + specValue.Name + " does not correspond to the type's precision"); } } } } if (declaredTypes.ContainsKey(type.FullName)) { declaredTypes[type.Name].AddError(TYPE_DECLARED_SEVERAL_TIMES); type.AddError(TYPE_DECLARED_SEVERAL_TIMES); } else { declaredTypes[type.Name] = type; } } } base.visit(obj, visitSubNodes); }
/// <summary> /// Checks the return value for a conversion to EFS type /// </summary> /// <param name="value"></param> /// <param name="type"></param> public void CheckReturnValue(IValue value, Type type) { if (value == null) { throw new FaultException<EFSServiceFault>( new EFSServiceFault("Cannot convert to EFS value " + DisplayValue() + " for type " + type.FullName)); } }
GetStandardValues(ITypeDescriptorContext context) { ItemEditor editor = (ItemEditor)context.Instance; DataDictionary.Types.NameSpace nameSpace = editor.Item.NameSpace; DataDictionary.Types.Type type = editor.Item.Type; return(GetValues(nameSpace, type)); }
/// <summary> /// Converts the value provided as an EFS value /// </summary> /// <returns></returns> public override IValue ConvertBack(Type type) { IValue retVal = null; StringType stringType = type as StringType; if (stringType != null) { retVal = new DataDictionary.Values.StringValue(stringType, Value); } CheckReturnValue(retVal, type); 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"); } }
public override void visit(BaseModelElement obj, bool visitSubNodes) { IExpressionable expressionable = obj as IExpressionable; if (expressionable != null) { // In case of rebuild, cleans the previously constructed tree if (Options.Rebuild) { expressionable.CleanCompilation(); } // Ensures that the expressionable is compiled expressionable.Compile(); Structure structure = expressionable as Structure; if (structure != null) { if (structure != structure.UnifiedStructure) { visit(structure.UnifiedStructure, visitSubNodes); } } StateMachine stateMachine = expressionable as StateMachine; if (stateMachine != null) { if (stateMachine != stateMachine.UnifiedStateMachine) { visit(stateMachine.UnifiedStateMachine, visitSubNodes); } } } ITypedElement typedElement = obj as ITypedElement; if (typedElement != null) { // Ensures that the type of the corresponding element is cached Type type = typedElement.Type; } Function function = obj as Function; if (function != null) { Type returnType = function.ReturnType; } base.visit(obj, visitSubNodes); }
/// <summary> /// Provides the type of this expression /// </summary> /// <returns></returns> public override Type GetExpressionType() { Type retVal = Ref as Type; if (retVal == null) { ITypedElement typedElement = Ref as ITypedElement; if (typedElement != null) { retVal = typedElement.Type; } } return(retVal); }
/// <summary> /// Provides the ICallable that is statically defined /// </summary> public virtual ICallable GetStaticCallable() { ICallable retVal = Ref as ICallable; if (retVal == null) { Type type = Ref as Type; if (type != null) { retVal = type.CastFunction; } } 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", 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> /// Refactors an element which has a type /// </summary> /// <param name="element">The element that has been modified</param> /// <param name="user">The user which references this type</param> private static void RefactorTypedElement(ModelElement element, ITypedElement user) { if (user != null) { try { ModelElement enclosing = EnclosingFinder <NameSpace> .find(user, true); Function function = user as Function; if (function != null) { bool refactor = false; Type current = function.ReturnType; while (current != null && !refactor) { refactor = current == element; current = EnclosingFinder <Type> .find(current); } if (refactor) { function.TypeName = function.ReturnType.ReferenceName(enclosing); } } else { bool refactor = false; Type current = user.Type; while (current != null && !refactor) { refactor = current == element; current = EnclosingFinder <Type> .find(current); } if (refactor) { user.TypeName = user.Type.ReferenceName(enclosing); } } } catch (Exception e) { ((ModelElement)user).AddError("Cannot refactor this element, reason = " + e.Message); } } }
/// <summary> /// Provides the type of this expression /// </summary> /// <returns></returns> public override Type GetExpressionType() { Type retVal = null; Function function = Called.GetStaticCallable() as Function; if (function != null) { retVal = function.ReturnType; } else { AddError("Cannot get type of function call " + ToString(), RuleChecksEnum.SemanticAnalysisError); } return(retVal); }
/// <summary> /// Provides the type of this expression /// </summary> /// <returns></returns> public override Type GetExpressionType() { Type retVal = null; if (Term != null) { retVal = Term.GetExpressionType(); } else if (Expression != null) { if (Not.Equals(UnaryOp)) { Type type = Expression.GetExpressionType(); if (type is BoolType) { retVal = type; } else { AddError("Cannot apply NOT on non boolean types", RuleChecksEnum.SemanticAnalysisError); } } else if (Minus.Equals(UnaryOp)) { Type type = Expression.GetExpressionType(); if (type == EfsSystem.Instance.IntegerType || type == EfsSystem.Instance.DoubleType || type is Range) { retVal = type; } else { AddError("Cannot apply - on non integral types", RuleChecksEnum.SemanticAnalysisError); } } else { retVal = Expression.GetExpressionType(); } } return(retVal); }
/// <summary> /// Checks the expression and appends errors to the root tree node when inconsistencies are found /// </summary> public override void CheckExpression() { base.CheckExpression(); InitialValue.CheckExpression(); Type initialValueType = InitialValue.GetExpressionType(); if (initialValueType != null) { Expression.CheckExpression(); Type expressionType = Expression.GetExpressionType(); if (expressionType != null) { if (expressionType != initialValueType) { AddError("Expression " + Expression + " has not the same type (" + expressionType.FullName + " than initial value " + InitialValue + " type " + initialValueType.FullName, RuleChecksEnum.SemanticAnalysisError); } } else { AddError("Cannot determine type of expression " + Expression, RuleChecksEnum.SemanticAnalysisError); } Type conditionType = Condition.GetExpressionType(); if (conditionType != null) { if (!(conditionType is BoolType)) { AddError("Condition " + Condition + " does not evaluate to a boolean", RuleChecksEnum.SemanticAnalysisError); } } else { AddError("Cannot determine type of condition " + Condition, RuleChecksEnum.SyntaxError); } } else { AddError("Cannot determine type of the initial value " + InitialValue, RuleChecksEnum.SemanticAnalysisError); } }
/// <summary> /// Converts the value provided as an EFS value /// </summary> /// <returns></returns> public override IValue ConvertBack(Type type) { IValue retVal = null; Collection collectionType = type as Collection; if (collectionType != null) { List<IValue> values = new List<IValue>(); foreach (Value item in Value) { values.Add(item.ConvertBack(collectionType.Type)); } retVal = new DataDictionary.Values.ListValue(collectionType, values); } CheckReturnValue(retVal, type); return retVal; }
public override void visit(Generated.Frame obj, bool visitSubNodes) { Tests.Frame frame = (Tests.Frame)obj; if (frame != null) { checkExpression(frame, frame.getCycleDuration()); Types.Type type = frame.CycleDuration.GetExpressionType(); if (type != null) { if (!frame.EFSSystem.DoubleType.Match(type)) { frame.AddError("Cycle duration should be compatible with the Time type"); } } } base.visit(obj, visitSubNodes); }
/// <summary> /// Provides the type associated to the name /// </summary> /// <param name="nameSpace"></param> /// <param name="name"></param> /// <returns></returns> public Types.Type findType(Types.NameSpace nameSpace, string name) { Types.Type retVal = null; if (name != null) { foreach (Dictionary dictionary in Dictionaries) { retVal = dictionary.findType(nameSpace, name); if (retVal != null) { break; } } if (retVal == null) { PredefinedTypes.TryGetValue(name, out retVal); } } return(retVal); }
/// <summary> /// Checks the statement for semantical errors /// </summary> public override void CheckStatement() { VariableIdentification.CheckExpression(); if (VariableIdentification.Ref is Parameter) { Root.AddError("Cannot assign a value to a parameter (" + VariableIdentification + ")"); } if (VariableIdentification.Ref == null) { Root.AddError("Cannot assign a value to " + VariableIdentification); } Type targetType = VariableIdentification.GetExpressionType(); if (targetType == null) { Root.AddError("Cannot determine type of target " + VariableIdentification); } else if (Expression != null) { Expression.CheckExpression(); Type type = Expression.GetExpressionType(); if (type != null) { if (!targetType.Match(type)) { UnaryExpression unaryExpression = Expression as UnaryExpression; if (unaryExpression != null && unaryExpression.Term.LiteralValue != null) { Root.AddError("Expression " + Expression + " does not fit in variable " + VariableIdentification); } else { Root.AddError("Expression [" + Expression + "] type (" + type.FullName + ") does not match variable [" + VariableIdentification + "] type (" + targetType.FullName + ")"); } } else { Range rangeType = targetType as Range; if (rangeType != null) { IValue value = Expression.Ref as IValue; if (value != null) { if (rangeType.convert(value) == null) { Root.AddError("Cannot set " + value.LiteralName + " in variable of type " + rangeType.Name); } } } } if (Expression.Ref == EfsSystem.Instance.EmptyValue) { if (targetType is Collection) { Root.AddError("Assignation of " + Expression.Ref.Name + " cannot be performed on variables of type collection. Use [] instead."); } } } else { Root.AddError("Cannot determine expression type (3) for " + Expression); } } else { Root.AddError("Invalid expression in assignment"); } // Check that the incoming variables are not modified if (EnclosingFinder <DataDictionary.Types.NameSpace> .find(Root, true) != null) { IVariable variable = VariableIdentification.Ref as IVariable; if (variable != null && variable.Mode == acceptor.VariableModeEnumType.aIncoming) { Root.AddError("An incoming variable cannot be written"); } } }
/// <summary> /// Constructor /// </summary> /// <param name="source"></param> /// <param name="target"></param> /// <param name="model"></param> public ElementReferenceArrow(Structure source, Type target, StructureElement model) : base(source, target, model.Name, model) { }
/// <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) { }
/// <summary> /// Combines two types to create a new one /// </summary> /// <param name="right"></param> /// <param name="Operator"></param> /// <returns></returns> public override Type CombineType(Type right, BinaryExpression.Operator Operator) { Type retVal = null; Function function = right as Function; if (function != null) { if (ReturnType == function.ReturnType) { if (FormalParameters.Count >= function.FormalParameters.Count) { retVal = this; } else { retVal = function; } } else { AddError("Cannot combine types " + ReturnType.Name + " and " + function.ReturnType.Name); } } else if (right.IsDouble()) { retVal = this; } else { AddError("Cannot combine types " + ReturnType.Name + " and " + right.Name); } return retVal; }
/// <summary> /// Indicates that binary operation is valid for this type and the other type /// </summary> /// <param name="operation"></param> /// <param name="otherType"></param> /// <returns></returns> public override bool ValidBinaryOperation(BinaryExpression.Operator operation, Type otherType) { bool retVal = false; if (ReturnType != null) { Function otherFunction = otherType as Function; if (otherFunction != null) { if (otherFunction.ReturnType != null) { retVal = ReturnType.ValidBinaryOperation(operation, otherFunction.ReturnType); } } else if (ReturnType != this) { retVal = ReturnType.ValidBinaryOperation(operation, otherType); } else { retVal = true; } } return retVal; }
/// <summary> /// Provides the type associated to the name /// </summary> /// <param name="nameSpace">the namespace in which the name should be found</param> /// <param name="name"></param> /// <returns></returns> public Types.Type findType(Types.NameSpace nameSpace, string name) { Types.Type retVal = null; if (name != null) { if (nameSpace != null) { if (!cache.ContainsKey(nameSpace)) { cache[nameSpace] = new Dictionary <string, Types.Type>(); } Dictionary <string, Types.Type> subCache = cache[nameSpace]; if (!subCache.ContainsKey(name)) { Types.Type tmp = null; if (!Utils.Utils.isEmpty(name)) { tmp = nameSpace.findTypeByName(name); if (tmp == null) { if (DefinedTypes.ContainsKey(name)) { tmp = DefinedTypes[name]; } } if (tmp == null && DefinedTypes.ContainsKey("Default." + name)) { tmp = DefinedTypes["Default." + name]; } } if (tmp == null) { Log.Error("Cannot find type named " + name); } subCache[name] = tmp; } retVal = subCache[name]; } else { if (DefinedTypes.ContainsKey(name)) { retVal = DefinedTypes[name]; } else if (DefinedTypes.ContainsKey("Default." + name)) { retVal = DefinedTypes["Default." + name]; } } } return(retVal); }
/// <summary> /// Constructor /// </summary> /// <param name="panel"></param> /// <param name="model"></param> protected TypeModelControl(ModelDiagramPanel panel, Type model) : base(panel, model) { NormalColor = Color.LightSteelBlue; }
/// <summary> /// Constructor /// </summary> /// <param name="source"></param> /// <param name="target"></param> /// <param name="model"></param> public VariableTypeArrow(Variable source, Type target, Variable model) : base(source, target, "type", model) { }
/// <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> /// Indicates that the other type can be placed in variables of this type /// </summary> /// <param name="otherType"></param> /// <returns></returns> public override bool Match(Type otherType) { bool retVal = base.Match(otherType); StateMachine current = otherType as StateMachine; while (current != null && !retVal) { retVal = this == current; current = current.EnclosingStateMachine; } return retVal; }
/// <summary> /// Indicates that the other type may be placed in this /// </summary> /// <param name="otherType"></param> /// <returns></returns> public override bool Match(Type otherType) { bool retVal = base.Match(otherType); if (!retVal && otherType is Enum) { Enum current = (Enum)otherType; while (current != null && !retVal) { retVal = current == this; current = current.EnclosingEnum; } } return retVal; }
public override void ClearCache() { base.ClearCache(); // Remove the cached type _type = null; }
/// <summary> /// Constructor /// </summary> /// <param name="type"></param> protected Value(Type type) { Type = type; }
public StandardValuesCollection GetValues(NameSpace nameSpace, Type type) { FinderRepository.INSTANCE.ClearCache(); List<string> retVal = new List<string>(); if (type != null) { string prefix = type.FullName; if (nameSpace == type.NameSpace && nameSpace != null) { prefix = prefix.Substring(nameSpace.FullName.Length + 1); } OverallValueFinder.INSTANCE.findAllValueNames(prefix, type, false, retVal); retVal.Sort(); } return new StandardValuesCollection(retVal); }
/// <summary> /// Constructor /// </summary> /// <param name="root"></param> /// <param name="log"></param> /// <param name="value"></param> /// <param name="type"></param> /// <param name="start">The start character for this expression in the original string</param> /// <param name="end">The end character for this expression in the original string</param> public NumberExpression(ModelElement root, ModelElement log, string value, Type type, int start, int end) : base(root, log, start, end) { Image = value; Type = type; }
/// <summary> /// Converts the value provided as an EFS value /// </summary> /// <param name="type">the value expected type</param> /// <returns></returns> public abstract IValue ConvertBack(Type type);
/// <summary> /// Constructor /// </summary> /// <param name="root"></param> /// <param name="log"></param> /// <param name="value"></param> /// <param name="type"></param> /// <param name="parsingData">Additional information about the parsing process</param> public NumberExpression(ModelElement root, ModelElement log, string value, Type type, ParsingData parsingData) : base(root, log, parsingData) { Image = value; Type = type; }