1 files changed, 0 insertions, 230 deletions
diff --git a/src/corelib/kernel/qmetatype.h b/src/corelib/kernel/qmetatype.h
index 06a3241062..4ad2885bed 100644
--- a/src/corelib/kernel/qmetatype.h
+++ b/src/corelib/kernel/qmetatype.h
@@ -694,221 +694,6 @@ public:
     }
 };
 
-enum IteratorCapability
-{
-    ForwardCapability = 1,
-    BiDirectionalCapability = 2,
-    RandomAccessCapability = 4
-};
-
-enum ContainerCapability
-{
-    ContainerIsAppendable = 1
-};
-
-template<typename Container, typename T = void>
-struct ContainerCapabilitiesImpl
-{
-    enum {ContainerCapabilities = 0};
-    using appendFunction = void(*)(const void *container, const void *newElement);
-    static constexpr const appendFunction appendImpl = nullptr;
-};
-
-template<typename Container>
-struct ContainerCapabilitiesImpl<Container, decltype(std::declval<Container>().push_back(std::declval<typename Container::value_type>()))>
-{
-    enum {ContainerCapabilities = ContainerIsAppendable};
-
-    // The code below invokes undefined behavior if and only if the pointer passed into QSequentialIterableImpl
-    // pointed to a const object to begin with
-    static void appendImpl(const void *container, const void *value)
-    { static_cast<Container *>(const_cast<void *>(container))->push_back(*static_cast<const typename Container::value_type *>(value)); }
-};
-
-template<typename Container>
-struct ContainerCapabilitiesImpl<Container,
-        std::void_t<decltype(std::declval<Container>().insert(std::declval<typename Container::value_type>())),
-                    decltype(std::declval<typename Container::value_type>() == std::declval<typename Container::value_type>())>>
-{
-    enum {ContainerCapabilities = ContainerIsAppendable};
-
-    // The code below invokes undefined behavior if and only if the pointer passed into QSequentialIterableImpl
-    // pointed to a const object to begin with
-    static void appendImpl(const void *container, const void *value)
-    { static_cast<Container *>(const_cast<void *>(container))->insert(*static_cast<const typename Container::value_type *>(value)); }
-};
-
-template<typename T, typename Category = typename std::iterator_traits<typename T::const_iterator>::iterator_category>
-struct CapabilitiesImpl;
-
-template<typename T>
-struct CapabilitiesImpl<T, std::forward_iterator_tag>
-{ enum { IteratorCapabilities = ForwardCapability }; };
-template<typename T>
-struct CapabilitiesImpl<T, std::bidirectional_iterator_tag>
-{ enum { IteratorCapabilities = BiDirectionalCapability | ForwardCapability }; };
-template<typename T>
-struct CapabilitiesImpl<T, std::random_access_iterator_tag>
-{ enum { IteratorCapabilities = RandomAccessCapability | BiDirectionalCapability | ForwardCapability }; };
-
-template<typename T>
-struct ContainerAPI : CapabilitiesImpl<T>
-{
-    static int size(const T *t) { return int(std::distance(t->begin(), t->end())); }
-};
-
-template<typename T>
-struct ContainerAPI<QList<T>> : CapabilitiesImpl<QList<T>>
-{ static int size(const QList<T> *t) { return t->size(); } };
-
-template<typename T>
-struct ContainerAPI<std::vector<T> > : CapabilitiesImpl<std::vector<T> >
-{ static int size(const std::vector<T> *t) { return int(t->size()); } };
-
-template<typename T>
-struct ContainerAPI<std::list<T> > : CapabilitiesImpl<std::list<T> >
-{ static int size(const std::list<T> *t) { return int(t->size()); } };
-
-/*
- revision 0: _iteratorCapabilties is treated as a bitfield, the remaining bits are used to introduce
-             _revision, _containerCapabilities and _unused. The latter contains 21 bits that are
-             not used yet
-*/
-class QSequentialIterableImpl
-{
-public:
-    const void * _iterable;
-    void *_iterator;
-    QMetaType _metaType;
-    uint _iteratorCapabilities;
-    // Iterator capabilities looks actually like
-    // uint _iteratorCapabilities:4;
-    // uint _revision:3;
-    // uint _containerCapabilities:4;
-    // uint _unused:21;
-    typedef int(*sizeFunc)(const void *p);
-    typedef void (*atFunc)(const void *p, int, void *);
-    enum Position { ToBegin, ToEnd };
-    typedef void (*moveIteratorFunc)(const void *p, void **, Position position);
-    typedef void (*advanceFunc)(void **p, int);
-    typedef void (*getFunc)( void * const *p, void *dataPtr);
-    typedef void (*destroyIterFunc)(void **p);
-    typedef bool (*equalIterFunc)(void * const *p, void * const *other);
-    typedef void (*copyIterFunc)(void **, void * const *);
-    typedef void(*appendFunction)(const void *container, const void *newElement);
-
-    IteratorCapability iteratorCapabilities() {return static_cast<IteratorCapability>(_iteratorCapabilities & 0xF);}
-    uint revision() {return _iteratorCapabilities >> 4 & 0x7;}
-    uint containerCapabilities() {return _iteratorCapabilities >> 7 & 0xF;}
-
-    sizeFunc _size;
-    atFunc _at;
-    moveIteratorFunc _moveTo;
-    appendFunction _append;
-    advanceFunc _advance;
-    getFunc _get;
-    destroyIterFunc _destroyIter;
-    equalIterFunc _equalIter;
-    copyIterFunc _copyIter;
-
-    template<class T>
-    static int sizeImpl(const void *p)
-    { return ContainerAPI<T>::size(static_cast<const T*>(p)); }
-
-    template<class T>
-    static void atImpl(const void *p, int idx, void *dataPtr)
-    {
-        typename T::const_iterator i = static_cast<const T*>(p)->begin();
-        std::advance(i, idx);
-        IteratorOwner<typename T::const_iterator>::getData(i, dataPtr);
-    }
-
-    template<class Container>
-    static void moveToImpl(const void *container, void **iterator, Position position)
-    {
-        auto it = (position == ToBegin) ?
-                    static_cast<const Container *>(container)->begin() :
-                    static_cast<const Container *>(container)->end();
-        IteratorOwner<typename Container::const_iterator>::assign(iterator, it);
-    }
-
-public:
-    template<class T> QSequentialIterableImpl(const T*p)
-      : _iterable(p)
-      , _iterator(nullptr)
-      , _metaType(QMetaType::fromType<typename T::value_type>())
-      , _iteratorCapabilities(ContainerAPI<T>::IteratorCapabilities | (0 << 4) | (ContainerCapabilitiesImpl<T>::ContainerCapabilities << (4+3)))
-      , _size(sizeImpl<T>)
-      , _at(atImpl<T>)
-      , _moveTo(moveToImpl<T>)
-      , _append(ContainerCapabilitiesImpl<T>::appendImpl)
-      , _advance(IteratorOwner<typename T::const_iterator>::advance)
-      , _get(IteratorOwner<typename T::const_iterator>::getData)
-      , _destroyIter(IteratorOwner<typename T::const_iterator>::destroy)
-      , _equalIter(IteratorOwner<typename T::const_iterator>::equal)
-      , _copyIter(IteratorOwner<typename T::const_iterator>::assign)
-    {
-    }
-
-    QSequentialIterableImpl()
-      : _iterable(nullptr)
-      , _iterator(nullptr)
-      , _iteratorCapabilities(0 | (0 << 4) ) // no iterator capabilities, revision 0
-      , _size(nullptr)
-      , _at(nullptr)
-      , _moveTo(nullptr)
-      , _append(nullptr)
-      , _advance(nullptr)
-      , _get(nullptr)
-      , _destroyIter(nullptr)
-      , _equalIter(nullptr)
-      , _copyIter(nullptr)
-    {
-    }
-
-    inline void moveToBegin() {
-        _moveTo(_iterable, &_iterator, ToBegin);
-    }
-    inline void moveToEnd() {
-        _moveTo(_iterable, &_iterator, ToEnd);
-    }
-    inline bool equal(const QSequentialIterableImpl&other) const { return _equalIter(&_iterator, &other._iterator); }
-    inline QSequentialIterableImpl &advance(int i) {
-      Q_ASSERT(i > 0 || _iteratorCapabilities & BiDirectionalCapability);
-      _advance(&_iterator, i);
-      return *this;
-    }
-
-    inline void append(const void *newElement) {
-        if (containerCapabilities() & ContainerIsAppendable)
-            _append(_iterable, newElement);
-    }
-
-    inline void getCurrent(void *dataPtr) const { _get(&_iterator, dataPtr); }
-
-    void at(int idx, void *dataPtr) const
-    { return _at(_iterable, idx, dataPtr); }
-
-    int size() const { Q_ASSERT(_iterable); return _size(_iterable); }
-
-    inline void destroyIter() { _destroyIter(&_iterator); }
-
-    void copy(const QSequentialIterableImpl &other)
-    {
-      *this = other;
-      _copyIter(&_iterator, &other._iterator);
-    }
-};
-QT_METATYPE_PRIVATE_DECLARE_TYPEINFO(QSequentialIterableImpl, Q_MOVABLE_TYPE)
-
-template<typename From>
-struct QSequentialIterableConvertFunctor
-{
-    QSequentialIterableImpl operator()(const From &f) const
-    {
-        return QSequentialIterableImpl(&f);
-    }
-};
 }
 
 namespace QtMetaTypePrivate {
@@ -1890,7 +1675,6 @@ QT_END_NAMESPACE
 
 QT_FOR_EACH_STATIC_TYPE(Q_DECLARE_BUILTIN_METATYPE)
 
-Q_DECLARE_METATYPE(QtMetaTypePrivate::QSequentialIterableImpl)
 Q_DECLARE_METATYPE(QtMetaTypePrivate::QAssociativeIterableImpl)
 Q_DECLARE_METATYPE(QtMetaTypePrivate::QPairVariantInterfaceImpl)
 
@@ -1909,20 +1693,6 @@ inline bool QtPrivate::IsMetaTypePair<T, true>::registerConverter(int id)
 
 namespace QtPrivate {
     template<typename T>
-    struct SequentialValueTypeIsMetaType<T, true>
-    {
-        static bool registerConverter(int id)
-        {
-            const int toId = qMetaTypeId<QtMetaTypePrivate::QSequentialIterableImpl>();
-            if (!QMetaType::hasRegisteredConverterFunction(id, toId)) {
-                QtMetaTypePrivate::QSequentialIterableConvertFunctor<T> o;
-                return QMetaType::registerConverter<T, QtMetaTypePrivate::QSequentialIterableImpl>(o);
-            }
-            return true;
-        }
-    };
-
-    template<typename T>
     struct AssociativeValueTypeIsMetaType<T, true>
     {
         static bool registerConverter(int id)