private void addPossibleEntriesToComboBoxSQL()
{
//use sql commands to search the repository for possible entries in the types combobox
//get ids and names of all eclasses and the names of the packages the eclasses are contained sorted by eclass name
String sqlResult = sqlRepository.SQLQuery("select a.Name AS Name, a.Object_ID, a.ea_guid, b.Name as PackageName, a.Stereotype from t_object a,t_package b where ( a.stereotype = '" + ECOREModelingMain.EClassStereotype + "' OR a.stereotype = '" + TGGModelingMain.TggRuleStereotype + "' OR a.stereotype = '" + TGGModelingMain.TggCorrespondenceTypeStereotype + "') and a.Package_ID = b.Package_ID ORDER BY a.Name");
foundData.AddRange(EAEcoreAddin.Util.EAUtil.getXMLNodeContentFromSQLQueryString(sqlResult, "Row"));
foreach (String row in foundData)
{
EClass classifier = new EClass(new SQLElement(sqlRepository, row), sqlRepository);
Boolean shouldAddClassifier = true;
if (ovType == TGGModelingMain.TggCorrespondenceStereotype && classifier.EaElement.Stereotype != TGGModelingMain.TggCorrespondenceTypeStereotype)
{
shouldAddClassifier = false;
}
if (shouldAddClassifier)
{
printClassifier(classifier, EAEcoreAddin.Util.EAUtil.getXMLNodeContentFromSQLQueryString(row, "PackageName")[0]);
addClassifier(classifier);
}
}
if (classifierId > 0)
{
this.Text = this.Items[this.ClassifierIDs.IndexOf(classifierId)] as String;
}
else
{
this.Text = this.Items[0] as String;
}
}
public static EPackage GenerateModel2()
{
var package = new EPackage
{
Name = "model2",
NsPrefix = "model2",
NsURI = "http://www.transformation-tool-contest.eu/2017/LiveContest/testModels/model2"
};
var classA = new EClass {
Name = "A"
};
var classB = new EClass {
Name = "B"
};
var classC = new EClass {
Name = "C"
};
var classD = new EClass {
Name = "D"
};
var classE = new EClass {
Name = "E"
};
classA.EStructuralFeatures.Add(new EReference
{
Name = "PropA",
EType = classE
});
classB.EStructuralFeatures.Add(new EReference
{
Name = "PropB",
EType = classE,
Refines = classA.EStructuralFeatures[0] as IEReference
});
classC.EStructuralFeatures.Add(new EReference
{
Name = "PropC",
EType = classE
});
classD.EStructuralFeatures.Add(new EReference
{
Name = "PropD",
EType = classE
});
classB.ESuperTypes.Add(classA);
classC.ESuperTypes.Add(classA);
classD.ESuperTypes.Add(classB);
classD.ESuperTypes.Add(classC);
package.EClassifiers.Add(classA);
package.EClassifiers.Add(classB);
package.EClassifiers.Add(classC);
package.EClassifiers.Add(classD);
package.EClassifiers.Add(classE);
return(package);
}
private void label1_Click(object sender, EventArgs e)
{
if (OnClass == null)
{
return;
}
switch (rClass)
{
case EClass.Class1:
rClass = EClass.Class2;
break;
case EClass.Class2:
rClass = EClass.Brak;
break;
case EClass.Brak:
rClass = EClass.Class1;
break;
case EClass.Dead:
case EClass.None:
break;
}
RClass = rClass;
OnClass(rClass);
}
protected void createEReference(EClass owner, int id)
{
EReferenceImpl r = (EReferenceImpl)ecoreFactory.createEReference();
r.setFeatureID(id);
owner.eStructuralFeatures.add(r);
}
public bool EA_OnPostNewElement(SQLRepository sqlRepository, EA.Element newElement2, EA.Diagram currentDiagram)
{
SQLElement newElement = sqlRepository.GetElementByID(newElement2.ElementID);
if (ECOREModelingMain.EcoreDiagramMetatype.Contains(currentDiagram.MetaType) || TGGModelingMain.TggSchemaDiagramMetatype.Contains(currentDiagram.MetaType))
{
if (newElement.Stereotype.ToLower() == EClassStereotype.ToLower())
{
EClass eClass = new EClass(newElement, sqlRepository);
eClass.saveTreeToEATaggedValue(false);
return(true);
}
else if (newElement.Stereotype.ToLower() == EDatatypeStereotype.ToLower())
{
EDatatype eDataType = new EDatatype(newElement, sqlRepository);
eDataType.saveTreeToEATaggedValue(false);
return(true);
}
else if (newElement.Stereotype.ToLower() == EEnumStereotype.ToLower())
{
EEnum eEnum = new EEnum(newElement, sqlRepository);
eEnum.saveTreeToEATaggedValue(false);
return(true);
}
}
return(false);
}
public MocaNode processEClass(SQLElement eaClass)
{
SQLTaggedValue refactorTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaClass, Main.MoflonRefactorTreeTaggedValueName);
if (refactorTreeTag != null)
{
EClass eClass = new EClass(eaClass, repository);
eClass.loadTreeFromTaggedValue();
MocaNode eClassMocaNode = MocaTreeUtil.mocaNodeFromXmlString(refactorTreeTag.Notes);
eClass.addMocaAttributesDuringExport(eClassMocaNode);
//add baseclass dependencies
/*foreach (var baseClass in eClassMocaNode.getAttributeOrCreate("baseClasses").Value.Split(" ".ToArray()))
* {
* if (baseClass != "")
* {
* SQLElement baseclass = repository.GetElementByGuid(baseClass);
* Export.computeAndAddToDependencies(repository, baseclass);
* }
* }*/
this.currentNode.appendChildNode(eClassMocaNode);
return(eClassMocaNode);
}
return(null);
}
private static string GetPointsObjName(EClass pClass)
{
string prefix = pClass.ToString();
string suffix = "Points";
return(prefix + suffix);
}
private Int32 UpdateAbilities(EClass p_class)
{
for (Int32 i = 0; i < 2; i++)
{
m_abilityDesc[i].text = String.Empty;
m_abilityHeader[i].text = String.Empty;
NGUITools.SetActive(m_abilityIcon[i].gameObject, false);
NGUITools.SetActive(m_abilityBorder[i].gameObject, false);
}
Int32 num = 0;
List <ParagonAbilitiesStaticData> list = new List <ParagonAbilitiesStaticData>(StaticDataHandler.GetIterator <ParagonAbilitiesStaticData>(EDataType.PARAGON_ABILITES));
foreach (ParagonAbilitiesStaticData paragonAbilitiesStaticData in list)
{
if (paragonAbilitiesStaticData.Class == p_class)
{
m_abilityDesc[num].text = paragonAbilitiesStaticData.GetDescription();
m_abilityHeader[num].text = LocaManager.GetText(paragonAbilitiesStaticData.NameKey);
m_abilityIcon[num].spriteName = paragonAbilitiesStaticData.Icon;
NGUITools.SetActive(m_abilityIcon[num].gameObject, true);
NGUITools.SetActive(m_abilityBorder[num].gameObject, true);
num++;
}
}
return(num);
}
public void Union(int a, int b)
{
EClass biggerClass = null;
EClass smallerClass = null;
if (equivalClasses[a].Size > equivalClasses[b].Size)
{
biggerClass = equivalClasses[a];
smallerClass = equivalClasses[b];
biggerClass.Size += equivalClasses[b].Size;
}
else
{
biggerClass = equivalClasses[b];
smallerClass = equivalClasses[a];
biggerClass.Size += equivalClasses[a].Size;
}
var keys = new List <int>(equivalClasses.Keys);
foreach (var key in keys)
{
if (equivalClasses[key].Name == smallerClass.Name)
{
equivalClasses[key] = biggerClass;
}
}
}
protected void createEAttribute(EClass owner, int id)
{
EAttributeImpl a = (EAttributeImpl)ecoreFactory.createEAttribute();
a.setFeatureID(id);
owner.eStructuralFeatures.add(a);
}
public static EClass Convert(this EClientClass cls)
{
string memberName = cls.ToString();
EClass serverClass = (EClass)Enum.Parse(typeof(EClass), memberName);
return(serverClass);
}
protected EClass initEClass(EClass c, Type instanceClass, string name, bool isAbstract, bool isInterface, bool isGenerated)
{
initEClassifier(c, ecorePackage.getEClass(), instanceClass, name, isGenerated);
c.abstract_ = isAbstract;
c.interface_ = isInterface;
return(c);
}
public MocaNode processEClass(SQLElement eaClass)
{
SQLTaggedValue changesTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(eaClass, Main.MoflonChangesTreeTaggedValueName);
if (changesTreeTag != null)
{
EClass eClass = new EClass(eaClass, repository);
eClass.loadTreeFromTaggedValue();
MocaNode eClassMocaNode = MocaTreeUtil.mocaNodeFromXmlString(changesTreeTag.Notes);
eClass.addMocaAttributesDuringExport(eClassMocaNode);
this.currentNode.appendChildNode(eClassMocaNode);
if (eClassMocaNode.hasAllAttributes(new List <string>(
new string[] { ChangesTreeConstants.ATTRIBUTE_KEY_PACKAGE_NAME, ChangesTreeConstants.ATTRIBUTE_KEY_PROJECT_NAME })))
{
String packageName = eClassMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_PACKAGE_NAME).Value;
String projectName = eClassMocaNode.getAttribute(ChangesTreeConstants.ATTRIBUTE_KEY_PROJECT_NAME).Value;
CachedClass temp = new CachedClass();
temp.getElement(eaClass.ElementGUID, repository);
temp.name = eClass.Name;
temp.previousName = eClass.Name;
temp.packageName = packageName;
temp.projectName = projectName;
temp.saveElementToEATaggedValue(true);
return(eClassMocaNode);
}
}
return(null);
}
public void CalcClassGain(double _gain)
{
TypeSize ts = ParAll.ST.TSSet.Current;
if (Tp == EUnit.Line)
{
TSLine tsl = ParAll.CTS.Line;
Class = EClass.None;
foreach (Meas m in MMeas)
{
m.Class = Classer.GetDefClass(m.FilterABC * _gain, tsl.Borders, m.Dead);
m.ClassIn = Classer.GetDefClass(m.FilterInABC * _gain, tsl.BordersIn, m.Dead);
Class = Classer.Compare(Class, m.Class);
}
}
else
{
TSCross tsc = ParAll.CTS.Cross;
Class = EClass.None;
foreach (Meas m in MMeas)
{
m.Class = Classer.GetDefClass(m.FilterABC * _gain, tsc.Borders, m.Dead);
Class = Classer.Compare(Class, m.Class);
}
}
}
/// <summary>
/// Add points of given class to the partitions
/// </summary>
public static void AddPoints(EClass pClass)
{
for (int x = 0; x < CProjectData.Points.groundArray.arrayXRange; x += partitionStepSize)
{
for (int y = 0; y < CProjectData.Points.groundArray.arrayYRange; y += partitionStepSize)
{
List <Vector3> points = new List <Vector3>();
for (int _x = x; _x < x + partitionStepSize; _x++)
{
for (int _y = y; _y < y + partitionStepSize; _y++)
{
CField element = CProjectData.Points.GetField(pClass, _x, _y);
//CField element = CProjectData.Points.groundArray.GetField(_x, _y);
if (element != null)
{
points.AddRange(element.points);
}
}
}
Obj pointsObj = new Obj(GetPointsObjName(pClass));
CObjExporter.AddPointsToObj(ref pointsObj, points);
pointsObj.UseMtl = CMaterialManager.GetPointsMaterial(pClass).Name;
AddObj(x, y, pointsObj);
}
}
}
private static string GetClassColor(EClass pClass)
{
switch (pClass)
{
case EClass.Ground:
return(GROUND_COLOR);
case EClass.Building:
return(BUILDING_COLOR);
case EClass.Unassigned:
return(UNASIGNED_COLOR);
case EClass.Balls:
return(BALLS_COLOR);
case EClass.BallsMainPoints:
return(BALLS_MP_COLOR);
case EClass.BallsCenters:
return(BALLS_CENTER_COLOR);
case EClass.BallsSurface:
return(BALLS_SURFACE_COLOR);
}
return(UNDEFINED_COLOR);
}
/// <summary>
/// Generate a character
/// </summary>
/// <param name="CharacterClass"></param>
/// <returns></returns>
public static CharacterData CreateCharacter(EClass CharacterClass = EClass.Conjurer)
{
// CharacterData Character = new CharacterData(-1, "Fake McGee", "", "", )
CharacterData Character = new CharacterData(-1, NameGenerator.GenerateFullElvenName(), "", ERace.Human, CharacterClass, EGender.Male, 1);
return(Character);
}
protected void createEOperation(EClass owner, int id)
{
EOperationImpl o = (EOperationImpl)ecoreFactory.createEOperation();
o.setOperationID(id);
owner.eOperations.add(o);
}
public override MocaNode serializeToMocaTree()
{
EClass dummyEClass = new EClass(this.rule, Repository);
dummyEClass.computeFeatures();
MocaNode ruleNode = dummyEClass.serializeToMocaTree();
ruleNode.Name = "Rule";
MocaNode operationsNode = ruleNode.getChildNodeWithName(EClass.OperationsChildNodeName);
MocaNode toDelete = null;
if (operationsNode != null)
{
foreach (MocaNode node in operationsNode.Children)
{
MocaAttribute nameAttr = node.getAttributeOrCreate("name");
if (nameAttr != null && nameAttr.Value == this.Name)
{
toDelete = node;
}
}
}
if (toDelete != null)
{
operationsNode.Children.Remove(toDelete);
}
ruleNode.appendChildAttribute(TGGRule.CspSpecAttributeName, "");
ruleNode.appendChildAttribute("refines", "");
ruleNode.appendChildAttribute("baseClasses", "");
ruleNode.appendChildNode(StoryPattern.ObjectVariablesChildNodeName);
return(ruleNode);
}
public static int ToImageIndex(this EClass Class)
{
switch (Class)
{
case EClass.Fighter_Human:
case EClass.Warrior_Nordein:
return(0);
case EClass.Defender_Human:
case EClass.Guardian_Nordein:
return(1);
case EClass.Priest_Human:
case EClass.Oracle_Vail:
return(2);
case EClass.Mage_Elf:
case EClass.Pagan_Vail:
return(3);
case EClass.Ranger_Elf:
case EClass.Assasin_Vail:
return(4);
case EClass.Archer_Elf:
case EClass.Hunter_Nordein:
return(5);
default:
return(-1);
}
}
public bool validate(EClass eClass, EObject eObject, DiagnosticChain diagnostics, Dictionary <object, object> context)
{
Object eValidator = null;
EClass eType = eClass;
//while ((eValidator = eValidatorRegistry.get(eType.eContainer())) == null)
while (!eValidatorRegistry.ContainsKey(eType.eContainer() as EPackage))
{
eValidator = eValidatorRegistry[eType.eContainer() as EPackage];
List <EClass> eSuperTypes = eType.eSuperTypes;
if (eSuperTypes.Count == 0)
{
//TODO return a defaultCase
eValidator = null;// eValidatorRegistry.get(null);
break;
}
else
{
eType = eSuperTypes.ElementAt(0);
}
}
//bool circular = context.get(EObjectValidator.ROOT_OBJECT) == eObject;
//TODO containskey check
bool circular = context[EObjectValidator.ROOT_OBJECT] == eObject;
bool result = doValidate((EValidator)eValidator, eClass, eObject, diagnostics, context);
if ((result || diagnostics != null) && !circular)
{
result &= doValidateContents(eObject, diagnostics, context);
}
return(result);
}
public void EA_OnNotifyContextItemModified(EA.Repository Repository, String GUID, EA.ObjectType ot)
{
SQLRepository sqlRepository = new SQLRepository(Repository, false);
if (ot == EA.ObjectType.otPackage)
{
EA.Package eaPackage = Repository.GetPackageByGuid(GUID);
if (eaPackage.Element.Stereotype.ToLower() == ECOREModelingMain.EPackageStereotype.ToLower())
{
EPackage ePackage = new EPackage(sqlRepository.GetPackageByID(eaPackage.PackageID), sqlRepository);
Main.addToTreeQueue(GUID, ePackage);
}
// track changes for metamodelevolution
savePackageChangesToEATaggedValue(sqlRepository, GUID);
}
if (ot == EA.ObjectType.otElement)
{
SQLElement eaElement = sqlRepository.GetElementByGuid(GUID);
if (eaElement.Stereotype.ToLower() == EClassStereotype.ToLower() && eaElement.Type == Main.EAClassType)
{
EClass eClass = new EClass(eaElement, sqlRepository);
eClass.saveTreeToEATaggedValue(false);
// track changes for metamodelevolution
saveElementChangesToEATaggedValue(eaElement, GUID, sqlRepository);
}
else if (eaElement.Stereotype.ToLower() == EDatatypeStereotype.ToLower())
{
EDatatype eDataType = new EDatatype(eaElement, sqlRepository);
eDataType.saveTreeToEATaggedValue(false);
}
else if (eaElement.Stereotype.ToLower() == EEnumStereotype.ToLower())
{
EEnum eEnum = new EEnum(eaElement, sqlRepository);
eEnum.saveTreeToEATaggedValue(false);
}
}
if (ot == EA.ObjectType.otConnector)
{
SQLConnector eaConnector = sqlRepository.GetConnectorByGuid(GUID);
if (eaConnector.Type == EReferenceConnectorType && (eaConnector.Stereotype == "" || eaConnector.Stereotype.ToLower() == "ereference"))
{
EReference clientReference = new EReference(eaConnector, sqlRepository);
clientReference.saveTreeToEATaggedValue(false);
}
else if (eaConnector.Type == InheritanceConnectorType)
{
SQLElement connectorSource = sqlRepository.GetElementByID(eaConnector.ClientID);
if (connectorSource.Stereotype == EClassStereotype)
{
EClass eClass = new EClass(connectorSource, sqlRepository);
eClass.saveTreeToEATaggedValue(false);
}
}
}
}
public void addClassifier(EClass classifier)
{
if (!ClassifierIDs.Contains(classifier.EaElement.ElementID))
{
ClassifierIDs.Add(classifier.EaElement.ElementID);
Classifiers.Add(classifier);
}
}
public ZoneThickLite(int _index, double?_Level, EClass _CLass, int _length, bool _last)
: this(_index)
{
Length = _length;
Last = _last;
Level = _Level;
Class = _CLass;
}
public MClass(ClassParams c, EClass t)
{
this._perksByLevel = new Dictionary <int, List <MPerk> >();
this._primaryStatsPerLevel = c.PrimaryStats;
this._secondaryStatsPerLevel = c.SecondaryStats;
this.Level = 0;
this._type = t;
}
ZoneThickLite(int _index)
{
Index = _index;
Length = 0;
Last = false;
Level = null;
Class = EClass.None;
}
public MyQuest(uint id, QuestAction questAction, ERace race, EClass _class)
{
Id = id;
Race.Add(race);
Class.Add(_class);
QuestAction = questAction;
Team = ETeam.Other;
Index = -2;
}
private void initEClassifier(EClassifier o, EClass metaObject, Type instanceClass, string name)
{
o.name = name;
if (instanceClass != null)
{
//hack: Originally setInstanceClass was defined manually in the EClassifier interface. Manual changes to the interface are not allowed anymore.
(o as EClassifierImpl).setInstanceClass(instanceClass);
}
}
public void CopyToTest()
{
var a = new[] { new EClass(1), new EClass(2) };
var l = new EventedList <EClass>(a);
var a2 = new EClass[2];
l.CopyTo(a2, 0);
Assert.That(a, Is.EquivalentTo(a));
}
public void CopyToTest1()
{
var a = new[] { new EClass(1), new EClass(2) };
var l = new EventedList <EClass>(a);
var a2 = new EClass[1];
l.CopyTo(1, a2, 0, 1);
Assert.That(a2[0], Is.EqualTo(a[1]));
}
protected ClassCard(EClass heroClass)
{
Class = heroClass;
}
