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>()); }
/// <summary> /// Adds the given element to the collection /// </summary> /// <param name="item">The item to add</param> public override void Add(IModelElement item) { IPropertyTemplateItem partCasted = item.As <IPropertyTemplateItem>(); if ((partCasted != null)) { this._parent.Part.Add(partCasted); } }
/// <summary> /// Removes the given item from the collection /// </summary> /// <returns>True, if the item was removed, otherwise False</returns> /// <param name="item">The item that should be removed</param> public override bool Remove(IModelElement item) { IPropertyTemplateItem propertyTemplateItemItem = item.As <IPropertyTemplateItem>(); if (((propertyTemplateItemItem != null) && this._parent.Part.Remove(propertyTemplateItemItem))) { return(true); } return(false); }
public static bool AreEqual(IList <IPropertyTemplateItem> pp1, IList <IPropertyTemplateItem> pp2) { foreach (IPropertyTemplateItem pp1Item in pp1) { IPropertyTemplateItem pp2Item = pp2[pp1.IndexOf(pp1Item)]; if (pp1Item != pp2Item) { return(false); } } return(true); }
/// <summary> /// Adds the given element to the collection /// </summary> /// <param name="item">The item to add</param> public override void Add(IModelElement item) { IPropertyTemplateItem partCasted = item.As <IPropertyTemplateItem>(); if ((partCasted != null)) { this._parent.Part.Add(partCasted); } if ((this._parent.ReferredClass == null)) { LL.MDE.Components.Qvt.Metamodel.EMOF.IClass referredClassCasted = item.As <LL.MDE.Components.Qvt.Metamodel.EMOF.IClass>(); if ((referredClassCasted != null)) { this._parent.ReferredClass = referredClassCasted; return; } } }
private static string GenerateAccess(string varname, IList <IPropertyTemplateItem> applicablePropertyPath) { string access = varname; foreach (IPropertyTemplateItem property in applicablePropertyPath) { access += "?." + property.ReferredProperty.Name; } IPropertyTemplateItem last = applicablePropertyPath.Last(); if (last.ReferredProperty.Type is IDataType) { if (cSharpPrimitiveTypes.Contains(last.ReferredProperty.Type.GetRealTypeName())) { access += "GetValueOrDefault()"; } } return(access); }
private static string GenerateFindValueWithKey(IPropertyTemplateItem propertyTemplateItem, IObjectTemplateExp objectTemplateExpression, string resultContainer, IList <IList <IPropertyTemplateItem> > applicablePropertyPaths, bool useMetamodelInterface) { StringBuilder sb = new StringBuilder(); IList <string> conditions = new List <string>(); string variableName = "var" + new Random().Next(); foreach (IList <IPropertyTemplateItem> applicablePropertyPath in applicablePropertyPaths) { string access = GenerateAccess(variableName, applicablePropertyPath); string condition = access + " == " + GenerateExpression(applicablePropertyPath.Last().Value, useMetamodelInterface); conditions.Add(condition); } string completeCondition = string.Join(" && ", conditions); // If the candidate is in a collection, we generate a query to find it if (propertyTemplateItem.ReferredProperty.isMany()) { sb.AppendLine(objectTemplateExpression.BindsTo.Name + " = " + resultContainer + "." + propertyTemplateItem.ReferredProperty.Name + ".OfType<" + propertyTemplateItem.ReferredProperty.Type.GetRealTypeName() + ">()" + ".FirstOrDefault(" + variableName + " => " + completeCondition + ");"); } // If the candidate is in a ref, we generate a conditional to find it else { sb.AppendLine("{" + propertyTemplateItem.ReferredProperty.Type.GetRealTypeName() + variableName + "= " + resultContainer + "." + propertyTemplateItem.ReferredProperty.Name + ";" + "if (" + completeCondition + ") {" + objectTemplateExpression.BindsTo.Name + " = " + variableName + ";" + "}" + "}"); } return(sb.ToString()); }
/// <summary> /// Creates a new observable property access proxy /// </summary> /// <param name="modelElement">The model instance element for which to create the property access proxy</param> public IsOppositeProxy(IPropertyTemplateItem modelElement) : base(modelElement) { }
private static string GenerateConditionnalProperty(IPropertyTemplateItem prop, bool useMetamodelInterface) { string right = GenerateExpression(prop.Value, useMetamodelInterface); return(prop.ObjContainer.BindsTo.Name + "." + prop.ReferredProperty.Name + " == " + right); }
public static string GenerateBindingFreeNonMany(IPropertyTemplateItem prop, IVariable bindedVariable) { return(bindedVariable.Type.GetRealTypeName() + " " + bindedVariable.Name + " = (" + bindedVariable.Type.GetRealTypeName() + ")" + prop.ObjContainer.BindsTo.Name + "." + prop.ReferredProperty.Name + ";"); }
private static string GenerateSetValue(IPropertyTemplateItem propertyTemplateItem, string resultContainer, IRelation relation, bool useMetamodelInterface) { StringBuilder sb = new StringBuilder(); IObjectTemplateExp objectTemplateExpression = propertyTemplateItem.Value as IObjectTemplateExp; // Case ref value if (objectTemplateExpression != null) { IKey transformationKey = ((IRelationalTransformation)relation.Transformation).OwnedKey.FirstOrDefault(k => k.Identifies == objectTemplateExpression.ReferredClass); IList <IList <IPropertyTemplateItem> > propertyPathsTransformationKey = transformationKey != null?FindKeyApplicablePropertyPaths(objectTemplateExpression, transformationKey) : null; IKey relationKey = relation.Keys().FirstOrDefault(k => k.Identifies == objectTemplateExpression.ReferredClass); IList <IList <IPropertyTemplateItem> > propertyPathsRelationKey = relationKey != null?FindKeyApplicablePropertyPaths(objectTemplateExpression, relationKey) : null; // We always start by creating the empty variable that will contain the object sb.AppendLine(objectTemplateExpression.BindsTo.Type.GetRealTypeName() + " " + objectTemplateExpression.BindsTo.Name + " = null;"); int nbBracketsOpened = 0; // If any part of a key applies, then we must generate a test to find a potential existing object if (propertyPathsTransformationKey != null || propertyPathsRelationKey != null) { // We try to resolve globally and locally, if a global key applies here if (propertyPathsTransformationKey != null) { sb.AppendLine(); sb.AppendLine("// Trying to resolve the object\'" + objectTemplateExpression.BindsTo.Name + "\' globally using the transformation key"); IList <string> tupleTypes = propertyPathsTransformationKey.Select(pp => pp.Last().ReferredProperty.Type.GetRealTypeName()).Select(name => name + (cSharpPrimitiveTypes.Contains(name) ? "?" : "")).ToList(); IList <string> tupleValues = propertyPathsTransformationKey.Select(pp => GenerateAccess(objectTemplateExpression.BindsTo.Name, pp)).ToList(); IList <string> tupleValuesRead = propertyPathsTransformationKey.Select(pp => GenerateExpression(pp.Last().Value, useMetamodelInterface)).ToList(); string tupleTypesCombined = string.Join(",", tupleTypes); string tupleValuesCombined = string.Join(",", tupleValues); string tupleValuesCombinedRead = string.Join(",", tupleValuesRead); string accessDictionnaryReadSafe = "transformation." + QvtCodeGeneratorStrings.KeyDictionnaryName(transformationKey) + ".TryGetValue(new Tuple<" + tupleTypesCombined + ">(" + tupleValuesCombinedRead + "), out " + objectTemplateExpression.BindsTo.Name + ")"; string accessDictionnaryWrite = "transformation." + QvtCodeGeneratorStrings.KeyDictionnaryName(transformationKey) + "[new Tuple<" + tupleTypesCombined + ">(" + tupleValuesCombined + ")]"; sb.AppendLine(accessDictionnaryReadSafe + ";"); // If not found globally with global key, we try to find locally with global key sb.AppendLine("// If the object wasn't found globally, we try to find it locally"); sb.AppendLine("if (" + objectTemplateExpression.BindsTo.Name + "== null) {"); sb.AppendLine(GenerateFindValueWithKey(propertyTemplateItem, objectTemplateExpression, resultContainer, propertyPathsTransformationKey, useMetamodelInterface)); nbBracketsOpened++; // If we found locally with global key, we add to the dictionnary sb.AppendLine("// If the object was found locally, we add it to the global cache"); sb.AppendLine("if (" + objectTemplateExpression.BindsTo.Name + "!= null) {"); sb.AppendLine(accessDictionnaryWrite + " = " + objectTemplateExpression.BindsTo.Name + ";"); // Else we continue with other attempts (local key or object creation) sb.AppendLine("}"); } if (propertyPathsRelationKey != null) { sb.AppendLine("// Trying to resolve the object locally using the relation key"); if (propertyPathsTransformationKey != null) { sb.AppendLine("else {"); nbBracketsOpened++; } sb.AppendLine(GenerateFindValueWithKey(propertyTemplateItem, objectTemplateExpression, resultContainer, propertyPathsRelationKey, useMetamodelInterface)); // If we found something locally, once again we check in the dictionnary and try to update sb.AppendLine("// If the object was found locally, we add it to the global cache"); sb.AppendLine("if (" + objectTemplateExpression.BindsTo.Name + "!= null) {"); sb.AppendLine(GenerateCheckAndAddDictionnary(propertyPathsTransformationKey, objectTemplateExpression.BindsTo.Name, transformationKey)); sb.AppendLine("}"); } // In the end we generate a test if we found a candidate sb.AppendLine("// If the object still doesn't exist, we create it"); sb.AppendLine("else {"); nbBracketsOpened++; } // In any case, we generate the code to create the object, even if it might end in the conditional due to the keys test string beginningCreation = objectTemplateExpression.BindsTo.Name + " = "; if (useMetamodelInterface) { sb.AppendLine(beginningCreation + " (" + objectTemplateExpression.BindsTo.Type.GetRealTypeName() + ") editor." + nameof(IMetaModelInterface.CreateNewObjectInField) + "(" + resultContainer + ", \"" + propertyTemplateItem.ReferredProperty.Name + "\");"); } else { string res = beginningCreation; res += "new " + objectTemplateExpression.BindsTo.Type.GetRealTypeName() + "();\n"; if (!propertyTemplateItem.ReferredProperty.isMany()) { res += resultContainer + "." + propertyTemplateItem.ReferredProperty.Name + " = " + objectTemplateExpression.BindsTo.Name + ";"; } else { res += resultContainer + "." + propertyTemplateItem.ReferredProperty.Name + ".Add(" + objectTemplateExpression.BindsTo.Name + ");"; } sb.AppendLine(res); } if (propertyPathsTransformationKey != null) { // TODO generate this all the time? sb.AppendLine("// We add the created object to the global cache"); sb.AppendLine(GenerateCheckAndAddDictionnary(propertyPathsTransformationKey, objectTemplateExpression.BindsTo.Name, transformationKey)); } // If we generated a conditional for the keys test, we close it now if (propertyPathsTransformationKey != null || propertyPathsRelationKey != null) { sb.AppendLine("}"); } for (int i = 0; i < nbBracketsOpened - 1; i++) { sb.AppendLine("}"); } return(sb.ToString()); } // Case primitive value (variable use or c sharp expression) else { if (useMetamodelInterface) { return("editor." + nameof(IMetaModelInterface.AddOrSetInField) + "(" + resultContainer + ", \"" + propertyTemplateItem.ReferredProperty.Name + "\", " + GenerateExpression(propertyTemplateItem.Value, true) + " );"); } else { return(resultContainer + "." + propertyTemplateItem.ReferredProperty.Name + "=" + GenerateExpression(propertyTemplateItem.Value, false) + ";"); } } }
private static IList <IList <IPropertyTemplateItem> > FindKeyApplicablePropertyPaths(IObjectTemplateExp objectTemplateExpression, IKey candidateKey) { // First, we try to find if some keys applies here IList <IList <IPropertyTemplateItem> > result = new List <IList <IPropertyTemplateItem> >(); IList <IList <IPropertyTemplateItem> > candidateKeyPropertyPaths = new List <IList <IPropertyTemplateItem> >(); bool isApplicable = true; foreach (IProperty property in candidateKey.Part) { IPropertyTemplateItem candidate = objectTemplateExpression.Part.FirstOrDefault(p => p.ReferredProperty == property); if (candidate != null) { List <IPropertyTemplateItem> propertyPath = new List <IPropertyTemplateItem>() { candidate }; candidateKeyPropertyPaths.Add(propertyPath); } else { isApplicable = false; break; } } if (isApplicable) { foreach (PropertyPath propertyPath in candidateKey.PropertyPaths()) { IObjectTemplateExp currentobjectTemplateExpression = objectTemplateExpression; bool isPathApplicable = true; List <IPropertyTemplateItem> concretePropertyPath = new List <IPropertyTemplateItem>(); foreach (IProperty property in propertyPath.Properties) { IEnumerable <IPropertyTemplateItem> nextObjectTemplate = currentobjectTemplateExpression.Part.Where(p => p.ReferredProperty == property).ToList(); if (!nextObjectTemplate.IsNullOrEmpty()) { concretePropertyPath.Add(nextObjectTemplate.Single()); currentobjectTemplateExpression = (IObjectTemplateExp)nextObjectTemplate.Single().Value; } else { isPathApplicable = false; break; } } if (isPathApplicable) { candidateKeyPropertyPaths.Add(concretePropertyPath); } else { isApplicable = false; break; } } } // If this key is valid, we merge all its contents into the result if (isApplicable) { foreach (IList <IPropertyTemplateItem> candidateKeyPropertyPath in candidateKeyPropertyPaths) { IList <IPropertyTemplateItem> existing = result.FirstOrDefault(pp => AreEqual(pp, candidateKeyPropertyPath)); if (existing.IsNullOrEmpty()) { result.Add(candidateKeyPropertyPath); } } return(result); } return(null); }