private UML.Classes.Kernel.Property addProperty(UML.Classes.Kernel.Class clazz,
string name,
string type = null,
string stereotype = null)
{
var property =
this.model.factory.createNewElement <UML.Classes.Kernel.Property>(
clazz, name
);
if (type != null)
{
property.type = this.model.factory.createPrimitiveType(type);
}
if (stereotype != null)
{
var stereotypes = new HashSet <UML.Profiles.Stereotype>();
stereotypes.Add(new TSF_EA.Stereotype(
this.model, property as TSF_EA.Element, stereotype)
);
property.stereotypes = stereotypes;
}
property.save();
return(property);
}
private UML.Classes.Kernel.Association addAssociation(UML.Classes.Kernel.Class source,
UML.Classes.Kernel.Class target,
string targetMultiplicity = null,
string dependsOn = null)
{
var association =
this.model.factory.createNewElement <UML.Classes.Kernel.Association>(
source, dependsOn
);
association.addRelatedElement(target);
//set source multiplicity and aggregationkind
((TSF_EA.Association)association).sourceEnd.aggregation = UML.Classes.Kernel.AggregationKind.composite;
if (targetMultiplicity == null)
{
targetMultiplicity = "1"; //default target multiplicity
}
if (targetMultiplicity != null)
{
((TSF_EA.Association)association).targetEnd.EAMultiplicity =
new TSF_EA.Multiplicity(targetMultiplicity);
}
//set target navibable
((TSF_EA.Association)association).targetEnd.isNavigable = true;
association.save();
return(association);
}
private static T CreateFrom(UML.Classes.Kernel.Class clazz)
{
GlossaryItem item;
Type TType = typeof(T);
if (TType == typeof(BusinessItem))
{
item = new BusinessItem();
}
else if (TType == typeof(DataItem))
{
item = new DataItem();
}
else
{
return(null);
}
if (!clazz.stereotypes.Any(x => x.name.Equals(item.Stereotype)))
{
return(null);
}
item.Origin = clazz as TSF_EA.ElementWrapper;
return((T)item);
}
private bool SynchronizeUmlItemTags(UML.UMLItem umlItem, ref string TagName, ref string TagValue, ref string TagNotes)
{
inSyncUmlItem = true;
try {
if (umlItem is UML.Classes.Kernel.Class)
{
UML.Classes.Kernel.Class classItem = umlItem as UML.Classes.Kernel.Class;
}
else if (umlItem is UML.Classes.Interfaces.Interface)
{
return(SynchronizeUmlItemTags(umlItem as UML.Classes.Interfaces.Interface, ref TagName, ref TagValue, ref TagNotes));
}
else if (umlItem is UML.Classes.Kernel.Operation)
{
return(SynchronizeUmlItemTags(umlItem as UML.Classes.Kernel.Operation, ref TagName, ref TagValue, ref TagNotes));
}
}
catch (Exception ex) {
inSyncUmlItem = false;
throw ex;
}
finally {
inSyncUmlItem = false;
}
return(false);
}
public virtual DB.Table transformLogicalClass(UML.Classes.Kernel.Class logicalClass)
{
//create the table
createTable((UTF_EA.Class)logicalClass);
//add the class as logical class
_table.logicalClasses.Add((UTF_EA.Class)logicalClass);
//create the columns from the attributes
createColumnsFromAttributes();
return(this.table);
}
public override void Update(UML.Classes.Kernel.Class clazz)
{
base.Update(clazz);
var eaClass = clazz as TSF_EA.ElementWrapper;
eaClass.notes = this.Description;
eaClass.addTaggedValue("domain", this.Domain);
clazz.save();
}
private TSF_EA.Generalization addGeneralization(UML.Classes.Kernel.Class parent,
UML.Classes.Kernel.Class child)
{
var generalization =
this.model.factory.createNewElement <TSF_EA.Generalization>(
child, string.Empty
);
generalization.addRelatedElement(parent);
generalization.save();
return(generalization);
}
private T CreateFrom <T>(UML.Classes.Kernel.Class clazz) where T : GlossaryItem, new()
{
T item = new T();
if (!clazz.stereotypes.Any(x => x.name.Equals(item.Stereotype)))
{
return(null);
}
item.settings = this.settings;
item.origin = clazz as TSF_EA.ElementWrapper;
return(item);
}
public virtual void Update(UML.Classes.Kernel.Class clazz)
{
var eaClass = clazz as TSF_EA.ElementWrapper;
eaClass.name = this.Name;
eaClass.author = this.Author;
eaClass.version = this.Version;
eaClass.status = this.Status;
eaClass.keywords = this.Keywords;
eaClass.created = this.CreateDate;
eaClass.modified = this.UpdateDate;
this.origin.addTaggedValue("modifier", this.UpdatedBy);
eaClass.save();
}
public override void Update(UML.Classes.Kernel.Class clazz)
{
base.Update(clazz);
var eaClass = clazz as TSF_EA.ElementWrapper;
eaClass.addTaggedValue("label", this.Label);
if (logicalDatatype != null)
{
eaClass.addTaggedValue("logical datatype", this.logicalDatatype.wrappedDatatype);
}
eaClass.addTaggedValue("size", this.Size.ToString());
eaClass.addTaggedValue("format", this.Format);
eaClass.addTaggedValue("initial value", this.InitialValue);
eaClass.notes = this.Description;
clazz.save();
}
public T FromClass <T>(UML.Classes.Kernel.Class clazz) where T : GlossaryItem, new()
{
if (clazz == null)
{
return(null);
}
if (clazz.stereotypes.Count != 1)
{
return(null);
}
GlossaryItem item = this.CreateFrom <T>(clazz);
if (item == null)
{
return(null);
}
return((T)item);
}
public static T FromClass(UML.Classes.Kernel.Class clazz)
{
if (clazz == null)
{
return(null);
}
if (clazz.stereotypes.Count != 1)
{
return(null);
}
GlossaryItem item = GlossaryItemFactory <T> .CreateFrom(clazz);
if (item == null)
{
return(null);
}
return((T)item);
}
private bool IsTrackedUmlItem(UML.UMLItem umlItem)
{
if (umlItem is UML.Classes.Kernel.Class)
{
UML.Classes.Kernel.Class classItem = umlItem as UML.Classes.Kernel.Class;
}
else if (umlItem is UML.Classes.Interfaces.Interface)
{
UML.Classes.Interfaces.Interface interfaceItem = umlItem as UML.Classes.Interfaces.Interface;
if (HasSterotype(C_ExtStereotypes.funptr, interfaceItem.stereotypes))
{
return(true);
}
}
else if (umlItem is UML.Classes.Kernel.Operation)
{
UML.Classes.Kernel.Operation opItem = umlItem as UML.Classes.Kernel.Operation;
if (HasSterotype(C_ExtStereotypes.funptr, opItem.stereotypes))
{
return(true);
}
}
return(false);
}
public bool IsA <T>(UML.Classes.Kernel.Class clazz) where T : GlossaryItem, new()
{
return(this.CreateFrom <T>(clazz) != null);
}
public static bool IsA(UML.Classes.Kernel.Class clazz)
{
return(GlossaryItemFactory <T> .CreateFrom(clazz) != null);
}
