public void StartElement(string localName, string qName, SortedList <string, string> atts)
{
if (!abort)
{
/**
* Deo neophodan za proveru ako postoji xml:base jer tada elementi, bar vecina nema nista pre #
*/
if (atts.ContainsKey(xmlBase))
{
profile.BaseNS = atts[xmlBase];
Console.WriteLine(profile.BaseNS);
}
checkedElementsCount++;
if (qName.StartsWith(rdfsNamespace) || (qName.StartsWith(cimsNamespace)))
{
documentIdentifiedLikeRDFS = true;
}
if ((!documentIdentifiedLikeRDFS) && (checkedElementsCount >= 70))
{
this.profile = null;
//occurredError = new ExtendedParseError(new Exception(documentError));
abort = true;
}
if (qName.Equals(rdfProfileElement) || qName.Equals(cimsClassCategoryElement) ||
qName.Equals(rdfsClassElement) || qName.Equals(rdfPropertyElement)) //start of new profile element
{
currentElement = new ProfileElement();
if (atts.ContainsKey(rdfAbout))
{
currentElement.URI = atts[rdfAbout];
}
else if (atts.ContainsKey(rdfId)) // some elements can have rdf:Id instead rdf:about
{
currentElement.URI = atts[rdfId];
}
switch (qName)
{
case cimsClassCategoryElement:
{
currentElement.Type = ProfileElement.TypeClassCategoryString;
break;
}
case rdfsClassElement:
{
currentElement.Type = ProfileElement.TypeClassString;
break;
}
case rdfPropertyElement:
{
currentElement.Type = ProfileElement.TypePropertyString;
break;
}
}
}
else if (qName.Equals(rdfType))
{
if (currentElement != null)
{
currentElement.Type = ExtractResourceAttributeFromElement(atts);
}
}
else if (qName.Equals(rdfsSubClassOf))
{
if (currentElement != null)
{
currentElement.SubClassOf = ExtractResourceAttributeFromElement(atts);
}
}
else if (qName.Equals(rdfsDomain))
{
if (currentElement != null)
{
string domainOfProperty = ExtractResourceAttributeFromElement(atts);
////if (domainOfProperty.StartsWith(StringManipulationManager.SeparatorSharp))
////{
//// domainOfProperty = domainOfProperty.Substring(1);
////}
currentElement.Domain = domainOfProperty;
AddBelongingInformation(currentElement.Domain);
}
}
else if (qName.Equals(rdfsRange))
{
if (currentElement != null)
{
currentElement.Range = ExtractResourceAttributeFromElement(atts);
}
}
else if (qName.Equals(cimsBelongsToCategory))
{
if (currentElement != null)
{
string belongToCategory = ExtractResourceAttributeFromElement(atts);
////if (belongToCategory.StartsWith(StringManipulationManager.SeparatorSharp))
////{
//// belongToCategory = belongToCategory.Substring(1);
////}
currentElement.BelongsToCategory = belongToCategory;
AddBelongingInformation(currentElement.BelongsToCategory);
}
}
else if (qName.Equals(cimsStereotype))
{
if (currentElement != null)
{
string stereotype = ExtractResourceAttributeFromElement(atts);
currentElement.AddStereotype(stereotype);
}
}
else if (qName.Equals(cimsDataType))
{
if (currentElement != null)
{
currentElement.DataType = ExtractResourceAttributeFromElement(atts);
}
}
else if (qName.Equals(cimsInverseRoleName))
{
if (currentElement != null)
{
currentElement.InverseRoleName = ExtractResourceAttributeFromElement(atts);
}
}
else if (qName.Equals(cimsMultiplicity))
{
if (currentElement != null)
{
currentElement.MultiplicityAsString = ExtractSimpleNameFromResourceURI(ExtractResourceAttributeFromElement(atts));
}
}
}
}
/// <summary>
/// Adds missing data to <c>entity</c> with respect to <c>modelClass</c>, and <c>package</c> from the model
/// </summary>
/// <param name="entity">ProfileElement element with missing data</param>
/// <param name="modelClass">CClass from model</param>
/// <param name="package">CPackage from model. Contains the <c>modelClass</c></param>
private void updateClassData(ProfileElement entity, CClass modelClass, CPackage package)
{
entity.AddStereotype(ProfileElementStereotype.StereotypeConcrete);
entity.URI = modelClass.name;
//PACKAGE: name and object - added "Package_" because of the current scheme
entity.BelongsToCategory = "Package_" + package.name;
entity.TypeAsEnumValue = ProfileElementTypes.Class;
entity.Label = StringManipulationManager.ExtractAllAfterSeparator(modelClass.name, StringManipulationManager.SeparatorSharp);
List <ProfileElement> packages = profile.GetAllProfileElementsOfType(ProfileElementTypes.ClassCategory);
foreach (ProfileElement pack in packages)
{
if (pack.UniqueName.Equals(entity.BelongsToCategory))
{
entity.BelongsToCategoryAsObject = pack;
pack.AddToMembersOfClassCategory(entity);
break;
}
}
//if package is not found, look for it in the model
//-----------------------------------------------------------------------------
if (entity.BelongsToCategoryAsObject == null)
{
//looking for package (and we know which one - CPackage) and adding it to hierarchy
ProfileElement newPackage = new ProfileElement();
newPackage.Label = package.name;
newPackage.URI = "Package_" + package.name;
//create separate package - detached from hierarchy, because we wont need it
newPackage.TypeAsEnumValue = ProfileElementTypes.ClassCategory;
newPackage.AddToMembersOfClassCategory(entity);
entity.BelongsToCategoryAsObject = newPackage;
entity.BelongsToCategory = newPackage.UniqueName;
profile.GetAllProfileElementsOfType(ProfileElementTypes.ClassCategory).Add(newPackage);
}
//-----------------------------------------------------------------------------
//PARENT: assumption is that all the classes needed are in profile,
//we dont need to add additional, not mentioned in profile
entity.SubClassOf = modelClass.parentClassName == null ? string.Empty : modelClass.parentClassName;
if (!string.IsNullOrEmpty(entity.SubClassOf))
{
bool foundInModel = false;
List <ProfileElement> classes = profile.GetAllProfileElementsOfType(ProfileElementTypes.Class);
foreach (ProfileElement temp in classes)
{
if (temp.URI.Equals(entity.SubClassOf))
{
entity.SubClassOfAsObject = temp;
break;
}
}
if (!foundInModel)
{
entity.SubClassOf = string.Empty;
}
}
//FIELDS
foreach (CAttribute att in modelClass.attributes)
{
addAttributeToElement(entity, att, modelClass);
}
}
