// 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/qiterable_impl.h>
#include <QtCore/qsequentialiterable.h>
#include <QtCore/qvariant.h>

QT_BEGIN_NAMESPACE

#if QT_DEPRECATED_SINCE(6, 15)
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED

/*!
    \class QSequentialIterable
    \deprecated [6.15] Use QMetaSequence::Iterable instead.
    \since 5.2
    \inmodule QtCore
    \brief The QSequentialIterable class is an iterable interface for a container in a QVariant.

    This class allows several methods of accessing the values of a container held within
    a QVariant. An instance of QSequentialIterable can be extracted from a QVariant if it can
    be converted to a QVariantList.

    The container itself is not copied before iterating over it.

    \sa QVariant
*/

/*!
    \typedef QSequentialIterable::RandomAccessIterator
    Exposes an iterator using std::random_access_iterator_tag.
*/

/*!
    \typedef QSequentialIterable::BidirectionalIterator
    Exposes an iterator using std::bidirectional_iterator_tag.
*/

/*!
    \typedef QSequentialIterable::ForwardIterator
    Exposes an iterator using std::forward_iterator_tag.
*/

/*!
    \typedef QSequentialIterable::InputIterator
    Exposes an iterator using std::input_iterator_tag.
*/

/*!
    \typedef QSequentialIterable::RandomAccessConstIterator
    Exposes a const_iterator using std::random_access_iterator_tag.
*/

/*!
    \typedef QSequentialIterable::BidirectionalConstIterator
    Exposes a const_iterator using std::bidirectional_iterator_tag.
*/

/*!
    \typedef QSequentialIterable::ForwardConstIterator
    Exposes a const_iterator using std::forward_iterator_tag.
*/

/*!
    \typedef QSequentialIterable::InputConstIterator
    Exposes a const_iterator using std::input_iterator_tag.
*/

/*!
    Adds \a value to the container, at \a position, if possible.
 */
void QSequentialIterable::addValue(const QVariant &value, Position position)
{
    QtPrivate::QVariantTypeCoercer coercer;
    const void *valuePtr = coercer.coerce(value, metaContainer().valueMetaType());

    switch (position) {
    case AtBegin:
        if (metaContainer().canAddValueAtBegin())
            metaContainer().addValueAtBegin(mutableIterable(), valuePtr);
        break;
    case AtEnd:
        if (metaContainer().canAddValueAtEnd())
            metaContainer().addValueAtEnd(mutableIterable(), valuePtr);
        break;
    case Unspecified:
        if (metaContainer().canAddValue())
            metaContainer().addValue(mutableIterable(), valuePtr);
        break;
    }
}

/*!
    Removes a value from the container, at \a position, if possible.
 */
void QSequentialIterable::removeValue(Position position)
{
    switch (position) {
    case AtBegin:
        if (metaContainer().canRemoveValueAtBegin())
            metaContainer().removeValueAtBegin(mutableIterable());
        break;
    case AtEnd:
        if (metaContainer().canRemoveValueAtEnd())
            metaContainer().removeValueAtEnd(mutableIterable());
        break;
    case Unspecified:
        if (metaContainer().canRemoveValue())
            metaContainer().removeValue(mutableIterable());
        break;
    }
}

QMetaType QSequentialIterable::valueMetaType() const
{
    return QMetaType(metaContainer().valueMetaType());
}

/*!
    Returns the value at position \a idx in the container.
*/
QVariant QSequentialIterable::at(qsizetype idx) const
{
    QVariant v(valueMetaType());
    void *dataPtr;
    if (valueMetaType() == QMetaType::fromType<QVariant>())
        dataPtr = &v;
    else
        dataPtr = v.data();

    const QMetaSequence meta = metaContainer();
    if (meta.canGetValueAtIndex()) {
        meta.valueAtIndex(m_iterable.constPointer(), idx, dataPtr);
    } else if (meta.canGetValueAtConstIterator()) {
        void *iterator = meta.constBegin(m_iterable.constPointer());
        meta.advanceConstIterator(iterator, idx);
        meta.valueAtConstIterator(iterator, dataPtr);
        meta.destroyConstIterator(iterator);
    }

    return v;
}

/*!
    Sets the element at position \a idx in the container to \a value.
*/
void QSequentialIterable::set(qsizetype idx, const QVariant &value)
{
    QtPrivate::QVariantTypeCoercer coercer;
    const void *dataPtr = coercer.coerce(value, metaContainer().valueMetaType());

    const QMetaSequence meta = metaContainer();
    if (meta.canSetValueAtIndex()) {
        meta.setValueAtIndex(m_iterable.mutablePointer(), idx, dataPtr);
    } else if (meta.canSetValueAtIterator()) {
        void *iterator = meta.begin(m_iterable.mutablePointer());
        meta.advanceIterator(iterator, idx);
        meta.setValueAtIterator(iterator, dataPtr);
        meta.destroyIterator(iterator);
    }
}

/*!
    \typealias QSequentialIterable::const_iterator
    \deprecated [6.15] Use QMetaSequence::Iterable::ConstIterator instead.
    \brief The QSequentialIterable::const_iterator allows iteration over a container in a QVariant.

    A QSequentialIterable::const_iterator can only be created by a QSequentialIterable instance,
    and can be used in a way similar to other stl-style iterators.
*/

/*!
    \typealias QSequentialIterable::iterator
    \since 6.0
    \deprecated [6.15] Use QMetaSequence::Iterable::Iterator instead.
    \brief The QSequentialIterable::iterator allows iteration over a container in a QVariant.

    A QSequentialIterable::iterator can only be created by a QSequentialIterable instance,
    and can be used in a way similar to other stl-style iterators.
*/

/*!
    \class QSequentialIterator
    \internal
 */

/*!
    Returns the current item, converted to a QVariantRef.
*/
QVariantRef<QSequentialIterator> QSequentialIterator::operator*() const
{
    return QVariantRef<QSequentialIterator>(this);
}

/*!
    Returns the current item, converted to a QVariantPointer.
*/
QVariantPointer<QSequentialIterator> QSequentialIterator::operator->() const
{
    return QVariantPointer<QSequentialIterator>(this);
}

/*!
    \class QSequentialConstIterator
    \internal
 */

/*!
    Returns the current item, converted to a QVariant.
*/
QVariant QSequentialConstIterator::operator*() const
{
    return QtIterablePrivate::retrieveElement(metaContainer().valueMetaType(), [this](void *dataPtr) {
        metaContainer().valueAtConstIterator(constIterator(), dataPtr);
    });
}

/*!
    Returns the current item, converted to a QVariantConstPointer.
*/
QVariantConstPointer QSequentialConstIterator::operator->() const
{
    return QVariantConstPointer(operator*());
}

QT_WARNING_POP
#endif // QT_DEPRECATED_SINCE(6, 15)

QT_END_NAMESPACE
