public static ISet <IVariable> FindAllVariables(IRelationDomain domain, ISet <IVariable> bindedVariables)
{
ISet <IVariable> result = new HashSet <IVariable>();
result.Add(domain.RootVariable);
bindedVariables.Add(domain.RootVariable);
foreach (IPropertyTemplateItem prop in FindAllPropertyTemplates(domain))
{
if (prop.Value is IVariableExp)
{
IVariableExp cast = (IVariableExp)prop.Value;
result.Add(cast.ReferredVariable);
bindedVariables.Add(cast.ReferredVariable);
}
else if (prop.Value is IObjectTemplateExp)
{
IObjectTemplateExp cast = (IObjectTemplateExp)prop.Value;
result.Add(cast.BindsTo);
bindedVariables.Add(cast.BindsTo);
}
else if (prop.Value is CSharpOpaqueExpression)
{
CSharpOpaqueExpression cast = (CSharpOpaqueExpression)prop.Value;
result.UnionWith(cast.BindsTo);
}
}
return(result);
}
public static ISet <IVariable> FindBindedVariables(IPropertyTemplateItem prop)
{
if (!prop.ReferredProperty.isMany())
{
IObjectTemplateExp nonManyPropObjectTemplate = prop.Value as IObjectTemplateExp;
if (nonManyPropObjectTemplate != null)
{
return(new HashSet <IVariable>()
{
nonManyPropObjectTemplate.BindsTo
});
}
else
{
IVariableExp nonManyPropVar = prop.Value as IVariableExp;
if (nonManyPropVar != null)
{
return(new HashSet <IVariable>()
{
nonManyPropVar.ReferredVariable
});
}
else
{
CSharpOpaqueExpression cast = prop.Value as CSharpOpaqueExpression;
if (cast != null)
{
return(new HashSet <IVariable>(cast.BindsTo));
}
}
}
}
return(new HashSet <IVariable>());
}
public static string GenerateExpression(IOclExpression expression, bool useMetamodelInterface)
{
if (expression is IOperationCallExp)
{
IOperationCallExp value = (IOperationCallExp)expression;
return("transformation.Functions." + value.ReferredOperation.Name + "(" + string.Join(",", value.Argument.Select(u => GenerateExpression(u, useMetamodelInterface))) + ")");
}
if (expression is CSharpOpaqueExpression)
{
CSharpOpaqueExpression value = (CSharpOpaqueExpression)expression;
return(value.Code);
}
if (expression is IVariableExp)
{
return(((IVariableExp)expression).ReferredVariable.Name);
}
if (expression is Assignment)
{
Assignment assignment = (Assignment)expression;
return(assignment.AssignedVariable.Type.GetRealTypeName() + " " + assignment.AssignedVariable.Name + " = " + GenerateExpression(assignment.Value, useMetamodelInterface));
}
if (expression is IRelationCallExp)
{
IRelationCallExp relationCallExp = (IRelationCallExp)expression;
return("transformation." + QvtCodeGeneratorStrings.RelationClassName(relationCallExp.ReferredRelation)
+ ".CheckAndEnforce(" + string.Join(",", relationCallExp.Argument.Select(u => GenerateExpression(u, useMetamodelInterface))) + ")");
}
throw new CodeGeneratorException("Cannot manage expression: " + expression);
}
private static void AnalyzeObjectTemplateExpression(IObjectTemplateExp objectTemplateExp, DomainVariablesBindingsResult currentResult, bool enforce, ISet <IObjectTemplateExp> analyzedSoFar = null)
{
if (analyzedSoFar == null)
{
analyzedSoFar = new HashSet <IObjectTemplateExp>();
}
if (!analyzedSoFar.Contains(objectTemplateExp))
{
analyzedSoFar.Add(objectTemplateExp);
if (!objectTemplateExp.IsAntiTemplate())
{
currentResult.VariablesItCanBind.Add(objectTemplateExp.BindsTo);
}
foreach (IPropertyTemplateItem propertyTemplateItem in objectTemplateExp.Part)
{
if (propertyTemplateItem.Value is IObjectTemplateExp)
{
IObjectTemplateExp casted = (IObjectTemplateExp)propertyTemplateItem.Value;
AnalyzeObjectTemplateExpression(casted, currentResult, enforce, analyzedSoFar);
}
else if (propertyTemplateItem.Value is IVariableExp)
{
IVariableExp casted = (IVariableExp)propertyTemplateItem.Value;
if (enforce)
{
if (!currentResult.IPropertyTemplateItemToVariablesRequired.ContainsKey(propertyTemplateItem))
{
currentResult.IPropertyTemplateItemToVariablesRequired[propertyTemplateItem] = new HashSet <IVariable>();
}
currentResult.IPropertyTemplateItemToVariablesRequired[propertyTemplateItem].Add(casted.ReferredVariable);
}
else
{
currentResult.VariablesItCanBind.Add(casted.ReferredVariable);
}
}
else if (propertyTemplateItem.Value is CSharpOpaqueExpression)
{
CSharpOpaqueExpression casted = (CSharpOpaqueExpression)propertyTemplateItem.Value;
if (!currentResult.IPropertyTemplateItemToVariablesRequired.ContainsKey(propertyTemplateItem))
{
currentResult.IPropertyTemplateItemToVariablesRequired[propertyTemplateItem] = new HashSet <IVariable>();
}
currentResult.IPropertyTemplateItemToVariablesRequired[propertyTemplateItem].UnionWith(casted.BindsTo);
}
}
}
}
private void GenerateString(CSharpOpaqueExpression exp, bool manylines = false)
{
List <string> variablesNames = exp.BindsTo.Select(a => a.Name).ToList();
string variablesNamesList = string.Join(",", variablesNames);
if (manylines)
{
WriteLine("#CSharpOpaqueExpression[");
PushIndent();
string[] instructions = exp.Code.Split(';');
foreach (string instruction in instructions.Where(i => !string.IsNullOrWhiteSpace(i)))
{
string toWrite = instruction.Trim() + ";";
if (instructions.Last() == instruction)
{
Write(toWrite);
}
else
{
WriteLine(toWrite);
}
}
PopIndent();
Write("]");
}
else
{
Write("#CSharpOpaqueExpression[");
Write(exp.Code + "]");
}
if (variablesNames.Count > 0)
{
Write("[variables: " + variablesNamesList + "]");
}
if (manylines)
{
WriteLine("");
}
}