qqmllist.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qqmllist.h"
#include "qqmllist_p.h"
#include <QtQml/private/qqmlproperty_p.h>
 
QT_BEGIN_NAMESPACE
 
static bool isObjectCompatible(QObject *object, QQmlListReferencePrivate *d)
{
    if (object) {
        const QQmlMetaObject elementType = d->elementType();
        if (elementType.isNull() || !QQmlMetaObject::canConvert(object, elementType))
            return false;
    }
    return true;
}
 
QQmlListReferencePrivate::QQmlListReferencePrivate()
: refCount(1)
{
}
 
QQmlListReference QQmlListReferencePrivate::init(
        const QQmlListProperty<QObject> &prop, QMetaType propType)
{
    QQmlListReference rv;
 
    if (!prop.object) return rv;
 
    rv.d = new QQmlListReferencePrivate;
    rv.d->object = prop.object;
    rv.d->property = prop;
    rv.d->propertyType = propType;
 
    return rv;
}
 
void QQmlListReferencePrivate::addref()
{
    Q_ASSERT(refCount > 0);
    ++refCount;
}
 
void QQmlListReferencePrivate::release()
{
    Q_ASSERT(refCount > 0);
    --refCount;
    if (!refCount)
        delete this;
}
 
QQmlListReference::QQmlListReference()
: d(nullptr)
{
}
 
#if QT_DEPRECATED_SINCE(6, 4)
QQmlListReference::QQmlListReference(const QVariant &variant, [[maybe_unused]] QQmlEngine *engine)
    : QQmlListReference(variant)
{}
 
QQmlListReference::QQmlListReference(QObject *object, const char *property,
                                     [[maybe_unused]] QQmlEngine *engine)
    : QQmlListReference(object, property)
{}
#endif
 
QQmlListReference::QQmlListReference(const QVariant &variant)
    : d(nullptr)
{
    const QMetaType t = variant.metaType();
    if (!(t.flags() & QMetaType::IsQmlList))
        return;
 
    d = new QQmlListReferencePrivate;
    d->propertyType = t;
 
    d->property.~QQmlListProperty();
    t.construct(&d->property, variant.constData());
 
    d->object = d->property.object;
}
 
QQmlListReference::QQmlListReference(QObject *object, const char *property)
    : d(nullptr)
{
    if (!object || !property) return;
 
    QQmlPropertyData local;
    const QQmlPropertyData *data =
        QQmlPropertyCache::property(object, QLatin1String(property), nullptr, &local);
 
    if (!data || !data->isQList()) return;
 
    d = new QQmlListReferencePrivate;
    d->object = object;
    d->propertyType = data->propType();
 
    void *args[] = { &d->property, nullptr };
    QMetaObject::metacall(object, QMetaObject::ReadProperty, data->coreIndex(), args);
}
 
QQmlListReference::QQmlListReference(const QQmlListReference &o)
: d(o.d)
{
    if (d) d->addref();
}
 
QQmlListReference &QQmlListReference::operator=(const QQmlListReference &o)
{
    if (o.d) o.d->addref();
    if (d) d->release();
    d = o.d;
    return *this;
}
 
QQmlListReference::~QQmlListReference()
{
    if (d) d->release();
}
 
bool QQmlListReference::isValid() const
{
    return d && d->object;
}
 
QObject *QQmlListReference::object() const
{
    if (isValid()) return d->object;
    else return nullptr;
}
 
const QMetaObject *QQmlListReference::listElementType() const
{
    return isValid() ? d->elementType() : nullptr;
}
 
bool QQmlListReference::canAppend() const
{
    return (isValid() && d->property.append);
}
 
bool QQmlListReference::canAt() const
{
    return (isValid() && d->property.at);
}
 
bool QQmlListReference::canClear() const
{
    return (isValid() && d->property.clear);
}
 
bool QQmlListReference::canCount() const
{
    return (isValid() && d->property.count);
}
 
bool QQmlListReference::canReplace() const
{
    return (isValid() && d->property.replace);
}
 
bool QQmlListReference::canRemoveLast() const
{
    return (isValid() && d->property.removeLast);
}
 
bool QQmlListReference::isManipulable() const
{
    return (isValid()
            && d->property.append
            && d->property.count
            && d->property.at
            && d->property.clear);
}
 
 
bool QQmlListReference::isReadable() const
{
    return (isValid() && d->property.count && d->property.at);
}
 
bool QQmlListReference::append(QObject *object) const
{
    if (!canAppend()) return false;
 
    if (!isObjectCompatible(object, d))
        return false;
 
    d->property.append(&d->property, object);
 
    return true;
}
 
QObject *QQmlListReference::at(qsizetype index) const
{
    if (!canAt()) return nullptr;
 
    return d->property.at(&d->property, index);
}
 
bool QQmlListReference::clear() const
{
    if (!canClear()) return false;
 
    d->property.clear(&d->property);
 
    return true;
}
 
qsizetype QQmlListReference::count() const
{
    if (!canCount()) return 0;
 
    return d->property.count(&d->property);
}
 
bool QQmlListReference::replace(qsizetype index, QObject *object) const
{
    if (!canReplace())
        return false;
 
    if (!isObjectCompatible(object, d))
        return false;
 
    d->property.replace(&d->property, index, object);
    return true;
}
 
bool QQmlListReference::removeLast() const
{
    if (!canRemoveLast())
        return false;
 
    d->property.removeLast(&d->property);
    return true;
}
 
QT_END_NAMESPACE