qassociativeiterable.cpp

Go to the documentation of this file.

// Copyright (C) 2020 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 <QtCore/qassociativeiterable.h>
#include <QtCore/qvariant.h>
 
#include <QtCore/private/qiterable_p.h>
 
QT_BEGIN_NAMESPACE
 
QVariant QAssociativeIterator::key() const
{
    return QIterablePrivate::retrieveElement(
                metaContainer().keyMetaType(), [this](void *dataPtr) {
        metaContainer().keyAtIterator(constIterator(), dataPtr);
    });
}
 
QVariantRef<QAssociativeIterator> QAssociativeIterator::value() const
{
    const QMetaType mappedMetaType(metaContainer().mappedMetaType());
    return QVariantRef<QAssociativeIterator>(mappedMetaType.isValid() ? this : nullptr);
}
 
QVariantRef<QAssociativeIterator> QAssociativeIterator::operator*() const
{
    return QVariantRef<QAssociativeIterator>(this);
}
 
QVariantPointer<QAssociativeIterator> QAssociativeIterator::operator->() const
{
    return QVariantPointer<QAssociativeIterator>(this);
}
 
QVariant QAssociativeConstIterator::key() const
{
    return QIterablePrivate::retrieveElement(
                metaContainer().keyMetaType(), [this](void *dataPtr) {
        metaContainer().keyAtConstIterator(constIterator(), dataPtr);
    });
}
 
QVariant QAssociativeConstIterator::value() const
{
    return QIterablePrivate::retrieveElement(
                metaContainer().mappedMetaType(), [this](void *dataPtr) {
        metaContainer().mappedAtConstIterator(constIterator(), dataPtr);
    });
}
 
QVariant QAssociativeConstIterator::operator*() const
{
    const QMetaType mappedMetaType(metaContainer().mappedMetaType());
    return mappedMetaType.isValid() ? value() : key();
}
 
QVariantConstPointer QAssociativeConstIterator::operator->() const
{
    return QVariantConstPointer(operator*());
}
 
QAssociativeIterable::const_iterator QAssociativeIterable::find(const QVariant &key) const
{
    const QMetaAssociation meta = metaContainer();
    QtPrivate::QVariantTypeCoercer coercer;
    if (const void *keyData = coercer.convert(key, meta.keyMetaType())) {
        return const_iterator(QConstIterator(this, meta.createConstIteratorAtKey(
                                                 constIterable(), keyData)));
    }
    return constEnd();
}
 
QAssociativeIterable::iterator QAssociativeIterable::mutableFind(const QVariant &key)
{
    const QMetaAssociation meta = metaContainer();
    QtPrivate::QVariantTypeCoercer coercer;
    if (const void *keyData = coercer.convert(key, meta.keyMetaType()))
        return iterator(QIterator(this, meta.createIteratorAtKey(mutableIterable(), keyData)));
    return mutableEnd();
}
 
bool QAssociativeIterable::containsKey(const QVariant &key)
{
    QtPrivate::QVariantTypeCoercer keyCoercer;
    QMetaAssociation meta = metaContainer();
    if (const void *keyData = keyCoercer.convert(key, meta.keyMetaType()))
        return meta.containsKey(constIterable(), keyData);
    return false;
}
 
void QAssociativeIterable::insertKey(const QVariant &key)
{
    QMetaAssociation meta = metaContainer();
    QtPrivate::QVariantTypeCoercer keyCoercer;
    meta.insertKey(mutableIterable(), keyCoercer.coerce(key, meta.keyMetaType()));
}
 
void QAssociativeIterable::removeKey(const QVariant &key)
{
    QMetaAssociation meta = metaContainer();
    QtPrivate::QVariantTypeCoercer keyCoercer;
    meta.removeKey(mutableIterable(), keyCoercer.coerce(key, meta.keyMetaType()));
}
 
 
QVariant QAssociativeIterable::value(const QVariant &key) const
{
    const QMetaAssociation meta = metaContainer();
    const QMetaType mappedMetaType = meta.mappedMetaType();
 
    QtPrivate::QVariantTypeCoercer coercer;
    const void *keyData = coercer.coerce(key, meta.keyMetaType());
 
    if (mappedMetaType == QMetaType::fromType<QVariant>()) {
        QVariant result;
        meta.mappedAtKey(constIterable(), keyData, &result);
        return result;
    }
 
    QVariant result(mappedMetaType);
    meta.mappedAtKey(constIterable(), keyData, result.data());
    return result;
}
 
void QAssociativeIterable::setValue(const QVariant &key, const QVariant &mapped)
{
    QtPrivate::QVariantTypeCoercer keyCoercer;
    QtPrivate::QVariantTypeCoercer mappedCoercer;
    QMetaAssociation meta = metaContainer();
    meta.setMappedAtKey(mutableIterable(), keyCoercer.coerce(key, meta.keyMetaType()),
                        mappedCoercer.coerce(mapped, meta.mappedMetaType()));
}
 
QT_END_NAMESPACE