summaryrefslogtreecommitdiffstats
path: root/src/uml/qobjects/qumlvaluepinobject.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/uml/qobjects/qumlvaluepinobject.cpp')
-rw-r--r--src/uml/qobjects/qumlvaluepinobject.cpp354
1 files changed, 221 insertions, 133 deletions
diff --git a/src/uml/qobjects/qumlvaluepinobject.cpp b/src/uml/qobjects/qumlvaluepinobject.cpp
index a53cf0aa..1694c404 100644
--- a/src/uml/qobjects/qumlvaluepinobject.cpp
+++ b/src/uml/qobjects/qumlvaluepinobject.cpp
@@ -39,6 +39,7 @@
**
****************************************************************************/
#include "qumlvaluepinobject_p.h"
+#include "private/qmodelingobject_p.h"
#include <QtUml/QUmlValuePin>
#include <QtUml/QUmlActivity>
@@ -65,16 +66,18 @@
QT_BEGIN_NAMESPACE
-QUmlValuePinObject::QUmlValuePinObject(QUmlValuePin *qModelingObject)
+QUmlValuePinObject::QUmlValuePinObject(QUmlValuePin *qModelingElement)
{
- setProperty("modelingObject", QVariant::fromValue(static_cast<QModelingObject *>(qModelingObject)));
+ setProperty("modelingElement", QVariant::fromValue(static_cast<QModelingElement *>(qModelingElement)));
+ setGroupProperties();
+ setPropertyData();
}
QUmlValuePinObject::~QUmlValuePinObject()
{
if (!property("deletingFromModelingObject").isValid()) {
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->deletingFromQObject = true;
- delete qmodelingobjectproperty_cast<QUmlComment *>(this);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->deletingFromQModelingObject = true;
+ delete qmodelingelementproperty_cast<QUmlComment *>(this);
}
}
@@ -83,63 +86,63 @@ QUmlValuePinObject::~QUmlValuePinObject()
const QSet<QObject *> QUmlValuePinObject::ownedComments() const
{
QSet<QObject *> set;
- foreach (QUmlComment *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->ownedComments())
- set.insert(element->asQObject());
+ foreach (QUmlComment *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->ownedComments())
+ set.insert(element->asQModelingObject());
return set;
}
const QSet<QObject *> QUmlValuePinObject::ownedElements() const
{
QSet<QObject *> set;
- foreach (QUmlElement *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->ownedElements())
- set.insert(element->asQObject());
+ foreach (QUmlElement *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->ownedElements())
+ set.insert(element->asQModelingObject());
return set;
}
QObject *QUmlValuePinObject::owner() const
{
- if (!qmodelingobjectproperty_cast<QUmlValuePin *>(this)->owner())
+ if (!qmodelingelementproperty_cast<QUmlValuePin *>(this)->owner())
return 0;
else
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->owner()->asQObject();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->owner()->asQModelingObject();
}
// OWNED ATTRIBUTES [MultiplicityElement]
bool QUmlValuePinObject::isOrdered() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->isOrdered();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->isOrdered();
}
bool QUmlValuePinObject::isUnique() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->isUnique();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->isUnique();
}
int QUmlValuePinObject::lower() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->lower();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->lower();
}
QObject *QUmlValuePinObject::lowerValue() const
{
- if (!qmodelingobjectproperty_cast<QUmlValuePin *>(this)->lowerValue())
+ if (!qmodelingelementproperty_cast<QUmlValuePin *>(this)->lowerValue())
return 0;
else
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->lowerValue()->asQObject();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->lowerValue()->asQModelingObject();
}
int QUmlValuePinObject::upper() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->upper();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->upper();
}
QObject *QUmlValuePinObject::upperValue() const
{
- if (!qmodelingobjectproperty_cast<QUmlValuePin *>(this)->upperValue())
+ if (!qmodelingelementproperty_cast<QUmlValuePin *>(this)->upperValue())
return 0;
else
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->upperValue()->asQObject();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->upperValue()->asQModelingObject();
}
// OWNED ATTRIBUTES [NamedElement]
@@ -147,62 +150,62 @@ QObject *QUmlValuePinObject::upperValue() const
const QSet<QObject *> QUmlValuePinObject::clientDependencies() const
{
QSet<QObject *> set;
- foreach (QUmlDependency *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->clientDependencies())
- set.insert(element->asQObject());
+ foreach (QUmlDependency *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->clientDependencies())
+ set.insert(element->asQModelingObject());
return set;
}
QString QUmlValuePinObject::name() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->name();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->name();
}
QObject *QUmlValuePinObject::nameExpression() const
{
- if (!qmodelingobjectproperty_cast<QUmlValuePin *>(this)->nameExpression())
+ if (!qmodelingelementproperty_cast<QUmlValuePin *>(this)->nameExpression())
return 0;
else
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->nameExpression()->asQObject();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->nameExpression()->asQModelingObject();
}
QObject *QUmlValuePinObject::namespace_() const
{
- if (!qmodelingobjectproperty_cast<QUmlValuePin *>(this)->namespace_())
+ if (!qmodelingelementproperty_cast<QUmlValuePin *>(this)->namespace_())
return 0;
else
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->namespace_()->asQObject();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->namespace_()->asQModelingObject();
}
QString QUmlValuePinObject::qualifiedName() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->qualifiedName();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->qualifiedName();
}
QtUml::VisibilityKind QUmlValuePinObject::visibility() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->visibility();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->visibility();
}
// OWNED ATTRIBUTES [RedefinableElement]
bool QUmlValuePinObject::isLeaf() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->isLeaf();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->isLeaf();
}
const QSet<QObject *> QUmlValuePinObject::redefinedElements() const
{
QSet<QObject *> set;
- foreach (QUmlRedefinableElement *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->redefinedElements())
- set.insert(element->asQObject());
+ foreach (QUmlRedefinableElement *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->redefinedElements())
+ set.insert(element->asQModelingObject());
return set;
}
const QSet<QObject *> QUmlValuePinObject::redefinitionContexts() const
{
QSet<QObject *> set;
- foreach (QUmlClassifier *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->redefinitionContexts())
- set.insert(element->asQObject());
+ foreach (QUmlClassifier *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->redefinitionContexts())
+ set.insert(element->asQModelingObject());
return set;
}
@@ -210,65 +213,65 @@ const QSet<QObject *> QUmlValuePinObject::redefinitionContexts() const
QObject *QUmlValuePinObject::activity() const
{
- if (!qmodelingobjectproperty_cast<QUmlValuePin *>(this)->activity())
+ if (!qmodelingelementproperty_cast<QUmlValuePin *>(this)->activity())
return 0;
else
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->activity()->asQObject();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->activity()->asQModelingObject();
}
const QSet<QObject *> QUmlValuePinObject::inGroups() const
{
QSet<QObject *> set;
- foreach (QUmlActivityGroup *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->inGroups())
- set.insert(element->asQObject());
+ foreach (QUmlActivityGroup *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->inGroups())
+ set.insert(element->asQModelingObject());
return set;
}
const QSet<QObject *> QUmlValuePinObject::inInterruptibleRegions() const
{
QSet<QObject *> set;
- foreach (QUmlInterruptibleActivityRegion *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->inInterruptibleRegions())
- set.insert(element->asQObject());
+ foreach (QUmlInterruptibleActivityRegion *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->inInterruptibleRegions())
+ set.insert(element->asQModelingObject());
return set;
}
const QSet<QObject *> QUmlValuePinObject::inPartitions() const
{
QSet<QObject *> set;
- foreach (QUmlActivityPartition *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->inPartitions())
- set.insert(element->asQObject());
+ foreach (QUmlActivityPartition *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->inPartitions())
+ set.insert(element->asQModelingObject());
return set;
}
QObject *QUmlValuePinObject::inStructuredNode() const
{
- if (!qmodelingobjectproperty_cast<QUmlValuePin *>(this)->inStructuredNode())
+ if (!qmodelingelementproperty_cast<QUmlValuePin *>(this)->inStructuredNode())
return 0;
else
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->inStructuredNode()->asQObject();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->inStructuredNode()->asQModelingObject();
}
const QSet<QObject *> QUmlValuePinObject::incomings() const
{
QSet<QObject *> set;
- foreach (QUmlActivityEdge *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->incomings())
- set.insert(element->asQObject());
+ foreach (QUmlActivityEdge *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->incomings())
+ set.insert(element->asQModelingObject());
return set;
}
const QSet<QObject *> QUmlValuePinObject::outgoings() const
{
QSet<QObject *> set;
- foreach (QUmlActivityEdge *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->outgoings())
- set.insert(element->asQObject());
+ foreach (QUmlActivityEdge *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->outgoings())
+ set.insert(element->asQModelingObject());
return set;
}
const QSet<QObject *> QUmlValuePinObject::redefinedNodes() const
{
QSet<QObject *> set;
- foreach (QUmlActivityNode *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->redefinedNodes())
- set.insert(element->asQObject());
+ foreach (QUmlActivityNode *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->redefinedNodes())
+ set.insert(element->asQModelingObject());
return set;
}
@@ -276,10 +279,10 @@ const QSet<QObject *> QUmlValuePinObject::redefinedNodes() const
QObject *QUmlValuePinObject::type() const
{
- if (!qmodelingobjectproperty_cast<QUmlValuePin *>(this)->type())
+ if (!qmodelingelementproperty_cast<QUmlValuePin *>(this)->type())
return 0;
else
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->type()->asQObject();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->type()->asQModelingObject();
}
// OWNED ATTRIBUTES [ObjectNode]
@@ -287,52 +290,52 @@ QObject *QUmlValuePinObject::type() const
const QSet<QObject *> QUmlValuePinObject::inStates() const
{
QSet<QObject *> set;
- foreach (QUmlState *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->inStates())
- set.insert(element->asQObject());
+ foreach (QUmlState *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->inStates())
+ set.insert(element->asQModelingObject());
return set;
}
bool QUmlValuePinObject::isControlType() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->isControlType();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->isControlType();
}
QtUml::ObjectNodeOrderingKind QUmlValuePinObject::ordering() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->ordering();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->ordering();
}
QObject *QUmlValuePinObject::selection() const
{
- if (!qmodelingobjectproperty_cast<QUmlValuePin *>(this)->selection())
+ if (!qmodelingelementproperty_cast<QUmlValuePin *>(this)->selection())
return 0;
else
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->selection()->asQObject();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->selection()->asQModelingObject();
}
QObject *QUmlValuePinObject::upperBound() const
{
- if (!qmodelingobjectproperty_cast<QUmlValuePin *>(this)->upperBound())
+ if (!qmodelingelementproperty_cast<QUmlValuePin *>(this)->upperBound())
return 0;
else
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->upperBound()->asQObject();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->upperBound()->asQModelingObject();
}
// OWNED ATTRIBUTES [Pin]
bool QUmlValuePinObject::isControl() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->isControl();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->isControl();
}
// OWNED ATTRIBUTES [ValuePin]
QObject *QUmlValuePinObject::value() const
{
- if (!qmodelingobjectproperty_cast<QUmlValuePin *>(this)->value())
+ if (!qmodelingelementproperty_cast<QUmlValuePin *>(this)->value())
return 0;
else
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->value()->asQObject();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->value()->asQModelingObject();
}
// OPERATIONS [Element]
@@ -340,51 +343,51 @@ QObject *QUmlValuePinObject::value() const
QSet<QObject *> QUmlValuePinObject::allOwnedElements() const
{
QSet<QObject *> set;
- foreach (QUmlElement *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->allOwnedElements())
- set.insert(element->asQObject());
+ foreach (QUmlElement *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->allOwnedElements())
+ set.insert(element->asQModelingObject());
return set;
}
bool QUmlValuePinObject::mustBeOwned() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->mustBeOwned();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->mustBeOwned();
}
// OPERATIONS [MultiplicityElement]
bool QUmlValuePinObject::compatibleWith(QObject *other) const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->compatibleWith(qmodelingobjectproperty_cast<QUmlMultiplicityElement *>(other));
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->compatibleWith(qmodelingelementproperty_cast<QUmlMultiplicityElement *>(other));
}
bool QUmlValuePinObject::includesCardinality(int C) const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->includesCardinality(C);
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->includesCardinality(C);
}
bool QUmlValuePinObject::includesMultiplicity(QObject *M) const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->includesMultiplicity(qmodelingobjectproperty_cast<QUmlMultiplicityElement *>(M));
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->includesMultiplicity(qmodelingelementproperty_cast<QUmlMultiplicityElement *>(M));
}
bool QUmlValuePinObject::is(int lowerbound, int upperbound) const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->is(lowerbound, upperbound);
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->is(lowerbound, upperbound);
}
bool QUmlValuePinObject::isMultivalued() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->isMultivalued();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->isMultivalued();
}
int QUmlValuePinObject::lowerBound() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->lowerBound();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->lowerBound();
}
//int QUmlValuePinObject::upperBound() const
//{
-// return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->upperBound();
+// return qmodelingelementproperty_cast<QUmlValuePin *>(this)->upperBound();
//}
// OPERATIONS [NamedElement]
@@ -392,327 +395,412 @@ int QUmlValuePinObject::lowerBound() const
QList<QObject *> QUmlValuePinObject::allNamespaces() const
{
QList<QObject *> set;
- foreach (QUmlNamespace *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->allNamespaces())
- set.append(element->asQObject());
+ foreach (QUmlNamespace *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->allNamespaces())
+ set.append(element->asQModelingObject());
return set;
}
QSet<QObject *> QUmlValuePinObject::allOwningPackages() const
{
QSet<QObject *> set;
- foreach (QUmlPackage *element, qmodelingobjectproperty_cast<QUmlValuePin *>(this)->allOwningPackages())
- set.insert(element->asQObject());
+ foreach (QUmlPackage *element, qmodelingelementproperty_cast<QUmlValuePin *>(this)->allOwningPackages())
+ set.insert(element->asQModelingObject());
return set;
}
bool QUmlValuePinObject::isDistinguishableFrom(QObject *n, QObject *ns) const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->isDistinguishableFrom(qmodelingobjectproperty_cast<QUmlNamedElement *>(n), qmodelingobjectproperty_cast<QUmlNamespace *>(ns));
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->isDistinguishableFrom(qmodelingelementproperty_cast<QUmlNamedElement *>(n), qmodelingelementproperty_cast<QUmlNamespace *>(ns));
}
QString QUmlValuePinObject::separator() const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->separator();
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->separator();
}
// OPERATIONS [RedefinableElement]
bool QUmlValuePinObject::isConsistentWith(QObject *redefinee) const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->isConsistentWith(qmodelingobjectproperty_cast<QUmlRedefinableElement *>(redefinee));
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->isConsistentWith(qmodelingelementproperty_cast<QUmlRedefinableElement *>(redefinee));
}
bool QUmlValuePinObject::isRedefinitionContextValid(QObject *redefined) const
{
- return qmodelingobjectproperty_cast<QUmlValuePin *>(this)->isRedefinitionContextValid(qmodelingobjectproperty_cast<QUmlRedefinableElement *>(redefined));
+ return qmodelingelementproperty_cast<QUmlValuePin *>(this)->isRedefinitionContextValid(qmodelingelementproperty_cast<QUmlRedefinableElement *>(redefined));
}
// SLOTS FOR OWNED ATTRIBUTES [Element]
void QUmlValuePinObject::addOwnedComment(QObject *ownedComment)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addOwnedComment(qmodelingobjectproperty_cast<QUmlComment *>(ownedComment));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addOwnedComment(qmodelingelementproperty_cast<QUmlComment *>(ownedComment));
}
void QUmlValuePinObject::removeOwnedComment(QObject *ownedComment)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeOwnedComment(qmodelingobjectproperty_cast<QUmlComment *>(ownedComment));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeOwnedComment(qmodelingelementproperty_cast<QUmlComment *>(ownedComment));
}
void QUmlValuePinObject::addOwnedElement(QObject *ownedElement)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addOwnedElement(qmodelingobjectproperty_cast<QUmlElement *>(ownedElement));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addOwnedElement(qmodelingelementproperty_cast<QUmlElement *>(ownedElement));
}
void QUmlValuePinObject::removeOwnedElement(QObject *ownedElement)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeOwnedElement(qmodelingobjectproperty_cast<QUmlElement *>(ownedElement));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeOwnedElement(qmodelingelementproperty_cast<QUmlElement *>(ownedElement));
}
void QUmlValuePinObject::setOwner(QObject *owner)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setOwner(qmodelingobjectproperty_cast<QUmlElement *>(owner));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setOwner(qmodelingelementproperty_cast<QUmlElement *>(owner));
}
// SLOTS FOR OWNED ATTRIBUTES [MultiplicityElement]
void QUmlValuePinObject::setOrdered(bool isOrdered)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setOrdered(isOrdered);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setOrdered(isOrdered);
}
void QUmlValuePinObject::unsetOrdered()
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->modifiedResettableProperties().removeAll(QStringLiteral("ordered"));
+ Q_D(QModelingObject);
+ d->modifiedResettableProperties.removeAll(QStringLiteral("ordered"));
}
void QUmlValuePinObject::setUnique(bool isUnique)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setUnique(isUnique);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setUnique(isUnique);
}
void QUmlValuePinObject::unsetUnique()
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->modifiedResettableProperties().removeAll(QStringLiteral("unique"));
+ Q_D(QModelingObject);
+ d->modifiedResettableProperties.removeAll(QStringLiteral("unique"));
}
void QUmlValuePinObject::setLower(int lower)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setLower(lower);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setLower(lower);
}
void QUmlValuePinObject::unsetLower()
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->modifiedResettableProperties().removeAll(QStringLiteral("lower"));
+ Q_D(QModelingObject);
+ d->modifiedResettableProperties.removeAll(QStringLiteral("lower"));
}
void QUmlValuePinObject::setLowerValue(QObject *lowerValue)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setLowerValue(qmodelingobjectproperty_cast<QUmlValueSpecification *>(lowerValue));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setLowerValue(qmodelingelementproperty_cast<QUmlValueSpecification *>(lowerValue));
}
void QUmlValuePinObject::setUpper(int upper)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setUpper(upper);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setUpper(upper);
}
void QUmlValuePinObject::unsetUpper()
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->modifiedResettableProperties().removeAll(QStringLiteral("upper"));
+ Q_D(QModelingObject);
+ d->modifiedResettableProperties.removeAll(QStringLiteral("upper"));
}
void QUmlValuePinObject::setUpperValue(QObject *upperValue)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setUpperValue(qmodelingobjectproperty_cast<QUmlValueSpecification *>(upperValue));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setUpperValue(qmodelingelementproperty_cast<QUmlValueSpecification *>(upperValue));
}
// SLOTS FOR OWNED ATTRIBUTES [NamedElement]
void QUmlValuePinObject::addClientDependency(QObject *clientDependency)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addClientDependency(qmodelingobjectproperty_cast<QUmlDependency *>(clientDependency));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addClientDependency(qmodelingelementproperty_cast<QUmlDependency *>(clientDependency));
}
void QUmlValuePinObject::removeClientDependency(QObject *clientDependency)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeClientDependency(qmodelingobjectproperty_cast<QUmlDependency *>(clientDependency));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeClientDependency(qmodelingelementproperty_cast<QUmlDependency *>(clientDependency));
}
void QUmlValuePinObject::setName(QString name)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setName(name);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setName(name);
}
void QUmlValuePinObject::setNameExpression(QObject *nameExpression)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setNameExpression(qmodelingobjectproperty_cast<QUmlStringExpression *>(nameExpression));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setNameExpression(qmodelingelementproperty_cast<QUmlStringExpression *>(nameExpression));
}
void QUmlValuePinObject::setNamespace(QObject *namespace_)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setNamespace(qmodelingobjectproperty_cast<QUmlNamespace *>(namespace_));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setNamespace(qmodelingelementproperty_cast<QUmlNamespace *>(namespace_));
}
void QUmlValuePinObject::setQualifiedName(QString qualifiedName)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setQualifiedName(qualifiedName);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setQualifiedName(qualifiedName);
}
void QUmlValuePinObject::setVisibility(QtUml::VisibilityKind visibility)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setVisibility(visibility);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setVisibility(visibility);
}
// SLOTS FOR OWNED ATTRIBUTES [RedefinableElement]
void QUmlValuePinObject::setLeaf(bool isLeaf)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setLeaf(isLeaf);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setLeaf(isLeaf);
}
void QUmlValuePinObject::unsetLeaf()
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->modifiedResettableProperties().removeAll(QStringLiteral("leaf"));
+ Q_D(QModelingObject);
+ d->modifiedResettableProperties.removeAll(QStringLiteral("leaf"));
}
void QUmlValuePinObject::addRedefinedElement(QObject *redefinedElement)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addRedefinedElement(qmodelingobjectproperty_cast<QUmlRedefinableElement *>(redefinedElement));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addRedefinedElement(qmodelingelementproperty_cast<QUmlRedefinableElement *>(redefinedElement));
}
void QUmlValuePinObject::removeRedefinedElement(QObject *redefinedElement)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeRedefinedElement(qmodelingobjectproperty_cast<QUmlRedefinableElement *>(redefinedElement));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeRedefinedElement(qmodelingelementproperty_cast<QUmlRedefinableElement *>(redefinedElement));
}
void QUmlValuePinObject::addRedefinitionContext(QObject *redefinitionContext)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addRedefinitionContext(qmodelingobjectproperty_cast<QUmlClassifier *>(redefinitionContext));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addRedefinitionContext(qmodelingelementproperty_cast<QUmlClassifier *>(redefinitionContext));
}
void QUmlValuePinObject::removeRedefinitionContext(QObject *redefinitionContext)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeRedefinitionContext(qmodelingobjectproperty_cast<QUmlClassifier *>(redefinitionContext));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeRedefinitionContext(qmodelingelementproperty_cast<QUmlClassifier *>(redefinitionContext));
}
// SLOTS FOR OWNED ATTRIBUTES [ActivityNode]
void QUmlValuePinObject::setActivity(QObject *activity)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setActivity(qmodelingobjectproperty_cast<QUmlActivity *>(activity));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setActivity(qmodelingelementproperty_cast<QUmlActivity *>(activity));
}
void QUmlValuePinObject::addInGroup(QObject *inGroup)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addInGroup(qmodelingobjectproperty_cast<QUmlActivityGroup *>(inGroup));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addInGroup(qmodelingelementproperty_cast<QUmlActivityGroup *>(inGroup));
}
void QUmlValuePinObject::removeInGroup(QObject *inGroup)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeInGroup(qmodelingobjectproperty_cast<QUmlActivityGroup *>(inGroup));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeInGroup(qmodelingelementproperty_cast<QUmlActivityGroup *>(inGroup));
}
void QUmlValuePinObject::addInInterruptibleRegion(QObject *inInterruptibleRegion)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addInInterruptibleRegion(qmodelingobjectproperty_cast<QUmlInterruptibleActivityRegion *>(inInterruptibleRegion));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addInInterruptibleRegion(qmodelingelementproperty_cast<QUmlInterruptibleActivityRegion *>(inInterruptibleRegion));
}
void QUmlValuePinObject::removeInInterruptibleRegion(QObject *inInterruptibleRegion)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeInInterruptibleRegion(qmodelingobjectproperty_cast<QUmlInterruptibleActivityRegion *>(inInterruptibleRegion));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeInInterruptibleRegion(qmodelingelementproperty_cast<QUmlInterruptibleActivityRegion *>(inInterruptibleRegion));
}
void QUmlValuePinObject::addInPartition(QObject *inPartition)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addInPartition(qmodelingobjectproperty_cast<QUmlActivityPartition *>(inPartition));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addInPartition(qmodelingelementproperty_cast<QUmlActivityPartition *>(inPartition));
}
void QUmlValuePinObject::removeInPartition(QObject *inPartition)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeInPartition(qmodelingobjectproperty_cast<QUmlActivityPartition *>(inPartition));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeInPartition(qmodelingelementproperty_cast<QUmlActivityPartition *>(inPartition));
}
void QUmlValuePinObject::setInStructuredNode(QObject *inStructuredNode)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setInStructuredNode(qmodelingobjectproperty_cast<QUmlStructuredActivityNode *>(inStructuredNode));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setInStructuredNode(qmodelingelementproperty_cast<QUmlStructuredActivityNode *>(inStructuredNode));
}
void QUmlValuePinObject::addIncoming(QObject *incoming)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addIncoming(qmodelingobjectproperty_cast<QUmlActivityEdge *>(incoming));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addIncoming(qmodelingelementproperty_cast<QUmlActivityEdge *>(incoming));
}
void QUmlValuePinObject::removeIncoming(QObject *incoming)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeIncoming(qmodelingobjectproperty_cast<QUmlActivityEdge *>(incoming));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeIncoming(qmodelingelementproperty_cast<QUmlActivityEdge *>(incoming));
}
void QUmlValuePinObject::addOutgoing(QObject *outgoing)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addOutgoing(qmodelingobjectproperty_cast<QUmlActivityEdge *>(outgoing));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addOutgoing(qmodelingelementproperty_cast<QUmlActivityEdge *>(outgoing));
}
void QUmlValuePinObject::removeOutgoing(QObject *outgoing)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeOutgoing(qmodelingobjectproperty_cast<QUmlActivityEdge *>(outgoing));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeOutgoing(qmodelingelementproperty_cast<QUmlActivityEdge *>(outgoing));
}
void QUmlValuePinObject::addRedefinedNode(QObject *redefinedNode)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addRedefinedNode(qmodelingobjectproperty_cast<QUmlActivityNode *>(redefinedNode));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addRedefinedNode(qmodelingelementproperty_cast<QUmlActivityNode *>(redefinedNode));
}
void QUmlValuePinObject::removeRedefinedNode(QObject *redefinedNode)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeRedefinedNode(qmodelingobjectproperty_cast<QUmlActivityNode *>(redefinedNode));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeRedefinedNode(qmodelingelementproperty_cast<QUmlActivityNode *>(redefinedNode));
}
// SLOTS FOR OWNED ATTRIBUTES [TypedElement]
void QUmlValuePinObject::setType(QObject *type)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setType(qmodelingobjectproperty_cast<QUmlType *>(type));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setType(qmodelingelementproperty_cast<QUmlType *>(type));
}
// SLOTS FOR OWNED ATTRIBUTES [ObjectNode]
void QUmlValuePinObject::addInState(QObject *inState)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->addInState(qmodelingobjectproperty_cast<QUmlState *>(inState));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->addInState(qmodelingelementproperty_cast<QUmlState *>(inState));
}
void QUmlValuePinObject::removeInState(QObject *inState)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->removeInState(qmodelingobjectproperty_cast<QUmlState *>(inState));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->removeInState(qmodelingelementproperty_cast<QUmlState *>(inState));
}
void QUmlValuePinObject::setControlType(bool isControlType)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setControlType(isControlType);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setControlType(isControlType);
}
void QUmlValuePinObject::unsetControlType()
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->modifiedResettableProperties().removeAll(QStringLiteral("controlType"));
+ Q_D(QModelingObject);
+ d->modifiedResettableProperties.removeAll(QStringLiteral("controlType"));
}
void QUmlValuePinObject::setOrdering(QtUml::ObjectNodeOrderingKind ordering)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setOrdering(ordering);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setOrdering(ordering);
}
void QUmlValuePinObject::unsetOrdering()
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->modifiedResettableProperties().removeAll(QStringLiteral("ordering"));
+ Q_D(QModelingObject);
+ d->modifiedResettableProperties.removeAll(QStringLiteral("ordering"));
}
void QUmlValuePinObject::setSelection(QObject *selection)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setSelection(qmodelingobjectproperty_cast<QUmlBehavior *>(selection));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setSelection(qmodelingelementproperty_cast<QUmlBehavior *>(selection));
}
void QUmlValuePinObject::setUpperBound(QObject *upperBound)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setUpperBound(qmodelingobjectproperty_cast<QUmlValueSpecification *>(upperBound));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setUpperBound(qmodelingelementproperty_cast<QUmlValueSpecification *>(upperBound));
}
// SLOTS FOR OWNED ATTRIBUTES [Pin]
void QUmlValuePinObject::setControl(bool isControl)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setControl(isControl);
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setControl(isControl);
}
void QUmlValuePinObject::unsetControl()
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->modifiedResettableProperties().removeAll(QStringLiteral("control"));
+ Q_D(QModelingObject);
+ d->modifiedResettableProperties.removeAll(QStringLiteral("control"));
}
// SLOTS FOR OWNED ATTRIBUTES [ValuePin]
void QUmlValuePinObject::setValue(QObject *value)
{
- qmodelingobjectproperty_cast<QUmlValuePin *>(this)->setValue(qmodelingobjectproperty_cast<QUmlValueSpecification *>(value));
+ qmodelingelementproperty_cast<QUmlValuePin *>(this)->setValue(qmodelingelementproperty_cast<QUmlValueSpecification *>(value));
+}
+
+
+void QUmlValuePinObject::setGroupProperties()
+{
+ Q_D(QModelingObject);
+ const QMetaObject *metaObject = this->metaObject();
+
+ d->propertyGroups << QStringLiteral("QObject");
+ d->groupProperties.insert(QStringLiteral("QObject"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("objectName"))));
+
+ d->propertyGroups << QStringLiteral("QUmlElement");
+ d->groupProperties.insert(QStringLiteral("QUmlElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("ownedComments"))));
+ d->groupProperties.insert(QStringLiteral("QUmlElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("ownedElements"))));
+ d->groupProperties.insert(QStringLiteral("QUmlElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("owner"))));
+
+ d->propertyGroups << QStringLiteral("QUmlMultiplicityElement");
+ d->groupProperties.insert(QStringLiteral("QUmlMultiplicityElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("isOrdered"))));
+ d->groupProperties.insert(QStringLiteral("QUmlMultiplicityElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("isUnique"))));
+ d->groupProperties.insert(QStringLiteral("QUmlMultiplicityElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("lower"))));
+ d->groupProperties.insert(QStringLiteral("QUmlMultiplicityElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("lowerValue"))));
+ d->groupProperties.insert(QStringLiteral("QUmlMultiplicityElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("upper"))));
+ d->groupProperties.insert(QStringLiteral("QUmlMultiplicityElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("upperValue"))));
+
+ d->propertyGroups << QStringLiteral("QUmlNamedElement");
+ d->groupProperties.insert(QStringLiteral("QUmlNamedElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("clientDependencies"))));
+ d->groupProperties.insert(QStringLiteral("QUmlNamedElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("name"))));
+ d->groupProperties.insert(QStringLiteral("QUmlNamedElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("nameExpression"))));
+ d->groupProperties.insert(QStringLiteral("QUmlNamedElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("namespace_"))));
+ d->groupProperties.insert(QStringLiteral("QUmlNamedElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("qualifiedName"))));
+ d->groupProperties.insert(QStringLiteral("QUmlNamedElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("visibility"))));
+
+ d->propertyGroups << QStringLiteral("QUmlRedefinableElement");
+ d->groupProperties.insert(QStringLiteral("QUmlRedefinableElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("isLeaf"))));
+ d->groupProperties.insert(QStringLiteral("QUmlRedefinableElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("redefinedElements"))));
+ d->groupProperties.insert(QStringLiteral("QUmlRedefinableElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("redefinitionContexts"))));
+
+ d->propertyGroups << QStringLiteral("QUmlActivityNode");
+ d->groupProperties.insert(QStringLiteral("QUmlActivityNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("activity"))));
+ d->groupProperties.insert(QStringLiteral("QUmlActivityNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("inGroups"))));
+ d->groupProperties.insert(QStringLiteral("QUmlActivityNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("inInterruptibleRegions"))));
+ d->groupProperties.insert(QStringLiteral("QUmlActivityNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("inPartitions"))));
+ d->groupProperties.insert(QStringLiteral("QUmlActivityNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("inStructuredNode"))));
+ d->groupProperties.insert(QStringLiteral("QUmlActivityNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("incomings"))));
+ d->groupProperties.insert(QStringLiteral("QUmlActivityNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("outgoings"))));
+ d->groupProperties.insert(QStringLiteral("QUmlActivityNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("redefinedNodes"))));
+
+ d->propertyGroups << QStringLiteral("QUmlTypedElement");
+ d->groupProperties.insert(QStringLiteral("QUmlTypedElement"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("type"))));
+
+ d->propertyGroups << QStringLiteral("QUmlObjectNode");
+ d->groupProperties.insert(QStringLiteral("QUmlObjectNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("inStates"))));
+ d->groupProperties.insert(QStringLiteral("QUmlObjectNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("isControlType"))));
+ d->groupProperties.insert(QStringLiteral("QUmlObjectNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("ordering"))));
+ d->groupProperties.insert(QStringLiteral("QUmlObjectNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("selection"))));
+ d->groupProperties.insert(QStringLiteral("QUmlObjectNode"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("upperBound"))));
+
+ d->propertyGroups << QStringLiteral("QUmlPin");
+ d->groupProperties.insert(QStringLiteral("QUmlPin"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("isControl"))));
+
+ d->propertyGroups << QStringLiteral("QUmlInputPin");
+
+ d->propertyGroups << QStringLiteral("QUmlValuePin");
+ d->groupProperties.insert(QStringLiteral("QUmlValuePin"), new QMetaProperty(metaObject->property(metaObject->indexOfProperty("value"))));
+}
+
+void QUmlValuePinObject::setPropertyData()
+{
+ Q_DECLARE_METAPROPERTY_INFO(QUmlValuePin, value, AggregationRole, QStringLiteral("composite"));
+ Q_DECLARE_METAPROPERTY_INFO(QUmlValuePin, value, PropertyClassRole, QStringLiteral("QUmlValuePin"));
+ Q_DECLARE_METAPROPERTY_INFO(QUmlValuePin, value, IsDerivedRole, false);
+ Q_DECLARE_METAPROPERTY_INFO(QUmlValuePin, value, IsDerivedUnionRole, false);
+ Q_DECLARE_METAPROPERTY_INFO(QUmlValuePin, value, DocumentationRole, QStringLiteral("Value that the pin will provide."));
+ Q_DECLARE_METAPROPERTY_INFO(QUmlValuePin, value, RedefinedPropertiesRole, QStringLiteral(""));
+ Q_DECLARE_METAPROPERTY_INFO(QUmlValuePin, value, SubsettedPropertiesRole, QStringLiteral("Element-ownedElement"));
+ Q_DECLARE_METAPROPERTY_INFO(QUmlValuePin, value, OppositeEndRole, QStringLiteral(""));
+
}
QT_END_NAMESPACE