path: root/src/mof/qmofproperty.cpp

/****************************************************************************
**
** Copyright (C) 2013 Sandro S. Andrade <sandroandrade@kde.org>
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtMof module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qmofproperty.h"

#include "private/qmofpropertyobject_p.h"

#include <QtMof/QMofAssociation>
#include <QtMof/QMofClass>
#include <QtMof/QMofClassifier>
#include <QtMof/QMofComment>
#include <QtMof/QMofDataType>
#include <QtMof/QMofElement>
#include <QtMof/QMofMultiplicityElement>
#include <QtMof/QMofNamedElement>
#include <QtMof/QMofNamespace>
#include <QtMof/QMofRedefinableElement>
#include <QtMof/QMofType>
#include <QtMof/QMofValueSpecification>

QT_BEGIN_NAMESPACE

/*!
    \class QMofProperty

    \inmodule QtMof

    \brief A property is a structural feature of a classifier that characterizes instances of the classifier. A property related by ownedAttribute to a classifier (other than an association) represents an attribute and might also represent an association end. It relates an instance of the class to a value or set of values of the type of the attribute. A property related by memberEnd or its specializations to an association represents an end of the association. The type of the property is the type of the end of the association.
 */
QMofProperty::QMofProperty(bool createQModelingObject) :
    _aggregation(QtMof::AggregationKindNone),
    _association(0),
    _class_(0),
    _datatype(0),
    _defaultValue(0),
    _isDerived(false),
    _isDerivedUnion(false),
    _isID(false),
    _isReadOnly(false),
    _owningAssociation(0)
{
    if (createQModelingObject)
        _qModelingObject = qobject_cast<QModelingObject *>(new QMofPropertyObject(this));
}

QModelingElement *QMofProperty::clone() const
{
    QMofProperty *c = new QMofProperty;
    foreach (QMofComment *element, ownedComments())
        c->addOwnedComment(dynamic_cast<QMofComment *>(element->clone()));
    c->setName(name());
    c->setVisibility(visibility());
    c->setLeaf(isLeaf());
    c->setStatic(isStatic());
    if (type())
        c->setType(dynamic_cast<QMofType *>(type()->clone()));
    c->setOrdered(isOrdered());
    c->setUnique(isUnique());
    if (lowerValue())
        c->setLowerValue(dynamic_cast<QMofValueSpecification *>(lowerValue()->clone()));
    if (upperValue())
        c->setUpperValue(dynamic_cast<QMofValueSpecification *>(upperValue()->clone()));
    c->setAggregation(aggregation());
    if (association())
        c->setAssociation(dynamic_cast<QMofAssociation *>(association()->clone()));
    if (class_())
        c->setClass(dynamic_cast<QMofClass *>(class_()->clone()));
    if (datatype())
        c->setDatatype(dynamic_cast<QMofDataType *>(datatype()->clone()));
    if (defaultValue())
        c->setDefaultValue(dynamic_cast<QMofValueSpecification *>(defaultValue()->clone()));
    c->setDerived(isDerived());
    c->setDerivedUnion(isDerivedUnion());
    c->setID(isID());
    c->setReadOnly(isReadOnly());
    if (owningAssociation())
        c->setOwningAssociation(dynamic_cast<QMofAssociation *>(owningAssociation()->clone()));
    foreach (QMofProperty *element, redefinedProperties())
        c->addRedefinedProperty(dynamic_cast<QMofProperty *>(element->clone()));
    foreach (QMofProperty *element, subsettedProperties())
        c->addSubsettedProperty(dynamic_cast<QMofProperty *>(element->clone()));
    return c;
}

// OWNED ATTRIBUTES

/*!
    Specifies the kind of aggregation that applies to the Property.
 */
QtMof::AggregationKind QMofProperty::aggregation() const
{
    // This is a read-write property

    return _aggregation;
}

void QMofProperty::setAggregation(QtMof::AggregationKind aggregation)
{
    // This is a read-write property

    if (_aggregation != aggregation) {
        _aggregation = aggregation;
        _qModelingObject->modifiedResettableProperties() << QStringLiteral("aggregation");
    }
}

/*!
    References the association of which this property is a member, if any.
 */
QMofAssociation *QMofProperty::association() const
{
    // This is a read-write association end

    return _association;
}

void QMofProperty::setAssociation(QMofAssociation *association)
{
    // This is a read-write association end

    if (_association != association) {
        _association = association;
        if (association && association->asQModelingObject() && this->asQModelingObject())
            QObject::connect(association->asQModelingObject(), SIGNAL(destroyed()), this->asQModelingObject(), SLOT(setAssociation()));
    }
}

/*!
    References the Class that owns the Property.
 */
QMofClass *QMofProperty::class_() const
{
    // This is a read-write association end

    return _class_;
}

void QMofProperty::setClass(QMofClass *class_)
{
    // This is a read-write association end

    if (_class_ != class_) {
        // Adjust subsetted properties

        _class_ = class_;
        if (class_ && class_->asQModelingObject() && this->asQModelingObject())
            QObject::connect(class_->asQModelingObject(), SIGNAL(destroyed()), this->asQModelingObject(), SLOT(setClass()));

        // Adjust subsetted properties
        setNamespace(class_);
    }
}

/*!
    The DataType that owns this Property.
 */
QMofDataType *QMofProperty::datatype() const
{
    // This is a read-write association end

    return _datatype;
}

void QMofProperty::setDatatype(QMofDataType *datatype)
{
    // This is a read-write association end

    if (_datatype != datatype) {
        // Adjust subsetted properties

        _datatype = datatype;
        if (datatype && datatype->asQModelingObject() && this->asQModelingObject())
            QObject::connect(datatype->asQModelingObject(), SIGNAL(destroyed()), this->asQModelingObject(), SLOT(setDatatype()));

        // Adjust subsetted properties
        setNamespace(datatype);
    }
}

/*!
    A String that is evaluated to give a default value for the Property when an object of the owning Classifier is instantiated.
 */
QString QMofProperty::default_() const
{
    // This is a read-write derived property

    qWarning("QMofProperty::default_(): to be implemented (this is a derived property)");

    return QString();
}

void QMofProperty::setDefault(QString default_)
{
    // This is a read-write derived property

    qWarning("QMofProperty::setDefault(): to be implemented (this is a derived property)");
    Q_UNUSED(default_);

    if (false /* <derivedexclusion-criteria> */) {
        // <derived-code>
    }
}

/*!
    A ValueSpecification that is evaluated to give a default value for the Property when an object of the owning Classifier is instantiated.
 */
QMofValueSpecification *QMofProperty::defaultValue() const
{
    // This is a read-write association end

    return _defaultValue;
}

void QMofProperty::setDefaultValue(QMofValueSpecification *defaultValue)
{
    // This is a read-write association end

    if (_defaultValue != defaultValue) {
        // Adjust subsetted properties
        removeOwnedElement(_defaultValue);

        _defaultValue = defaultValue;
        if (defaultValue && defaultValue->asQModelingObject() && this->asQModelingObject())
            QObject::connect(defaultValue->asQModelingObject(), SIGNAL(destroyed()), this->asQModelingObject(), SLOT(setDefaultValue()));
        defaultValue->asQModelingObject()->setParent(this->asQModelingObject());

        // Adjust subsetted properties
        if (defaultValue) {
            addOwnedElement(defaultValue);
        }
    }
}

/*!
    This is a derived value, indicating whether the aggregation of the Property is composite or not.
 */
bool QMofProperty::isComposite() const
{
    // This is a read-write derived property

    qWarning("QMofProperty::isComposite(): to be implemented (this is a derived property)");

    return bool();
}

void QMofProperty::setComposite(bool isComposite)
{
    // This is a read-write derived property

    qWarning("QMofProperty::setComposite(): to be implemented (this is a derived property)");
    Q_UNUSED(isComposite);

    if (false /* <derivedexclusion-criteria> */) {
        // <derived-code>
    }
}

/*!
    Specifies whether the Property is derived, i.e., whether its value or values can be computed from other information.
 */
bool QMofProperty::isDerived() const
{
    // This is a read-write property

    return _isDerived;
}

void QMofProperty::setDerived(bool isDerived)
{
    // This is a read-write property

    if (_isDerived != isDerived) {
        _isDerived = isDerived;
        _qModelingObject->modifiedResettableProperties() << QStringLiteral("isDerived");
    }
}

/*!
    Specifies whether the property is derived as the union of all of the properties that are constrained to subset it.
 */
bool QMofProperty::isDerivedUnion() const
{
    // This is a read-write property

    return _isDerivedUnion;
}

void QMofProperty::setDerivedUnion(bool isDerivedUnion)
{
    // This is a read-write property

    if (_isDerivedUnion != isDerivedUnion) {
        _isDerivedUnion = isDerivedUnion;
        _qModelingObject->modifiedResettableProperties() << QStringLiteral("isDerivedUnion");
    }
}

/*!
    True indicates this property can be used to uniquely identify an instance of the containing Class.
 */
bool QMofProperty::isID() const
{
    // This is a read-write property

    return _isID;
}

void QMofProperty::setID(bool isID)
{
    // This is a read-write property

    if (_isID != isID) {
        _isID = isID;
        _qModelingObject->modifiedResettableProperties() << QStringLiteral("isID");
    }
}

/*!
    If true, the attribute may only be read, and not written.
 */
bool QMofProperty::isReadOnly() const
{
    // This is a read-write property

    return _isReadOnly;
}

void QMofProperty::setReadOnly(bool isReadOnly)
{
    // This is a read-write property

    if (_isReadOnly != isReadOnly) {
        _isReadOnly = isReadOnly;
        _qModelingObject->modifiedResettableProperties() << QStringLiteral("isReadOnly");

        // Adjust redefined properties
        QMofStructuralFeature::setReadOnly(isReadOnly);
    }
}

/*!
    In the case where the property is one navigable end of a binary association with both ends navigable, this gives the other end.
 */
QMofProperty *QMofProperty::opposite() const
{
    // This is a read-write derived association end

    qWarning("QMofProperty::opposite(): to be implemented (this is a derived association end)");

    return 0;
}

void QMofProperty::setOpposite(QMofProperty *opposite)
{
    // This is a read-write derived association end

    qWarning("QMofProperty::setOpposite(): to be implemented (this is a derived association end)");
    Q_UNUSED(opposite);

    if (false /* <derivedexclusion-criteria> */) {
        // <derived-code>
    }
}

/*!
    References the owning association of this property, if any.
 */
QMofAssociation *QMofProperty::owningAssociation() const
{
    // This is a read-write association end

    return _owningAssociation;
}

void QMofProperty::setOwningAssociation(QMofAssociation *owningAssociation)
{
    // This is a read-write association end

    if (_owningAssociation != owningAssociation) {
        // Adjust subsetted properties
        removeFeaturingClassifier(_owningAssociation);
        removeRedefinitionContext(_owningAssociation);

        _owningAssociation = owningAssociation;
        if (owningAssociation && owningAssociation->asQModelingObject() && this->asQModelingObject())
            QObject::connect(owningAssociation->asQModelingObject(), SIGNAL(destroyed()), this->asQModelingObject(), SLOT(setOwningAssociation()));

        // Adjust subsetted properties
        setNamespace(owningAssociation);
        setAssociation(owningAssociation);
        if (owningAssociation) {
            addFeaturingClassifier(owningAssociation);
        }
        if (owningAssociation) {
            addRedefinitionContext(owningAssociation);
        }
    }
}

/*!
    References the properties that are redefined by this property.
 */
const QSet<QMofProperty *> QMofProperty::redefinedProperties() const
{
    // This is a read-write association end

    return _redefinedProperties;
}

void QMofProperty::addRedefinedProperty(QMofProperty *redefinedProperty)
{
    // This is a read-write association end

    if (!_redefinedProperties.contains(redefinedProperty)) {
        _redefinedProperties.insert(redefinedProperty);
        if (redefinedProperty && redefinedProperty->asQModelingObject() && this->asQModelingObject())
            QObject::connect(redefinedProperty->asQModelingObject(), SIGNAL(destroyed(QObject*)), this->asQModelingObject(), SLOT(removeRedefinedProperty(QObject *)));

        // Adjust subsetted properties
        addRedefinedElement(redefinedProperty);
    }
}

void QMofProperty::removeRedefinedProperty(QMofProperty *redefinedProperty)
{
    // This is a read-write association end

    if (_redefinedProperties.contains(redefinedProperty)) {
        _redefinedProperties.remove(redefinedProperty);

        // Adjust subsetted properties
        removeRedefinedElement(redefinedProperty);
    }
}

/*!
    References the properties of which this property is constrained to be a subset.
 */
const QSet<QMofProperty *> QMofProperty::subsettedProperties() const
{
    // This is a read-write association end

    return _subsettedProperties;
}

void QMofProperty::addSubsettedProperty(QMofProperty *subsettedProperty)
{
    // This is a read-write association end

    if (!_subsettedProperties.contains(subsettedProperty)) {
        _subsettedProperties.insert(subsettedProperty);
        if (subsettedProperty && subsettedProperty->asQModelingObject() && this->asQModelingObject())
            QObject::connect(subsettedProperty->asQModelingObject(), SIGNAL(destroyed(QObject*)), this->asQModelingObject(), SLOT(removeSubsettedProperty(QObject *)));
    }
}

void QMofProperty::removeSubsettedProperty(QMofProperty *subsettedProperty)
{
    // This is a read-write association end

    if (_subsettedProperties.contains(subsettedProperty)) {
        _subsettedProperties.remove(subsettedProperty);
    }
}

// OPERATIONS

/*!
    The query isAttribute() is true if the Property is defined as an attribute of some classifier.
 */
bool QMofProperty::isAttribute(QMofProperty *p) const
{
    qWarning("QMofProperty::isAttribute(): to be implemented (operation)");

    Q_UNUSED(p);
    return bool ();
}

/*!
    The query isConsistentWith() specifies, for any two Properties in a context in which redefinition is possible, whether redefinition would be logically consistent. A redefining property is consistent with a redefined property if the type of the redefining property conforms to the type of the redefined property, the multiplicity of the redefining property (if specified) is contained in the multiplicity of the redefined property.
 */
bool QMofProperty::isConsistentWith(QMofRedefinableElement *redefinee) const
{
    qWarning("QMofProperty::isConsistentWith(): to be implemented (operation)");

    Q_UNUSED(redefinee);
    return bool ();
}

/*!
    The query isNavigable() indicates whether it is possible to navigate across the property.
 */
bool QMofProperty::isNavigable() const
{
    qWarning("QMofProperty::isNavigable(): to be implemented (operation)");

    return bool ();
}

/*!
    The query subsettingContext() gives the context for subsetting a property. It consists, in the case of an attribute, of the corresponding classifier, and in the case of an association end, all of the classifiers at the other ends.
 */
QSet<QMofType *> QMofProperty::subsettingContext() const
{
    qWarning("QMofProperty::subsettingContext(): to be implemented (operation)");

    return QSet<QMofType *> ();
}

QT_END_NAMESPACE