public override void Execute(UMLRelationship r, ActionMap map, List <PreFile> prefiles)
{
UMLClass a = null;
UMLClass b = null;
UMLClass ac = null;
int defaultDetsA = 0;
int defaultDetsB = 0;
PreFile prefA;
PreFile prefB;
PreRET temp;
RelationshipHelper.GetClasses(r, ref a, ref b, this.IsAlternate, ref defaultDetsA, ref defaultDetsB);
if (r is UMLAssociation)
{
ac = ((UMLAssociation)r).AssociationClass;
}
prefA = PreFileHelper.GetPreFileWithClass(a, prefiles);
prefB = PreFileHelper.GetPreFileWithClass(b, prefiles);
if (prefA == null)
{
if (prefB == null)
{
prefA = new PreFile();
prefA.Rets.Add(new PreRET());
prefA.Rets.Add(new PreRET());
prefA.Rets[0].Classes.Add(a);
prefA.Rets[1].Classes.Add(b);
prefiles.Add(prefA);
if (ac != null)
{
prefA.Rets.Add(new PreRET());
prefA.Rets[2].Classes.Add(ac);
}
}
else
{
temp = new PreRET();
temp.Classes.Add(a);
prefB.Rets.Add(temp);
}
}
else
{
if (prefB == null)
{
temp = new PreRET();
temp.Classes.Add(b);
prefA.Rets.Add(temp);
}
}
}
public override void Execute(UMLRelationship r, ActionMap map, List<PreFile> prefiles)
{
UMLClass a = null;
UMLClass b = null;
UMLClass ac = null;
int defaultDetsA = 0;
int defaultDetsB = 0;
PreFile prefA;
PreFile prefB;
PreRET temp;
RelationshipHelper.GetClasses(r, ref a, ref b, this.IsAlternate, ref defaultDetsA, ref defaultDetsB);
if (r is UMLAssociation)
{
ac = ((UMLAssociation)r).AssociationClass;
}
prefA = PreFileHelper.GetPreFileWithClass(a, prefiles);
prefB = PreFileHelper.GetPreFileWithClass(b, prefiles);
if (prefA == null)
{
if (prefB == null)
{
prefA = new PreFile();
prefA.Rets.Add(new PreRET());
prefA.Rets.Add(new PreRET());
prefA.Rets[0].Classes.Add(a);
prefA.Rets[1].Classes.Add(b);
prefiles.Add(prefA);
if (ac != null)
{
prefA.Rets.Add(new PreRET());
prefA.Rets[2].Classes.Add(ac);
}
}
else
{
temp = new PreRET();
temp.Classes.Add(a);
prefB.Rets.Add(temp);
}
}
else
{
if (prefB == null)
{
temp = new PreRET();
temp.Classes.Add(b);
prefA.Rets.Add(temp);
}
}
}
public static void GetClasses(UMLRelationship r, ref UMLClass a, ref UMLClass b, bool isAlternate, ref int defaultDetsA, ref int defaultDetsB)
{
if (r is UMLAssociation)
{
if (isAlternate)
{
switch (((UMLAssociation)r).End2.MultiplicityKind)
{
case MultiplicityKind.MANY:
case MultiplicityKind.ONETOMANY:
case MultiplicityKind.ZEROTOMANY: defaultDetsA = 1; break;
}
switch (((UMLAssociation)r).End1.MultiplicityKind)
{
case MultiplicityKind.MANY:
case MultiplicityKind.ONETOMANY:
case MultiplicityKind.ZEROTOMANY: defaultDetsB = 1; break;
}
a = ((UMLAssociation)r).End2.Participant;
b = ((UMLAssociation)r).End1.Participant;
}
else
{
switch (((UMLAssociation)r).End1.MultiplicityKind)
{
case MultiplicityKind.MANY:
case MultiplicityKind.ONETOMANY:
case MultiplicityKind.ZEROTOMANY: defaultDetsA = 1; break;
}
switch (((UMLAssociation)r).End2.MultiplicityKind)
{
case MultiplicityKind.MANY:
case MultiplicityKind.ONETOMANY:
case MultiplicityKind.ZEROTOMANY: defaultDetsB = 1; break;
}
a = ((UMLAssociation)r).End1.Participant;
b = ((UMLAssociation)r).End2.Participant;
}
}
else if (r is UMLGeneralization)
{
a = ((UMLGeneralization)r).Parent;
b = ((UMLGeneralization)r).Child;
}
else if (r is UMLRealization)
{
a = ((UMLRealization)r).Supplier;
b = ((UMLRealization)r).Client;
}
}
public static void GetClasses(UMLRelationship r, ref UMLClass a, ref UMLClass b, bool isAlternate, ref int defaultDetsA, ref int defaultDetsB)
{
if (r is UMLAssociation)
{
if (isAlternate)
{
switch (((UMLAssociation)r).End2.MultiplicityKind)
{
case MultiplicityKind.MANY:
case MultiplicityKind.ONETOMANY:
case MultiplicityKind.ZEROTOMANY: defaultDetsA = 1; break;
}
switch (((UMLAssociation)r).End1.MultiplicityKind)
{
case MultiplicityKind.MANY:
case MultiplicityKind.ONETOMANY:
case MultiplicityKind.ZEROTOMANY: defaultDetsB = 1; break;
}
a = ((UMLAssociation)r).End2.Participant;
b = ((UMLAssociation)r).End1.Participant;
}
else
{
switch (((UMLAssociation)r).End1.MultiplicityKind)
{
case MultiplicityKind.MANY:
case MultiplicityKind.ONETOMANY:
case MultiplicityKind.ZEROTOMANY: defaultDetsA = 1; break;
}
switch (((UMLAssociation)r).End2.MultiplicityKind)
{
case MultiplicityKind.MANY:
case MultiplicityKind.ONETOMANY:
case MultiplicityKind.ZEROTOMANY: defaultDetsB = 1; break;
}
a = ((UMLAssociation)r).End1.Participant;
b = ((UMLAssociation)r).End2.Participant;
}
}
else if (r is UMLGeneralization)
{
a = ((UMLGeneralization)r).Parent;
b = ((UMLGeneralization)r).Child;
}
else if (r is UMLRealization)
{
a = ((UMLRealization)r).Supplier;
b = ((UMLRealization)r).Client;
}
}
//METHODS #region Methods public abstract void Execute(UMLRelationship r, ActionMap map, List<PreFile> files);
public override void Execute(UMLRelationship r, ActionMap map, List<PreFile> prefiles)
{
UMLClass a = null;
UMLClass b = null;
int defaultDetsA = 0;
int defaultDetsB = 0;
PreFile prefA;
PreFile prefB;
PreRET temp;
RelationshipHelper.GetClasses(r, ref a, ref b, this.IsAlternate, ref defaultDetsA, ref defaultDetsB);
prefA = PreFileHelper.GetPreFileWithClass(a, prefiles);
prefB = PreFileHelper.GetPreFileWithClass(b, prefiles);
if (prefA == null)
{
if (prefB == null)
{
prefA = new PreFile();
prefA.Rets.Add(new PreRET());
prefA.Rets.Add(new PreRET());
prefA.Rets[0].Classes.Add(a);
prefA.Rets[1].Classes.Add(b);
prefA.Rets[1].Parents.Add(prefA.Rets[0]);
prefiles.Add(prefA);
}
else
{
temp = new PreRET();
temp.Classes.Add(a);
prefB.Rets.Add(temp);
foreach (PreRET ret in PreFileHelper.GetPreRETsWithClass(b, prefB))
{
ret.Parents.Add(temp);
}
}
}
else
{
if (prefB == null)
{
temp = new PreRET();
temp.Classes.Add(b);
prefA.Rets.Add(temp);
foreach (PreRET ret in PreFileHelper.GetPreRETsWithClass(a, prefA))
{
temp.Parents.Add(ret);
}
}
else
{
foreach (PreRET retparent in PreFileHelper.GetPreRETsWithClass(a, prefA))
{
foreach (PreRET retchild in PreFileHelper.GetPreRETsWithClass(b, prefB))
{
retchild.Parents.Add(retparent);
//Merging to form the Real RET is done in the FileProcessing
}
}
prefA.Merge(prefB);
prefiles.Remove(prefB);
}
}
}
public List <UMLFile> CreateFiles(IDictionary relationships)
{
List <PreFile> prefiles = new List <PreFile>();
List <PreRET> retsToDelete;
List <UMLFile> files = new List <UMLFile>();
IDictionary <String, String> tnamemap;
IDictionary <String, UMLClass> tclasses;
UMLFile tfile;
String tname;
int tdets;
UMLAttribute tattrib;
//0. Pre-Pre-Processing (set dependencies in relationships)
foreach (DictionaryEntry entry in relationships)
{
UMLRelationship r = (UMLRelationship)entry.Value;
if (r is UMLDependency)
{
foreach (DictionaryEntry entry2 in relationships)
{
UMLRelationship q = (UMLRelationship)entry2.Value;
if (q is UMLAssociation)
{
if ((((UMLDependency)r).Client.Guid.Equals(((UMLAssociation)q).End1.Participant.Guid)) &&
(((UMLDependency)r).Supplier.Guid.Equals(((UMLAssociation)q).End2.Participant.Guid)) ||
(((UMLDependency)r).Client.Guid.Equals(((UMLAssociation)q).End2.Participant.Guid)) &&
(((UMLDependency)r).Supplier.Guid.Equals(((UMLAssociation)q).End1.Participant.Guid)))
{
((UMLAssociation)q).DependencyType = "D";
}
}
}
}
}
//1. PreFile Generation (Pre-Processing)
foreach (DictionaryEntry entry in relationships)
{
UMLRelationship r = (UMLRelationship)entry.Value;
if (!(r is UMLDependency))
{
ActionKey key = new ActionKey(r);
AbstractAction action = map.GetAction(key);
if (action != null)
{
action.Execute(r, map, prefiles);
}
else
{
throw new ArgumentException("There is no defined action for the actionKey given.");
}
}
}
//2. File Generation (Processing)
if (prefiles.Count == 0)
{
return(null);
}
else
{
//2.1 Clean-up (eliminate parents in PreFiles - Generalization cases)
foreach (PreFile prefile in prefiles)
{
retsToDelete = new List <PreRET>();
foreach (PreRET preret in prefile.Rets)
{
foreach (PreRET parent in preret.Parents)
{
//2.1.1 Merge
preret.Merge(parent);
//mark parent ret for deletion
if (!retsToDelete.Contains(parent))
{
retsToDelete.Add(parent);
}
}
}
//2.1.2 Deletion (optimized since rets are only in one file)
foreach (PreRET retToDelete in retsToDelete)
{
prefile.Rets.Remove(retToDelete);
}
//2.1.3 File generation
tfile = new UMLFile();
//Rets
tfile.Rets = prefile.Rets.Count;
//Dets & Name
tdets = 0;
tname = "";
tnamemap = new Dictionary <String, String>();
tclasses = new Dictionary <String, UMLClass>();
foreach (PreRET ret in prefile.Rets)
{
UMLFile.RET tret = new UMLFile.RET();
foreach (UMLClass c in ret.Classes)
{
tnamemap[c.Name] = c.Name;
tret.Classes.Add(c);
if (!(tclasses.ContainsKey(c.Name)))
{
tclasses[c.Name] = c;
c.LoadAttributes();
tdets += c.Attributes.Count;
foreach (UMLAttribute attrib in c.Attributes)
{
tattrib = new UMLAttribute();
tattrib.Name = c.Name + "." + attrib.Name;
tfile.Attributes.Add(tattrib);
}
}
}
tfile.RetsCollection.Add(tret);
}
foreach (KeyValuePair <String, String> kvp in tnamemap)
{
tname += kvp.Value + "_";
}
tfile.Dets = tdets;
tfile.Dets += prefile.DefaultDets;
tname = tname.Remove(tname.Length - 1, 1);
//limit File name size to 50 chars (could cause name collisions)
tfile.Name = tname.Length > 50 ? tname.Substring(1, 50) : tname;
files.Add(tfile);
}
return(files);
}
}
//METHODS #region Methods public abstract void Execute(UMLRelationship r, ActionMap map, List <PreFile> files);
public override void Execute(UMLRelationship r, ActionMap map, List<PreFile> prefiles)
{
UMLClass a = null;
UMLClass b = null;
UMLClass ac = null;
int defaultDetsA = 0;
int defaultDetsB = 0;
PreFile prefA;
PreFile prefB;
RelationshipHelper.GetClasses(r, ref a, ref b, this.IsAlternate, ref defaultDetsA, ref defaultDetsB);
if (r is UMLAssociation)
{
ac = ((UMLAssociation)r).AssociationClass;
}
prefA = PreFileHelper.GetPreFileWithClass(a, prefiles);
prefB = PreFileHelper.GetPreFileWithClass(b, prefiles);
if (prefA == null)
{
if (prefB == null)
{
prefA = new PreFile();
prefA.Rets.Add(new PreRET());
prefA.Rets[0].Classes.Add(a);
prefA.Rets[0].Classes.Add(b);
if (ac != null)
{
prefA.Rets[0].Classes.Add(ac);
}
prefiles.Add(prefA);
}
else
{
foreach (PreRET ret in PreFileHelper.GetPreRETsWithClass(b, prefB))
{
ret.Classes.Add(a);
if (ac != null)
{
ret.Classes.Add(ac);
}
}
}
}
else
{
if (prefB == null)
{
foreach (PreRET ret in PreFileHelper.GetPreRETsWithClass(a, prefA))
{
ret.Classes.Add(b);
if (ac != null)
{
ret.Classes.Add(ac);
}
}
}
else
{
foreach (PreRET reta in PreFileHelper.GetPreRETsWithClass(a, prefA))
{
foreach (PreRET retb in PreFileHelper.GetPreRETsWithClass(b, prefB))
{
reta.Merge(retb);
prefB.Rets.Remove(retb);
if (ac != null)
{
reta.Classes.Add(ac);
}
}
}
prefA.Merge(prefB);
prefiles.Remove(prefB);
}
}
}
public ActionKey(UMLRelationship r)
{
ProcessRelationship(r);
}
//METHODS
#region Methods
private void ProcessRelationship(UMLRelationship r)
{
string end1type;
string end2type;
string end1mult;
string end2mult;
string dependency;
//For all relationship types
if (r is UMLAssociation)
{
this._actionType = ActionKey.EntryType.ASSOCIATION;
}
else if (r is UMLGeneralization)
{
this._actionType = ActionKey.EntryType.GENERALIZATION;
}
else if (r is UMLRealization)
{
this._actionType = ActionKey.EntryType.REALIZATION;
}
else
{
throw new ArgumentException("");
}
//Associations to AssociationClasses are not treated independently in StarUML and hence are
//not considered here
//Associations
if (r is UMLAssociation)
{
switch (((UMLAssociation)r).End1.AggregationKind)
{
case AggregationKind.AGGREGATE: end1type = EndType.AGGREGATION; break;
case AggregationKind.COMPOSITE: end1type = EndType.COMPOSITION; break;
case AggregationKind.NONE: end1type = EndType.NONE; break;
default: end1type = EndType.NONE; break;
}
switch (((UMLAssociation)r).End2.AggregationKind)
{
case AggregationKind.AGGREGATE: end2type = EndType.AGGREGATION; break;
case AggregationKind.COMPOSITE: end2type = EndType.COMPOSITION; break;
case AggregationKind.NONE: end2type = EndType.NONE; break;
default: end2type = EndType.NONE; break;
}
switch (((UMLAssociation)r).End1.MultiplicityKind)
{
case MultiplicityKind.MANY: end1mult = MultiplicityType.MANY; break;
case MultiplicityKind.ONE: end1mult = MultiplicityType.ONE; break;
case MultiplicityKind.ONETOMANY: end1mult = MultiplicityType.ONETOMANY; break;
case MultiplicityKind.ZEROTOMANY: end1mult = MultiplicityType.ZEROTOMANY; break;
case MultiplicityKind.ZEROTOONE: end1mult = MultiplicityType.ZEROTOONE; break;
default: end1mult = MultiplicityType.MANY; break;
}
switch (((UMLAssociation)r).End2.MultiplicityKind)
{
case MultiplicityKind.MANY: end2mult = MultiplicityType.MANY; break;
case MultiplicityKind.ONE: end2mult = MultiplicityType.ONE; break;
case MultiplicityKind.ONETOMANY: end2mult = MultiplicityType.ONETOMANY; break;
case MultiplicityKind.ZEROTOMANY: end2mult = MultiplicityType.ZEROTOMANY; break;
case MultiplicityKind.ZEROTOONE: end2mult = MultiplicityType.ZEROTOONE; break;
default: end2mult = MultiplicityType.MANY; break;
}
if (end1type.Equals(EndType.COMPOSITION) ||
end2type.Equals(EndType.COMPOSITION))
{
dependency = "D";
}
else
{
if (((UMLAssociation)r).DependencyType.Equals("D"))
{
dependency = "D";
}
else
{
dependency = "I";
}
}
//if (((UMLAssociation)r).Stereotype != null)
//{
// if (((UMLAssociation)r).Stereotype.Equals("D"))
// {
// dependency = "D";
// }
// else if (((UMLAssociation)r).Stereotype.Equals("I"))
// {
// dependency = "I";
// }
// else
// {
// throw new ArgumentException("Only dependent and independent dependency-types are allowed.");
// }
//}
//else
//{
// dependency = "D";
//}
//FIN_HARDCODE
this._key = end1type + end2type + end1mult + end2mult + dependency;
}
//Generalizations
if (r is UMLGeneralization)
{
end1type = EndType.GENERALIZATION;
end2type = EndType.NONE;
this._key = end1type.ToString() + end2type.ToString();
}
//Realizations
if (r is UMLRealization)
{
end1type = EndType.REALIZATION;
end2type = EndType.NONE;
this._key = end1type.ToString() + end2type.ToString();
}
}
public override void Execute(UMLRelationship r, ActionMap map, List<PreFile> prefiles)
{
UMLClass a=null;
UMLClass b=null;
int defaultDetsA = 0;
int defaultDetsB = 0;
PreFile temp, tempA, tempB;
RelationshipHelper.GetClasses(r, ref a, ref b, this.IsAlternate, ref defaultDetsA, ref defaultDetsB);
//1st File
if ((tempA = PreFileHelper.GetPreFileWithClass(a, prefiles)) == null)
{
tempA = new PreFile();
tempA.Rets.Add(new PreRET());
tempA.Rets[0].Classes.Add(a);
prefiles.Add(tempA);
}
tempA.DefaultDets += defaultDetsA;
//2nd File
if ((tempB = PreFileHelper.GetPreFileWithClass(b, prefiles)) == null)
{
tempB = new PreFile();
tempB.Rets.Add(new PreRET());
tempB.Rets[0].Classes.Add(b);
prefiles.Add(tempB);
}
tempB.DefaultDets += defaultDetsB;
//3rd File (only if there is an Association-Class)
if (r is UMLAssociation)
{
if (((UMLAssociation)r).AssociationClass != null)
{
UMLClass dependencyClass = null;
UMLClass associationClass = ((UMLAssociation)r).AssociationClass;
UMLDependencyCollection dependencies = associationClass.GetDependencies();
foreach (UMLDependency d in dependencies)
{
d.Client = Helper.GetDependencyClient<UMLClass>(d.Guid);
d.Supplier = Helper.GetDependencySupplier<UMLClass>(d.Guid);
if ((d.Client.Guid == associationClass.Guid && d.Supplier.Guid == a.Guid) ||
(d.Supplier.Guid == associationClass.Guid && d.Client.Guid == a.Guid))
dependencyClass = a;
else if ((d.Client.Guid == associationClass.Guid && d.Supplier.Guid == b.Guid) ||
(d.Supplier.Guid == associationClass.Guid && d.Client.Guid == b.Guid))
dependencyClass = b;
}
if (dependencyClass == null)
{
//temp = PreFileHelper.GetPreFileWithClass(a, prefiles);
//if (temp == null)
temp = new PreFile();
temp.Rets.Add(new PreRET());
temp.Rets[0].Classes.Add(((UMLAssociation)r).AssociationClass);
prefiles.Add(temp);
}
else if (dependencyClass == a)
{
PreRET pret = new PreRET();
pret.Classes.Add(associationClass);
tempA.Rets.Add(pret);
}
else if (dependencyClass == b)
{
PreRET pret = new PreRET();
pret.Classes.Add(associationClass);
tempB.Rets.Add(pret);
}
}
}
}
public override void Execute(UMLRelationship r, ActionMap map, List <PreFile> prefiles)
{
UMLClass a = null;
UMLClass b = null;
int defaultDetsA = 0;
int defaultDetsB = 0;
PreFile prefA;
PreFile prefB;
PreRET temp;
RelationshipHelper.GetClasses(r, ref a, ref b, this.IsAlternate, ref defaultDetsA, ref defaultDetsB);
prefA = PreFileHelper.GetPreFileWithClass(a, prefiles);
prefB = PreFileHelper.GetPreFileWithClass(b, prefiles);
if (prefA == null)
{
if (prefB == null)
{
prefA = new PreFile();
prefA.Rets.Add(new PreRET());
prefA.Rets.Add(new PreRET());
prefA.Rets[0].Classes.Add(a);
prefA.Rets[1].Classes.Add(b);
prefA.Rets[1].Parents.Add(prefA.Rets[0]);
prefiles.Add(prefA);
}
else
{
temp = new PreRET();
temp.Classes.Add(a);
prefB.Rets.Add(temp);
foreach (PreRET ret in PreFileHelper.GetPreRETsWithClass(b, prefB))
{
ret.Parents.Add(temp);
}
}
}
else
{
if (prefB == null)
{
temp = new PreRET();
temp.Classes.Add(b);
prefA.Rets.Add(temp);
foreach (PreRET ret in PreFileHelper.GetPreRETsWithClass(a, prefA))
{
temp.Parents.Add(ret);
}
}
else
{
foreach (PreRET retparent in PreFileHelper.GetPreRETsWithClass(a, prefA))
{
foreach (PreRET retchild in PreFileHelper.GetPreRETsWithClass(b, prefB))
{
retchild.Parents.Add(retparent);
//Merging to form the Real RET is done in the FileProcessing
}
}
prefA.Merge(prefB);
prefiles.Remove(prefB);
}
}
}
public override void Execute(UMLRelationship r, ActionMap map, List <PreFile> prefiles)
{
UMLClass a = null;
UMLClass b = null;
UMLClass ac = null;
int defaultDetsA = 0;
int defaultDetsB = 0;
PreFile prefA;
PreFile prefB;
RelationshipHelper.GetClasses(r, ref a, ref b, this.IsAlternate, ref defaultDetsA, ref defaultDetsB);
if (r is UMLAssociation)
{
ac = ((UMLAssociation)r).AssociationClass;
}
prefA = PreFileHelper.GetPreFileWithClass(a, prefiles);
prefB = PreFileHelper.GetPreFileWithClass(b, prefiles);
if (prefA == null)
{
if (prefB == null)
{
prefA = new PreFile();
prefA.Rets.Add(new PreRET());
prefA.Rets[0].Classes.Add(a);
prefA.Rets[0].Classes.Add(b);
if (ac != null)
{
prefA.Rets[0].Classes.Add(ac);
}
prefiles.Add(prefA);
}
else
{
foreach (PreRET ret in PreFileHelper.GetPreRETsWithClass(b, prefB))
{
ret.Classes.Add(a);
if (ac != null)
{
ret.Classes.Add(ac);
}
}
}
}
else
{
if (prefB == null)
{
foreach (PreRET ret in PreFileHelper.GetPreRETsWithClass(a, prefA))
{
ret.Classes.Add(b);
if (ac != null)
{
ret.Classes.Add(ac);
}
}
}
else
{
foreach (PreRET reta in PreFileHelper.GetPreRETsWithClass(a, prefA))
{
foreach (PreRET retb in PreFileHelper.GetPreRETsWithClass(b, prefB))
{
reta.Merge(retb);
prefB.Rets.Remove(retb);
if (ac != null)
{
reta.Classes.Add(ac);
}
}
}
prefA.Merge(prefB);
prefiles.Remove(prefB);
}
}
}
public override void Execute(UMLRelationship r, ActionMap map, List <PreFile> prefiles)
{
UMLClass a = null;
UMLClass b = null;
int defaultDetsA = 0;
int defaultDetsB = 0;
PreFile temp, tempA, tempB;
RelationshipHelper.GetClasses(r, ref a, ref b, this.IsAlternate, ref defaultDetsA, ref defaultDetsB);
//1st File
if ((tempA = PreFileHelper.GetPreFileWithClass(a, prefiles)) == null)
{
tempA = new PreFile();
tempA.Rets.Add(new PreRET());
tempA.Rets[0].Classes.Add(a);
prefiles.Add(tempA);
}
tempA.DefaultDets += defaultDetsA;
//2nd File
if ((tempB = PreFileHelper.GetPreFileWithClass(b, prefiles)) == null)
{
tempB = new PreFile();
tempB.Rets.Add(new PreRET());
tempB.Rets[0].Classes.Add(b);
prefiles.Add(tempB);
}
tempB.DefaultDets += defaultDetsB;
//3rd File (only if there is an Association-Class)
if (r is UMLAssociation)
{
if (((UMLAssociation)r).AssociationClass != null)
{
UMLClass dependencyClass = null;
UMLClass associationClass = ((UMLAssociation)r).AssociationClass;
UMLDependencyCollection dependencies = associationClass.GetDependencies();
foreach (UMLDependency d in dependencies)
{
d.Client = Helper.GetDependencyClient <UMLClass>(d.Guid);
d.Supplier = Helper.GetDependencySupplier <UMLClass>(d.Guid);
if ((d.Client.Guid == associationClass.Guid && d.Supplier.Guid == a.Guid) ||
(d.Supplier.Guid == associationClass.Guid && d.Client.Guid == a.Guid))
{
dependencyClass = a;
}
else if ((d.Client.Guid == associationClass.Guid && d.Supplier.Guid == b.Guid) ||
(d.Supplier.Guid == associationClass.Guid && d.Client.Guid == b.Guid))
{
dependencyClass = b;
}
}
if (dependencyClass == null)
{
//temp = PreFileHelper.GetPreFileWithClass(a, prefiles);
//if (temp == null)
temp = new PreFile();
temp.Rets.Add(new PreRET());
temp.Rets[0].Classes.Add(((UMLAssociation)r).AssociationClass);
prefiles.Add(temp);
}
else if (dependencyClass == a)
{
PreRET pret = new PreRET();
pret.Classes.Add(associationClass);
tempA.Rets.Add(pret);
}
else if (dependencyClass == b)
{
PreRET pret = new PreRET();
pret.Classes.Add(associationClass);
tempB.Rets.Add(pret);
}
}
}
}
