You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
340 lines
13 KiB
340 lines
13 KiB
/***************************************************************************
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* copyright (C) 2003-2007 *
|
|
* Umbrello UML Modeller Authors <uml-devel@uml.sf.net> *
|
|
***************************************************************************/
|
|
|
|
// own header
|
|
#include "umlrole.h"
|
|
|
|
// qt/kde includes
|
|
#include <kdebug.h>
|
|
#include <tqregexp.h>
|
|
|
|
// local includes
|
|
#include "association.h"
|
|
#include "umldoc.h"
|
|
#include "uml.h"
|
|
|
|
|
|
// constructor
|
|
UMLRole::UMLRole(UMLAssociation * parent, UMLObject * parentObj, Uml::Role_Type role)
|
|
: UMLObject(const_cast<UMLAssociation*>(parent))
|
|
{
|
|
init(parent, parentObj, role);
|
|
}
|
|
|
|
UMLRole::~UMLRole() { }
|
|
|
|
bool UMLRole::operator==(UMLRole &rhs) {
|
|
if (this == &rhs) {
|
|
return true;
|
|
}
|
|
return ( UMLObject::operator==( rhs ) &&
|
|
m_Changeability == rhs.m_Changeability &&
|
|
m_Multi == rhs.m_Multi &&
|
|
m_Name == rhs.m_Name
|
|
);
|
|
}
|
|
|
|
UMLAssociation * UMLRole::getParentAssociation () {
|
|
return m_pAssoc;
|
|
}
|
|
|
|
UMLObject* UMLRole::getObject() {
|
|
return m_pSecondary;
|
|
}
|
|
|
|
Uml::Changeability_Type UMLRole::getChangeability() const {
|
|
return m_Changeability;
|
|
}
|
|
|
|
TQString UMLRole::getMultiplicity() const {
|
|
return m_Multi;
|
|
}
|
|
|
|
void UMLRole::setObject (UMLObject *obj) {
|
|
// because we will get the id of this role from the parent
|
|
// object, we CANT allow UMLRoles to take other UMLRoles as
|
|
// parent objects. In fact, there is probably good reason
|
|
// to only take UMLClassifiers here, but I'll leave it more open
|
|
// for the time being. -b.t.
|
|
if (obj && dynamic_cast<UMLRole*>(obj)) {
|
|
kError() << "UMLRole(" << ID2STR(m_nId) << ") cannot setObject() to another UMLRole("
|
|
<< ID2STR(obj->getID()) << ")" << endl;
|
|
return;
|
|
}
|
|
|
|
m_pSecondary = obj;
|
|
UMLObject::emitModified();
|
|
}
|
|
|
|
void UMLRole::setChangeability (Uml::Changeability_Type value) {
|
|
m_Changeability = value;
|
|
UMLObject::emitModified();
|
|
}
|
|
|
|
void UMLRole::setMultiplicity ( const TQString &multi ) {
|
|
m_Multi = multi;
|
|
UMLObject::emitModified();
|
|
}
|
|
|
|
Uml::Role_Type UMLRole::getRole() {
|
|
return m_role;
|
|
}
|
|
|
|
void UMLRole::init(UMLAssociation * parent, UMLObject * parentObj, Uml::Role_Type r) {
|
|
m_BaseType = Uml::ot_Role;
|
|
m_role = r;
|
|
m_pAssoc = parent;
|
|
m_pSecondary = parentObj;
|
|
m_Multi = "";
|
|
m_Name = "";
|
|
m_Changeability = Uml::chg_Changeable;
|
|
|
|
// connect this up to parent
|
|
connect(this,TQ_SIGNAL(modified()),parent,TQ_SIGNAL(modified()));
|
|
}
|
|
|
|
void UMLRole::saveToXMI( TQDomDocument & qDoc, TQDomElement & qElement ) {
|
|
TQDomElement roleElement = UMLObject::save("UML:AssociationEnd", qDoc);
|
|
if (m_pSecondary)
|
|
roleElement.setAttribute( "type", ID2STR(m_pSecondary->getID()) );
|
|
else
|
|
kError() << "UMLRole::saveToXMI(id " << ID2STR(m_nId)
|
|
<< "): m_pSecondary is NULL" << endl;
|
|
if (!m_Multi.isEmpty())
|
|
roleElement.setAttribute("multiplicity", m_Multi);
|
|
if (m_role == Uml::A) { // role aggregation based on parent type
|
|
// role A
|
|
switch (m_pAssoc->getAssocType()) {
|
|
case Uml::at_Composition:
|
|
roleElement.setAttribute("aggregation", "composite");
|
|
break;
|
|
case Uml::at_Aggregation:
|
|
roleElement.setAttribute("aggregation", "aggregate");
|
|
break;
|
|
default:
|
|
roleElement.setAttribute("aggregation", "none");
|
|
break;
|
|
}
|
|
if (m_pAssoc->getAssocType() == Uml::at_UniAssociation) {
|
|
// Normally the isNavigable attribute is "true".
|
|
// We set it to false on role A to indicate that
|
|
// role B gets an explicit arrowhead.
|
|
roleElement.setAttribute("isNavigable", "false");
|
|
} else {
|
|
roleElement.setAttribute("isNavigable", "true");
|
|
}
|
|
} else {
|
|
roleElement.setAttribute("aggregation", "none");
|
|
roleElement.setAttribute("isNavigable", "true");
|
|
//FIXME obviously this isn't standard XMI
|
|
if (m_pAssoc->getAssocType() == Uml::at_Relationship) {
|
|
roleElement.setAttribute("relationship", "true");
|
|
}
|
|
}
|
|
|
|
roleElement.setAttribute("visibility", getVisibility().toString(false));
|
|
|
|
switch (m_Changeability) {
|
|
case Uml::chg_Frozen:
|
|
roleElement.setAttribute("changeability", "frozen");
|
|
break;
|
|
case Uml::chg_AddOnly:
|
|
roleElement.setAttribute("changeability", "addOnly");
|
|
break;
|
|
case Uml::chg_Changeable:
|
|
roleElement.setAttribute("changeability", "changeable");
|
|
break;
|
|
}
|
|
qElement.appendChild( roleElement );
|
|
}
|
|
|
|
bool UMLRole::load( TQDomElement & element ) {
|
|
UMLDoc * doc = UMLApp::app()->getDocument();
|
|
TQString type = element.attribute("type", "");
|
|
if (!type.isEmpty()) {
|
|
if (!m_SecondaryId.isEmpty())
|
|
kWarning() << "UMLRole::load: overwriting old m_SecondaryId \""
|
|
<< m_SecondaryId << " with new value \""
|
|
<< type << "\"" << endl;
|
|
m_SecondaryId = type;
|
|
}
|
|
// Inspect child nodes - for multiplicity (and type if not set above.)
|
|
for (TQDomNode node = element.firstChild(); !node.isNull(); node = node.nextSibling()) {
|
|
if (node.isComment())
|
|
continue;
|
|
TQDomElement tempElement = node.toElement();
|
|
TQString tag = tempElement.tagName();
|
|
if (Uml::tagEq(tag, "name")) {
|
|
m_Name = tempElement.text();
|
|
} else if (Uml::tagEq(tag, "AssociationEnd.multiplicity")) {
|
|
/**
|
|
* There are different ways in which the multiplicity might be given:
|
|
* - direct value in the <AssociationEnd.multiplicity> tag,
|
|
* - attributes "lower" and "upper" of a subordinate <MultiplicityRange>,
|
|
* - direct value in subordinate <MultiplicityRange.lower> and
|
|
* <MultiplicityRange.upper> tags
|
|
*/
|
|
TQDomNode n = tempElement.firstChild();
|
|
if (node.isNull() || tempElement.isNull() || n.isNull() ||
|
|
n.toElement().isNull()) {
|
|
m_Multi = tempElement.text().stripWhiteSpace();
|
|
continue;
|
|
}
|
|
tempElement = n.toElement();
|
|
tag = tempElement.tagName();
|
|
if (!Uml::tagEq(tag, "Multiplicity")) {
|
|
m_Multi = tempElement.text().stripWhiteSpace();
|
|
continue;
|
|
}
|
|
n = tempElement.firstChild();
|
|
tempElement = n.toElement();
|
|
tag = tempElement.tagName();
|
|
if (!Uml::tagEq(tag, "Multiplicity.range")) {
|
|
m_Multi = tempElement.text().stripWhiteSpace();
|
|
continue;
|
|
}
|
|
n = tempElement.firstChild();
|
|
tempElement = n.toElement();
|
|
tag = tempElement.tagName();
|
|
if (!Uml::tagEq(tag, "MultiplicityRange")) {
|
|
m_Multi = tempElement.text().stripWhiteSpace();
|
|
continue;
|
|
}
|
|
TQString multiUpper;
|
|
if (tempElement.hasAttribute("lower")) {
|
|
m_Multi = tempElement.attribute("lower", "");
|
|
multiUpper = tempElement.attribute("upper", "");
|
|
if (!multiUpper.isEmpty()) {
|
|
if (!m_Multi.isEmpty())
|
|
m_Multi.append("..");
|
|
m_Multi.append(multiUpper);
|
|
}
|
|
continue;
|
|
}
|
|
n = tempElement.firstChild();
|
|
while (!n.isNull()) {
|
|
tempElement = n.toElement();
|
|
tag = tempElement.tagName();
|
|
if (Uml::tagEq(tag, "MultiplicityRange.lower")) {
|
|
m_Multi = tempElement.text();
|
|
} else if (Uml::tagEq(tag, "MultiplicityRange.upper")) {
|
|
multiUpper = tempElement.text();
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
if (!multiUpper.isEmpty()) {
|
|
if (!m_Multi.isEmpty())
|
|
m_Multi.append("..");
|
|
m_Multi.append(multiUpper);
|
|
}
|
|
} else if (m_SecondaryId.isEmpty() &&
|
|
(Uml::tagEq(tag, "type") ||
|
|
Uml::tagEq(tag, "participant"))) {
|
|
m_SecondaryId = tempElement.attribute("xmi.id", "");
|
|
if (m_SecondaryId.isEmpty())
|
|
m_SecondaryId = tempElement.attribute("xmi.idref", "");
|
|
if (m_SecondaryId.isEmpty()) {
|
|
TQDomNode inner = tempElement.firstChild();
|
|
TQDomElement innerElem = inner.toElement();
|
|
m_SecondaryId = innerElem.attribute("xmi.id", "");
|
|
if (m_SecondaryId.isEmpty())
|
|
m_SecondaryId = innerElem.attribute("xmi.idref", "");
|
|
}
|
|
}
|
|
}
|
|
if (!m_Multi.isEmpty())
|
|
kDebug() << "UMLRole::load(" << m_Name << "): m_Multi is " << m_Multi << endl;
|
|
if (m_SecondaryId.isEmpty()) {
|
|
kError() << "UMLRole::load(" << m_Name << "): type not given or illegal" << endl;
|
|
return false;
|
|
}
|
|
UMLObject * obj;
|
|
obj = doc->findObjectById(STR2ID(m_SecondaryId));
|
|
if (obj) {
|
|
m_pSecondary = obj;
|
|
m_SecondaryId = "";
|
|
}
|
|
|
|
// block signals to prevent needless updating
|
|
blockSignals(true);
|
|
// Here comes the handling of the association type.
|
|
// This is open for discussion - I'm pretty sure there are better ways..
|
|
|
|
// Yeah, for one, setting the *parent* object parameters from here is sucky
|
|
// as hell. Why are we using roleA to store what is essentially a parent (association)
|
|
// parameter, eh? The UML13.dtd is pretty silly, but since that is what
|
|
// is driving us to that point, we have to go with it. Some analysis of
|
|
// the component roles/linked items needs to be done in order to get things
|
|
// right. *sigh* -b.t.
|
|
|
|
// Setting association type from the role (A)
|
|
// Determination of the "aggregation" attribute used to be done only
|
|
// when (m_role == Uml::A) but some XMI writers (e.g. StarUML) place
|
|
// the aggregation attribute at role B.
|
|
// The role end with the aggregation unequal to "none" wins.
|
|
TQString aggregation = element.attribute("aggregation", "none");
|
|
if (aggregation == "composite")
|
|
m_pAssoc->setAssocType(Uml::at_Composition);
|
|
else if (aggregation == "shared" // UML1.3
|
|
|| aggregation == "aggregate") // UML1.4
|
|
m_pAssoc->setAssocType(Uml::at_Aggregation);
|
|
|
|
if (!element.hasAttribute("isNavigable")) {
|
|
/* Backward compatibility mode: In Umbrello version 1.3.x the
|
|
logic for saving the isNavigable flag was wrong.
|
|
May happen on loading role A.
|
|
*/
|
|
m_pAssoc->setOldLoadMode(true);
|
|
} else if (m_pAssoc->getOldLoadMode() == true) {
|
|
/* Here is the original logic:
|
|
" Role B:
|
|
If isNavigable is not given, we make no change to the
|
|
association type.
|
|
If isNavigable is given, and is "true", then we assume that
|
|
the association's other end (role A) is not navigable, and
|
|
therefore we change the association type to UniAssociation.
|
|
The case that isNavigable is given as "false" is ignored.
|
|
Combined with the association type logic for role A, this
|
|
allows us to support at_Association and at_UniAssociation. "
|
|
*/
|
|
if (element.attribute("isNavigable") == "true")
|
|
m_pAssoc->setAssocType(Uml::at_UniAssociation);
|
|
} else if (element.attribute("isNavigable") == "false") {
|
|
m_pAssoc->setAssocType(Uml::at_UniAssociation);
|
|
}
|
|
|
|
//FIXME not standard XMI
|
|
if (element.hasAttribute("relationship")) {
|
|
if (element.attribute("relationship") == "true") {
|
|
m_pAssoc->setAssocType(Uml::at_Relationship);
|
|
}
|
|
}
|
|
|
|
if (m_Multi.isEmpty())
|
|
m_Multi = element.attribute("multiplicity", "");
|
|
|
|
// Changeability defaults to Changeable if it cant set it here..
|
|
m_Changeability = Uml::chg_Changeable;
|
|
TQString changeability = element.attribute("changeability", "");
|
|
if (changeability.isEmpty())
|
|
element.attribute("changeable", ""); // for backward compatibility
|
|
if (changeability == "frozen")
|
|
m_Changeability = Uml::chg_Frozen;
|
|
else if (changeability == "addOnly")
|
|
m_Changeability = Uml::chg_AddOnly;
|
|
|
|
// finished config, now unblock
|
|
blockSignals(false);
|
|
return true;
|
|
}
|
|
|
|
#include "umlrole.moc"
|