diff options
Diffstat (limited to 'src/uml/qumltemplateparameter.cpp')
| -rw-r--r-- | src/uml/qumltemplateparameter.cpp | 196 |
1 files changed, 107 insertions, 89 deletions
diff --git a/src/uml/qumltemplateparameter.cpp b/src/uml/qumltemplateparameter.cpp index 47636ef8..090ae1b0 100644 --- a/src/uml/qumltemplateparameter.cpp +++ b/src/uml/qumltemplateparameter.cpp @@ -40,153 +40,171 @@ ****************************************************************************/ #include "qumltemplateparameter.h" -#include <QtUml/QUmlComment> -#include <QtUml/QUmlElement> +#include "private/qumltemplateparameterobject_p.h" + #include <QtUml/QUmlParameterableElement> #include <QtUml/QUmlTemplateSignature> -QT_BEGIN_NAMESPACE - /*! - \class UmlTemplateParameter + \class QUmlTemplateParameter \inmodule QtUml \brief A template parameter exposes a parameterable element as a formal template parameter of a template. */ - -QUmlTemplateParameter::QUmlTemplateParameter(QObject *parent) : - QObject(parent) +QUmlTemplateParameter::QUmlTemplateParameter(bool createQObject) : + _default_(0), + _ownedDefault(0), + _ownedParameteredElement(0), + _parameteredElement(0), + _signature(0) { + if (createQObject) + _qObject = new QUmlTemplateParameterObject(this); } -// OWNED ATTRIBUTES [Element] - -/*! - The Comments owned by this element. - */ -const QSet<QUmlComment *> QUmlTemplateParameter::ownedComment() const +QUmlTemplateParameter::~QUmlTemplateParameter() { - return *(reinterpret_cast<const QSet<QUmlComment *> *>(&_ownedComment)); + if (!deletingFromQObject) { + _qObject->setProperty("deletingFromModelingObject", true); + delete _qObject; + } } -/*! - The Elements owned by this element. - */ -const QSet<QUmlElement *> QUmlTemplateParameter::ownedElement() const -{ - return *(reinterpret_cast<const QSet<QUmlElement *> *>(&_ownedElement)); -} +// OWNED ATTRIBUTES /*! - The Element that owns this element. + The element that is the default for this formal template parameter. */ -QUmlElement *QUmlTemplateParameter::owner() const +QUmlParameterableElement * +QUmlTemplateParameter::default_() const { - return reinterpret_cast<QUmlElement *>(_owner); -} + // This is a read-write association end -// OWNED ATTRIBUTES [TemplateParameter] + return _default_; +} -/*! - The element that is the default for this formal template parameter. - */ -QUmlParameterableElement *QUmlTemplateParameter::default_() const +void QUmlTemplateParameter::setDefault(QUmlParameterableElement *default_) { - return reinterpret_cast<QUmlParameterableElement *>(_default_); + // This is a read-write association end + + if (_default_ != default_) { + _default_ = default_; + if (default_->asQObject() && this->asQObject()) + QObject::connect(default_->asQObject(), SIGNAL(destroyed()), this->asQObject(), SLOT(setDefault())); + } } /*! The element that is owned by this template parameter for the purpose of providing a default. */ -QUmlParameterableElement *QUmlTemplateParameter::ownedDefault() const +QUmlParameterableElement * +QUmlTemplateParameter::ownedDefault() const { - return reinterpret_cast<QUmlParameterableElement *>(_ownedDefault); -} + // This is a read-write association end -/*! - The element that is owned by this template parameter. - */ -QUmlParameterableElement *QUmlTemplateParameter::ownedParameteredElement() const -{ - return reinterpret_cast<QUmlParameterableElement *>(_ownedParameteredElement); + return _ownedDefault; } -/*! - The element exposed by this template parameter. - */ -QUmlParameterableElement *QUmlTemplateParameter::parameteredElement() const +void QUmlTemplateParameter::setOwnedDefault(QUmlParameterableElement *ownedDefault) { - return reinterpret_cast<QUmlParameterableElement *>(_parameteredElement); -} + // This is a read-write association end -/*! - The template signature that owns this template parameter. - */ -QUmlTemplateSignature *QUmlTemplateParameter::signature() const -{ - return reinterpret_cast<QUmlTemplateSignature *>(_signature); -} + if (_ownedDefault != ownedDefault) { + // Adjust subsetted properties + removeOwnedElement(_ownedDefault); -// OPERATIONS [Element] + _ownedDefault = ownedDefault; + if (ownedDefault->asQObject() && this->asQObject()) + QObject::connect(ownedDefault->asQObject(), SIGNAL(destroyed()), this->asQObject(), SLOT(setOwnedDefault())); + ownedDefault->asQObject()->setParent(this->asQObject()); -/*! - The query allOwnedElements() gives all of the direct and indirect owned elements of an element. - */ -QSet<QUmlElement *> QUmlTemplateParameter::allOwnedElements() const -{ - QSet<QUmlElement *> r; - foreach (UmlElement *element, UmlElement::allOwnedElements()) - r.insert(reinterpret_cast<QUmlElement *>(element)); - return r; + // Adjust subsetted properties + if (ownedDefault) { + addOwnedElement(ownedDefault); + } + setDefault(ownedDefault); + } } /*! - The query mustBeOwned() indicates whether elements of this type must have an owner. Subclasses of Element that do not require an owner must override this operation. + The element that is owned by this template parameter. */ -bool QUmlTemplateParameter::mustBeOwned() const +QUmlParameterableElement * +QUmlTemplateParameter::ownedParameteredElement() const { - return UmlElement::mustBeOwned(); -} - -// SLOTS FOR OWNED ATTRIBUTES [Element] + // This is a read-write association end -void QUmlTemplateParameter::addOwnedComment(UmlComment *ownedComment) -{ - UmlElement::addOwnedComment(ownedComment); + return _ownedParameteredElement; } -void QUmlTemplateParameter::removeOwnedComment(UmlComment *ownedComment) +void QUmlTemplateParameter::setOwnedParameteredElement(QUmlParameterableElement *ownedParameteredElement) { - UmlElement::removeOwnedComment(ownedComment); -} + // This is a read-write association end -// SLOTS FOR OWNED ATTRIBUTES [TemplateParameter] + if (_ownedParameteredElement != ownedParameteredElement) { + // Adjust subsetted properties + removeOwnedElement(_ownedParameteredElement); -void QUmlTemplateParameter::setDefault(QUmlParameterableElement *default_) -{ - UmlTemplateParameter::setDefault(default_); + _ownedParameteredElement = ownedParameteredElement; + if (ownedParameteredElement->asQObject() && this->asQObject()) + QObject::connect(ownedParameteredElement->asQObject(), SIGNAL(destroyed()), this->asQObject(), SLOT(setOwnedParameteredElement())); + ownedParameteredElement->asQObject()->setParent(this->asQObject()); + + // Adjust subsetted properties + setParameteredElement(ownedParameteredElement); + if (ownedParameteredElement) { + addOwnedElement(ownedParameteredElement); + } + } } -void QUmlTemplateParameter::setOwnedDefault(QUmlParameterableElement *ownedDefault) +/*! + The element exposed by this template parameter. + */ +QUmlParameterableElement * +QUmlTemplateParameter::parameteredElement() const { - UmlTemplateParameter::setOwnedDefault(ownedDefault); + // This is a read-write association end + + return _parameteredElement; } -void QUmlTemplateParameter::setOwnedParameteredElement(QUmlParameterableElement *ownedParameteredElement) +void QUmlTemplateParameter::setParameteredElement(QUmlParameterableElement *parameteredElement) { - UmlTemplateParameter::setOwnedParameteredElement(ownedParameteredElement); + // This is a read-write association end + + if (_parameteredElement != parameteredElement) { + _parameteredElement = parameteredElement; + if (parameteredElement->asQObject() && this->asQObject()) + QObject::connect(parameteredElement->asQObject(), SIGNAL(destroyed()), this->asQObject(), SLOT(setParameteredElement())); + } } -void QUmlTemplateParameter::setParameteredElement(QUmlParameterableElement *parameteredElement) +/*! + The template signature that owns this template parameter. + */ +QUmlTemplateSignature * +QUmlTemplateParameter::signature() const { - UmlTemplateParameter::setParameteredElement(parameteredElement); + // This is a read-write association end + + return _signature; } void QUmlTemplateParameter::setSignature(QUmlTemplateSignature *signature) { - UmlTemplateParameter::setSignature(signature); -} + // This is a read-write association end -QT_END_NAMESPACE + if (_signature != signature) { + // Adjust subsetted properties + + _signature = signature; + if (signature->asQObject() && this->asQObject()) + QObject::connect(signature->asQObject(), SIGNAL(destroyed()), this->asQObject(), SLOT(setSignature())); + + // Adjust subsetted properties + setOwner(signature); + } +} |