1 files changed, 87 insertions, 82 deletions

diff --git a/src/uml/qumltemplatesignature.cpp b/src/uml/qumltemplatesignature.cpp
index d7d2250d..adf3ae3a 100644
--- a/src/uml/qumltemplatesignature.cpp
+++ b/src/uml/qumltemplatesignature.cpp
@@ -40,137 +40,142 @@
 ****************************************************************************/
 #include "qumltemplatesignature.h"
 
-#include <QtUml/QUmlComment>
-#include <QtUml/QUmlElement>
+#include "private/qumltemplatesignatureobject_p.h"
+
 #include <QtUml/QUmlTemplateableElement>
 #include <QtUml/QUmlTemplateParameter>
 
-QT_BEGIN_NAMESPACE
-
 /*!
-    \class UmlTemplateSignature
+    \class QUmlTemplateSignature
 
     \inmodule QtUml
 
     \brief A template signature bundles the set of formal template parameters for a templated element.
  */
-
-QUmlTemplateSignature::QUmlTemplateSignature(QObject *parent) :
-    QObject(parent)
+QUmlTemplateSignature::QUmlTemplateSignature(bool createQObject) :
+    _template_(0)
 {
+    if (createQObject)
+        _qObject = new QUmlTemplateSignatureObject(this);
 }
 
-// OWNED ATTRIBUTES [Element]
-
-/*!
-    The Comments owned by this element.
- */
-const QSet<QUmlComment *> QUmlTemplateSignature::ownedComment() const
+QUmlTemplateSignature::~QUmlTemplateSignature()
 {
-    return *(reinterpret_cast<const QSet<QUmlComment *> *>(&_ownedComment));
+    if (!deletingFromQObject) {
+        _qObject->setProperty("deletingFromModelingObject", true);
+        delete _qObject;
+    }
 }
 
+// OWNED ATTRIBUTES
+
 /*!
-    The Elements owned by this element.
+    The formal template parameters that are owned by this template signature.
  */
-const QSet<QUmlElement *> QUmlTemplateSignature::ownedElement() const
+const QList<QUmlTemplateParameter *> 
+QUmlTemplateSignature::ownedParameter() const
 {
-    return *(reinterpret_cast<const QSet<QUmlElement *> *>(&_ownedElement));
+    // This is a read-write association end
+
+    return _ownedParameter;
 }
 
-/*!
-    The Element that owns this element.
- */
-QUmlElement *QUmlTemplateSignature::owner() const
+void QUmlTemplateSignature::addOwnedParameter(QUmlTemplateParameter *ownedParameter)
 {
-    return reinterpret_cast<QUmlElement *>(_owner);
-}
+    // This is a read-write association end
 
-// OWNED ATTRIBUTES [TemplateSignature]
+    if (!_ownedParameter.contains(ownedParameter)) {
+        _ownedParameter.append(ownedParameter);
+        if (ownedParameter->asQObject() && this->asQObject())
+            QObject::connect(ownedParameter->asQObject(), SIGNAL(destroyed(QObject*)), this->asQObject(), SLOT(removeOwnedParameter(QObject *)));
+        ownedParameter->asQObject()->setParent(this->asQObject());
 
-/*!
-    The formal template parameters that are owned by this template signature.
- */
-const QList<QUmlTemplateParameter *> QUmlTemplateSignature::ownedParameter() const
-{
-    return *(reinterpret_cast<const QList<QUmlTemplateParameter *> *>(&_ownedParameter));
-}
+        // Adjust subsetted properties
+        addParameter(ownedParameter);
+        addOwnedElement(ownedParameter);
 
-/*!
-    The ordered set of all formal template parameters for this template signature.
- */
-const QList<QUmlTemplateParameter *> QUmlTemplateSignature::parameter() const
-{
-    return *(reinterpret_cast<const QList<QUmlTemplateParameter *> *>(&_parameter));
+        // Adjust opposite properties
+        if (ownedParameter) {
+            ownedParameter->setSignature(this);
+        }
+    }
 }
 
-/*!
-    The element that owns this template signature.
- */
-QUmlTemplateableElement *QUmlTemplateSignature::template_() const
+void QUmlTemplateSignature::removeOwnedParameter(QUmlTemplateParameter *ownedParameter)
 {
-    return reinterpret_cast<QUmlTemplateableElement *>(_template_);
-}
+    // This is a read-write association end
 
-// OPERATIONS [Element]
+    if (_ownedParameter.contains(ownedParameter)) {
+        _ownedParameter.removeAll(ownedParameter);
+        if (ownedParameter->asQObject())
+            ownedParameter->asQObject()->setParent(0);
 
-/*!
-    The query allOwnedElements() gives all of the direct and indirect owned elements of an element.
- */
-QSet<QUmlElement *> QUmlTemplateSignature::allOwnedElements() const
-{
-    QSet<QUmlElement *> r;
-    foreach (UmlElement *element, UmlElement::allOwnedElements())
-        r.insert(reinterpret_cast<QUmlElement *>(element));
-    return r;
+        // Adjust subsetted properties
+        removeParameter(ownedParameter);
+        removeOwnedElement(ownedParameter);
+
+        // Adjust opposite properties
+        if (ownedParameter) {
+            ownedParameter->setSignature(0);
+        }
+    }
 }
 
 /*!
-    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 ordered set of all formal template parameters for this template signature.
  */
-bool QUmlTemplateSignature::mustBeOwned() const
+const QList<QUmlTemplateParameter *> 
+QUmlTemplateSignature::parameter() const
 {
-    return UmlElement::mustBeOwned();
-}
-
-// SLOTS FOR OWNED ATTRIBUTES [Element]
+    // This is a read-write association end
 
-void QUmlTemplateSignature::addOwnedComment(UmlComment *ownedComment)
-{
-    UmlElement::addOwnedComment(ownedComment);
+    return _parameter;
 }
 
-void QUmlTemplateSignature::removeOwnedComment(UmlComment *ownedComment)
+void QUmlTemplateSignature::addParameter(QUmlTemplateParameter *parameter)
 {
-    UmlElement::removeOwnedComment(ownedComment);
-}
-
-// SLOTS FOR OWNED ATTRIBUTES [TemplateSignature]
+    // This is a read-write association end
 
-void QUmlTemplateSignature::addOwnedParameter(UmlTemplateParameter *ownedParameter)
-{
-    UmlTemplateSignature::addOwnedParameter(ownedParameter);
+    if (!_parameter.contains(parameter)) {
+        _parameter.append(parameter);
+        if (parameter->asQObject() && this->asQObject())
+            QObject::connect(parameter->asQObject(), SIGNAL(destroyed(QObject*)), this->asQObject(), SLOT(removeParameter(QObject *)));
+    }
 }
 
-void QUmlTemplateSignature::removeOwnedParameter(UmlTemplateParameter *ownedParameter)
+void QUmlTemplateSignature::removeParameter(QUmlTemplateParameter *parameter)
 {
-    UmlTemplateSignature::removeOwnedParameter(ownedParameter);
-}
+    // This is a read-write association end
 
-void QUmlTemplateSignature::addParameter(UmlTemplateParameter *parameter)
-{
-    UmlTemplateSignature::addParameter(parameter);
+    if (_parameter.contains(parameter)) {
+        _parameter.removeAll(parameter);
+    }
 }
 
-void QUmlTemplateSignature::removeParameter(UmlTemplateParameter *parameter)
+/*!
+    The element that owns this template signature.
+ */
+QUmlTemplateableElement *
+QUmlTemplateSignature::template_() const
 {
-    UmlTemplateSignature::removeParameter(parameter);
+    // This is a read-write association end
+
+    return _template_;
 }
 
 void QUmlTemplateSignature::setTemplate(QUmlTemplateableElement *template_)
 {
-    UmlTemplateSignature::setTemplate(template_);
-}
+    // This is a read-write association end
+
+    if (_template_ != template_) {
+        // Adjust subsetted properties
 
-QT_END_NAMESPACE
+        _template_ = template_;
+        if (template_->asQObject() && this->asQObject())
+            QObject::connect(template_->asQObject(), SIGNAL(destroyed()), this->asQObject(), SLOT(setTemplate()));
+
+        // Adjust subsetted properties
+        setOwner(template_);
+    }
+}