/// <summary>
/// Adds members included from structural representatives
/// </summary>
internal void IncludeSRMembers(PSMBridgeClass representedClass)
{
foreach (KeyValuePair <PSMAttribute, PSMBridgeAttribute> kvp in representedClass.PSMAttribute)
{
PSMBridgeAttribute copy = new PSMBridgeAttribute(kvp.Key, kvp.Value.PropertyType, kvp.Value.Type);
PSMAttribute.Add(kvp.Key, copy);
copy.Tag = kvp.Value.Tag;
Properties.Add(copy);
}
foreach (KeyValuePair <PSMAssociation, PSMBridgeAssociation> kvp in PSMChildMembers)
{
if (kvp.Value.Direction == PSMBridgeAssociation.AssociationDirection.Down)
{
PSMBridgeAssociation copy = new PSMBridgeAssociation(kvp.Value.DefaultName, kvp.Value.Aliases, kvp.Value.SourceAsscociation, kvp.Value.Direction, kvp.Value.PropertyType, kvp.Value.Type);
PSMChildMembers.Add(kvp.Key, copy);
copy.Tag = kvp.Value.Tag;
Properties.Add(copy, kvp.Value.Name);
}
}
}
public void TranslateSchema(Schema schema, bool translateAsOldVersion = false)
{
PSMSchema psmSchema = (PSMSchema)schema;
IEnumerable <AttributeType> attTypes = psmSchema.GetAvailablePSMTypes();
foreach (AttributeType type in attTypes)
{
if (translateAsOldVersion && schema.Project.PSMBuiltInTypes.Contains(type))
{
continue;
}
Classifier existsCl;
if (Library.RootNamespace.NestedClassifier.TryGetValue(type.Name, out existsCl))
{
PSMAttributeType.Add(type, existsCl);
continue;
}
Classifier parent;
if (type.BaseType == null)
{
parent = Library.Any;
}
else
{
if (Library.RootNamespace.NestedClassifier.TryGetValue(type.BaseType.Name, out parent) == false)
{
parent = Library.Any;
}
}
Classifier newClassifier = new Classifier(Library.TypeTable, Library.TypeTable.Library.RootNamespace, type.Name, parent);
Library.TypeTable.RegisterType(newClassifier);
// Library.RootNamespace.NestedClassifier.Add(newClassifier);
PSMAttributeType.Add(type, newClassifier);
}
List <PSMBridgeClass> classToProcess = new List <PSMBridgeClass>();
// JM: usporadani trid tak, aby predkove byli zalozeni pred potomky
List <PSMClass> psmClassesHierarchy = ModelIterator.GetPSMClassesInheritanceBFS(psmSchema).ToList();
foreach (PSM.PSMClass psmClass in psmClassesHierarchy)
{
// JM: parent - predek v PSM modelu
PSMBridgeClass parent = psmClass.GeneralizationAsSpecific != null ? PSMAssociationMembers[psmClass.GeneralizationAsSpecific.General] : null;
string nameOverride = translateAsOldVersion ? psmClass.Name + @"_old" : null;
PSMBridgeClass newClass = new PSMBridgeClass(Library.TypeTable, Library.TypeTable.Library.RootNamespace, psmClass, parent, nameOverride);
// tt.Library.RootNamespace.NestedClassifier.Add(newClass);
Library.TypeTable.RegisterType(newClass);
classToProcess.Add(newClass);
//Hack
newClass.Tag = psmClass;
//Registred to find
PSMAssociationMembers.Add(psmClass, newClass);
}
foreach (var cM in psmSchema.PSMContentModels)
{
string cMName = PSMBridgeClass.GetContentModelOCLName(cM);
if (translateAsOldVersion)
{
cMName += @"_old";
}
PSMBridgeClass newClass = new PSMBridgeClass(Library.TypeTable, Library.TypeTable.Library.RootNamespace, cM, cMName);
// tt.Library.RootNamespace.NestedClassifier.Add(newClass);
Library.TypeTable.RegisterType(newClass);
classToProcess.Add(newClass);
newClass.Tag = cM;
//Registred to find
PSMAssociationMembers.Add(cM, newClass);
}
classToProcess.ForEach(cl => cl.TranslateMembers(this, translateAsOldVersion));
List <PSMBridgeClass> orderedSRs = ModelIterator.GetPSMClassesStructuralRepresentativeRelationBFS(psmSchema).Where(c => c.IsStructuralRepresentative).Select(psmc => PSMAssociationMembers[psmc]).ToList();
orderedSRs.ForEach(cl => cl.IncludeSRMembers(PSMAssociationMembers[((PSMClass)cl.PSMSource).RepresentedClass]));
}
public PSMBridgeClass(TypesTable.TypesTable tt, Namespace ns, PSMClass sourceClass, PSMBridgeClass parent = null, string nameOverride = null)
: this(tt, ns, nameOverride ?? sourceClass.Name, parent)
{
this.PSMSource = sourceClass;
this.PSMSourceType = SourceType.PSMClass;
}
