/// <summary>
/// Creates a function which gets the field named "fieldName" from one of the subfield of the structure provided as parameter
/// </summary>
/// <param name="nameSpace">The namespace in which the function should be created</param>
/// <param name="structure">The structure which should be looked for</param>
/// <param name="subField">The name of the subfield to look for</param>
/// <param name="returnType">The function return type</param>
private void AppendGetFunction(DataDictionary.Types.NameSpace nameSpace, DataDictionary.Types.Structure structure, string subField, string returnType)
{
DataDictionary.Functions.Function getFunction = (DataDictionary.Functions.Function)DataDictionary.Generated.acceptor.getFactory().createFunction();
getFunction.Name = subField;
getFunction.setTypeName(returnType);
DataDictionary.Parameter param = (DataDictionary.Parameter)DataDictionary.Generated.acceptor.getFactory().createParameter();
param.Name = "msg";
param.TypeName = structure.Name;
getFunction.appendParameters(param);
foreach (DataDictionary.Types.StructureElement element in structure.Elements)
{
DataDictionary.Functions.Case cas = (DataDictionary.Functions.Case)DataDictionary.Generated.acceptor.getFactory().createCase();
DataDictionary.Rules.PreCondition condition = (DataDictionary.Rules.PreCondition)DataDictionary.Generated.acceptor.getFactory().createPreCondition();
condition.Expression = "msg." + element.Name + " != EMPTY";
cas.appendPreConditions(condition);
cas.ExpressionText = "msg." + element.Name + "." + subField;
getFunction.appendCases(cas);
}
nameSpace.appendFunctions(getFunction);
}
public void AddPreConditionHandler(object sender, EventArgs args)
{
PreCondition preCondition = (PreCondition)acceptor.getFactory().createPreCondition();
preCondition.Condition = "<empty>";
Item.appendPreConditions(preCondition);
}
/// <summary>
/// Creates a precondition in the enclosing function case
/// </summary>
/// <param name="enclosing"></param>
/// <param name="name"></param>
/// <returns></returns>
protected PreCondition CreatePreCondition(Case enclosing, string name)
{
PreCondition retVal = (PreCondition)Factory.createPreCondition();
enclosing.appendPreConditions(retVal);
retVal.ExpressionText = name;
return(retVal);
}
/// <summary>
/// Creates a precondition in the enclosing rule condition
/// </summary>
/// <param name="enclosing"></param>
/// <param name="expression"></param>
/// <returns></returns>
protected PreCondition CreatePreCondition(RuleCondition enclosing, string expression)
{
PreCondition retVal = (PreCondition)Factory.createPreCondition();
enclosing.appendPreConditions(retVal);
retVal.ExpressionText = expression;
return(retVal);
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(IModelElement element)
{
{
PreCondition item = element as PreCondition;
if (item != null)
{
appendPreConditions(item);
}
}
}
/// <summary>
/// Adds a preCondition to the modelized item
/// </summary>
/// <param name="preCondition"></param>
/// <returns></returns>
public override PreConditionTreeNode AddPreCondition(DataDictionary.Rules.PreCondition preCondition)
{
PreConditionTreeNode retVal = new PreConditionTreeNode(preCondition);
Item.appendPreConditions(preCondition);
Nodes.Add(retVal);
SortSubNodes();
Item.setVerified(false);
return(retVal);
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
if (SourceNode is DataDictionaryView.PreConditionTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding pre-condition ?", "Move pre-condition", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
DataDictionaryView.PreConditionTreeNode preConditionTreeNode = (DataDictionaryView.PreConditionTreeNode)SourceNode;
DataDictionary.Rules.PreCondition preCondition = preConditionTreeNode.Item;
preConditionTreeNode.Delete();
AddPreCondition(preCondition);
}
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
base.AcceptDrop(SourceNode);
if (SourceNode is PreConditionTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding function ?", "Move action", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
PreConditionTreeNode node = SourceNode as PreConditionTreeNode;
DataDictionary.Rules.PreCondition preCondition = node.Item;
node.Delete();
AddPreCondition(preCondition);
}
}
}
/// <summary>
/// Creates a case in the enclosing function
/// </summary>
/// <param name="function"></param>
/// <param name="name"></param>
/// <param name="expression"></param>
/// <param name="preConditionExpression"></param>
/// <returns></returns>
protected Case CreateCase(Function function, string name, string expression, string preConditionExpression = "")
{
Case retVal = (Case)Factory.createCase();
function.appendCases(retVal);
retVal.Name = name;
retVal.ExpressionText = expression;
if (preConditionExpression != "")
{
PreCondition preCondition = (PreCondition)Factory.createPreCondition();
preCondition.ExpressionText = preConditionExpression;
retVal.appendPreConditions(preCondition);
}
return(retVal);
}
/// <summary>
/// Evaluates the boundaries associated to a specific preCondition
/// </summary>
/// <param name="context">The context used to evaluate the precondition and segment value</param>
/// <param name="preCondition">The precondition to evaluate the range</param>
/// <param name="parameter"></param>
/// <param name="explain"></param>
/// <returns></returns>
private List<ISegment> EvaluateBoundaries(InterpretationContext context, PreCondition preCondition,
Parameter parameter, ExplanationPart explain)
{
List<ISegment> retVal = new List<ISegment>();
if (parameter != null)
{
BinaryExpression expression = preCondition.Expression as BinaryExpression;
if (expression != null && expression.Left != null && expression.Right != null && ExpressionBasedOnParameter(parameter, expression))
{
IValue val;
if (expression.Right.Ref == parameter)
{
// Expression like xxx <= Parameter
val = expression.Left.GetValue(context, explain);
switch (expression.Operation)
{
case BinaryExpression.Operator.Less:
case BinaryExpression.Operator.LessOrEqual:
retVal.Add(new Graph.Segment(GetDoubleValue(val), double.MaxValue,
new Graph.Segment.Curve()));
break;
case BinaryExpression.Operator.Greater:
case BinaryExpression.Operator.GreaterOrEqual:
retVal.Add(new Graph.Segment(0, GetDoubleValue(val), new Graph.Segment.Curve()));
break;
default:
throw new Exception("Invalid comparison operator while evaluating Graph of function");
}
}
else
{
if (expression.Left.Ref == parameter)
{
// Expression like Parameter <= xxx
val = expression.Right.GetValue(context, explain);
switch (expression.Operation)
{
case BinaryExpression.Operator.Less:
case BinaryExpression.Operator.LessOrEqual:
retVal.Add(new Graph.Segment(0, GetDoubleValue(val), new Graph.Segment.Curve()));
break;
case BinaryExpression.Operator.Greater:
case BinaryExpression.Operator.GreaterOrEqual:
retVal.Add(new Graph.Segment(GetDoubleValue(val), double.MaxValue,
new Graph.Segment.Curve()));
break;
default:
throw new Exception("Invalid comparison operator while evaluating Graph of function");
}
}
else
{
if (FunctionCallOnParameter(expression.Right, parameter))
{
Graph graph = expression.Right.CreateGraph(context, parameter, explain);
if (graph != null)
{
// Expression like xxx <= f(Parameter)
val = expression.Left.GetValue(context, explain);
retVal = graph.GetSegments(BinaryExpression.Inverse(expression.Operation),
GetDoubleValue(val));
}
else
{
AddError("Cannot create graph for " + expression.Right);
}
}
else
{
Graph graph = expression.Left.CreateGraph(context, parameter, explain);
if (graph != null)
{
// Expression like f(Parameter) <= xxx
val = expression.Right.GetValue(context, explain);
retVal = graph.GetSegments(expression.Operation, GetDoubleValue(val));
}
else
{
throw new Exception("Cannot evaluate bounds of segment");
}
}
}
}
}
else
{
if (!ExpressionBasedOnPlaceHolder(context, expression))
{
BoolValue value = preCondition.Expression.GetValue(context, explain) as BoolValue;
if (value != null && value.Val)
{
retVal.Add(new Graph.Segment(0, double.MaxValue, new Graph.Segment.Curve()));
}
}
}
}
else
{
AddError("Parameter is null");
}
return retVal;
}
public void AddPreConditionHandler(object sender, EventArgs args)
{
DataDictionary.Rules.PreCondition preCondition = (DataDictionary.Rules.PreCondition)DataDictionary.Generated.acceptor.getFactory().createPreCondition();
preCondition.Condition = "<empty>";
PreConditions.AddPreCondition(preCondition);
}
/// <summary>
/// Adds a preCondition to the modelized item
/// </summary>
/// <param name="preCondition"></param>
public void AddPreCondition(DataDictionary.Rules.PreCondition preCondition)
{
Item.appendPreConditions(preCondition);
Nodes.Add(new DataDictionaryView.PreConditionTreeNode(preCondition));
SortSubNodes();
}
/// <summary>
/// Adds a precondition
/// </summary>
/// <param name="preCondition"></param>
/// <returns></returns>
public virtual PreConditionTreeNode AddPreCondition(DataDictionary.Rules.PreCondition preCondition)
{
return(PreConditions.AddPreCondition(preCondition));
}
