1/****************************************************************************
2**
3** Copyright (C) 2016 The Qt Company Ltd.
4** Contact: https://www.qt.io/licensing/
5**
6** This file is part of the QtQml module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and The Qt Company. For licensing terms
14** and conditions see https://www.qt.io/terms-conditions. For further
15** information use the contact form at https://www.qt.io/contact-us.
16**
17** GNU Lesser General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU Lesser
19** General Public License version 3 as published by the Free Software
20** Foundation and appearing in the file LICENSE.LGPL3 included in the
21** packaging of this file. Please review the following information to
22** ensure the GNU Lesser General Public License version 3 requirements
23** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24**
25** GNU General Public License Usage
26** Alternatively, this file may be used under the terms of the GNU
27** General Public License version 2.0 or (at your option) the GNU General
28** Public license version 3 or any later version approved by the KDE Free
29** Qt Foundation. The licenses are as published by the Free Software
30** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31** included in the packaging of this file. Please review the following
32** information to ensure the GNU General Public License requirements will
33** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34** https://www.gnu.org/licenses/gpl-3.0.html.
35**
36** $QT_END_LICENSE$
37**
38****************************************************************************/
39
40#include <QtQml/qqml.h>
41
42#include "qv4sequenceobject_p.h"
43
44#include <private/qv4functionobject_p.h>
45#include <private/qv4arrayobject_p.h>
46#include <private/qqmlengine_p.h>
47#include <private/qv4scopedvalue_p.h>
48#include <private/qv4jscall_p.h>
49#include "qv4runtime_p.h"
50#include "qv4objectiterator_p.h"
51#include <private/qqmlvaluetypewrapper_p.h>
52#if QT_CONFIG(qml_itemmodel)
53#include <private/qqmlmodelindexvaluetype_p.h>
54#include <QtCore/qabstractitemmodel.h>
55#endif
56
57#include <algorithm>
58
59QT_BEGIN_NAMESPACE
60
61using namespace QV4;
62
63// helper function to generate valid warnings if errors occur during sequence operations.
64static void generateWarning(QV4::ExecutionEngine *v4, const QString& description)
65{
66 QQmlEngine *engine = v4->qmlEngine();
67 if (!engine)
68 return;
69 QQmlError retn;
70 retn.setDescription(description);
71
72 QV4::CppStackFrame *stackFrame = v4->currentStackFrame;
73
74 retn.setLine(stackFrame->lineNumber());
75 retn.setUrl(QUrl(stackFrame->source()));
76 QQmlEnginePrivate::warning(engine, retn);
77}
78
79// F(elementType, elementTypeName, sequenceType, defaultValue)
80#if QT_CONFIG(qml_itemmodel)
81#define FOREACH_QML_SEQUENCE_TYPE_FOR_ITEMMODEL(F) \
82 F(QModelIndex, QModelIndex, QModelIndexList, QModelIndex()) \
83 F(QModelIndex, QModelIndexVector, QVector<QModelIndex>, QModelIndex()) \
84 F(QModelIndex, QModelIndexStdVector, std::vector<QModelIndex>, QModelIndex()) \
85 F(QItemSelectionRange, QItemSelectionRange, QItemSelection, QItemSelectionRange())
86#else
87#define FOREACH_QML_SEQUENCE_TYPE_FOR_ITEMMODEL(F)
88#endif
89
90#define FOREACH_QML_SEQUENCE_TYPE(F) \
91 F(int, IntVector, QVector<int>, 0) \
92 F(qreal, RealVector, QVector<qreal>, 0.0) \
93 F(bool, BoolVector, QVector<bool>, false) \
94 F(int, IntStdVector, std::vector<int>, 0) \
95 F(qreal, RealStdVector, std::vector<qreal>, 0.0) \
96 F(bool, BoolStdVector, std::vector<bool>, false) \
97 F(int, Int, QList<int>, 0) \
98 F(qreal, Real, QList<qreal>, 0.0) \
99 F(bool, Bool, QList<bool>, false) \
100 F(QString, String, QList<QString>, QString()) \
101 F(QString, QString, QStringList, QString()) \
102 F(QString, StringVector, QVector<QString>, QString()) \
103 F(QString, StringStdVector, std::vector<QString>, QString()) \
104 F(QUrl, Url, QList<QUrl>, QUrl()) \
105 F(QUrl, UrlVector, QVector<QUrl>, QUrl()) \
106 F(QUrl, UrlStdVector, std::vector<QUrl>, QUrl()) \
107 FOREACH_QML_SEQUENCE_TYPE_FOR_ITEMMODEL(F)
108
109static QV4::ReturnedValue convertElementToValue(QV4::ExecutionEngine *engine, const QString &element)
110{
111 return engine->newString(s: element)->asReturnedValue();
112}
113
114static QV4::ReturnedValue convertElementToValue(QV4::ExecutionEngine *, int element)
115{
116 return QV4::Encode(element);
117}
118
119static QV4::ReturnedValue convertElementToValue(QV4::ExecutionEngine *engine, const QUrl &element)
120{
121 return engine->newString(s: element.toString())->asReturnedValue();
122}
123
124#if QT_CONFIG(qml_itemmodel)
125static QV4::ReturnedValue convertElementToValue(QV4::ExecutionEngine *engine, const QModelIndex &element)
126{
127 const QMetaObject *vtmo = QQmlValueTypeFactory::metaObjectForMetaType(type: QMetaType::QModelIndex);
128 return QV4::QQmlValueTypeWrapper::create(engine, QVariant(element), metaObject: vtmo, typeId: QMetaType::QModelIndex);
129}
130
131static QV4::ReturnedValue convertElementToValue(QV4::ExecutionEngine *engine, const QItemSelectionRange &element)
132{
133 int metaTypeId = qMetaTypeId<QItemSelectionRange>();
134 const QMetaObject *vtmo = QQmlValueTypeFactory::metaObjectForMetaType(type: metaTypeId);
135 return QV4::QQmlValueTypeWrapper::create(engine, QVariant::fromValue(value: element), metaObject: vtmo, typeId: metaTypeId);
136}
137#endif
138
139static QV4::ReturnedValue convertElementToValue(QV4::ExecutionEngine *, qreal element)
140{
141 return QV4::Encode(element);
142}
143
144static QV4::ReturnedValue convertElementToValue(QV4::ExecutionEngine *, bool element)
145{
146 return QV4::Encode(element);
147}
148
149static QString convertElementToString(const QString &element)
150{
151 return element;
152}
153
154static QString convertElementToString(int element)
155{
156 return QString::number(element);
157}
158
159static QString convertElementToString(const QUrl &element)
160{
161 return element.toString();
162}
163
164#if QT_CONFIG(qml_itemmodel)
165static QString convertElementToString(const QModelIndex &element)
166{
167 return reinterpret_cast<const QQmlModelIndexValueType *>(&element)->toString();
168}
169
170static QString convertElementToString(const QItemSelectionRange &element)
171{
172 return reinterpret_cast<const QQmlItemSelectionRangeValueType *>(&element)->toString();
173}
174#endif
175
176static QString convertElementToString(qreal element)
177{
178 QString qstr;
179 RuntimeHelpers::numberToString(result: &qstr, num: element, radix: 10);
180 return qstr;
181}
182
183static QString convertElementToString(bool element)
184{
185 if (element)
186 return QStringLiteral("true");
187 else
188 return QStringLiteral("false");
189}
190
191template <typename ElementType> ElementType convertValueToElement(const Value &value);
192
193template <> QString convertValueToElement(const Value &value)
194{
195 return value.toQString();
196}
197
198template <> int convertValueToElement(const Value &value)
199{
200 return value.toInt32();
201}
202
203template <> QUrl convertValueToElement(const Value &value)
204{
205 return QUrl(value.toQString());
206}
207
208#if QT_CONFIG(qml_itemmodel)
209template <> QModelIndex convertValueToElement(const Value &value)
210{
211 const QQmlValueTypeWrapper *v = value.as<QQmlValueTypeWrapper>();
212 if (v)
213 return v->toVariant().toModelIndex();
214 return QModelIndex();
215}
216
217template <> QItemSelectionRange convertValueToElement(const Value &value)
218{
219 const QQmlValueTypeWrapper *v = value.as<QQmlValueTypeWrapper>();
220 if (v)
221 return v->toVariant().value<QItemSelectionRange>();
222 return QItemSelectionRange();
223}
224#endif
225
226template <> qreal convertValueToElement(const Value &value)
227{
228 return value.toNumber();
229}
230
231template <> bool convertValueToElement(const Value &value)
232{
233 return value.toBoolean();
234}
235
236namespace QV4 {
237
238template <typename Container> struct QQmlSequence;
239
240namespace Heap {
241
242template <typename Container>
243struct QQmlSequence : Object {
244 void init(const Container &container);
245 void init(QObject *object, int propertyIndex, bool readOnly);
246 void destroy() {
247 delete container;
248 object.destroy();
249 Object::destroy();
250 }
251
252 mutable Container *container;
253 QQmlQPointer<QObject> object;
254 int propertyIndex;
255 bool isReference : 1;
256 bool isReadOnly : 1;
257};
258
259}
260
261template <typename Container>
262struct QQmlSequence : public QV4::Object
263{
264 V4_OBJECT2(QQmlSequence<Container>, QV4::Object)
265 Q_MANAGED_TYPE(QmlSequence)
266 V4_PROTOTYPE(sequencePrototype)
267 V4_NEEDS_DESTROY
268public:
269
270 void init()
271 {
272 defineAccessorProperty(QStringLiteral("length"), method_get_length, method_set_length);
273 }
274
275 QV4::ReturnedValue containerGetIndexed(uint index, bool *hasProperty) const
276 {
277 /* Qt containers have int (rather than uint) allowable indexes. */
278 if (index > INT_MAX) {
279 generateWarning(engine(), QLatin1String("Index out of range during indexed get"));
280 if (hasProperty)
281 *hasProperty = false;
282 return Encode::undefined();
283 }
284 if (d()->isReference) {
285 if (!d()->object) {
286 if (hasProperty)
287 *hasProperty = false;
288 return Encode::undefined();
289 }
290 loadReference();
291 }
292 if (index < size_t(d()->container->size())) {
293 if (hasProperty)
294 *hasProperty = true;
295 return convertElementToValue(engine(), qAsConst(*(d()->container))[index]);
296 }
297 if (hasProperty)
298 *hasProperty = false;
299 return Encode::undefined();
300 }
301
302 bool containerPutIndexed(uint index, const QV4::Value &value)
303 {
304 if (internalClass()->engine->hasException)
305 return false;
306
307 /* Qt containers have int (rather than uint) allowable indexes. */
308 if (index > INT_MAX) {
309 generateWarning(engine(), QLatin1String("Index out of range during indexed set"));
310 return false;
311 }
312
313 if (d()->isReadOnly) {
314 engine()->throwTypeError(QLatin1String("Cannot insert into a readonly container"));
315 return false;
316 }
317
318 if (d()->isReference) {
319 if (!d()->object)
320 return false;
321 loadReference();
322 }
323
324 size_t count = size_t(d()->container->size());
325
326 typename Container::value_type element = convertValueToElement<typename Container::value_type>(value);
327
328 if (index == count) {
329 d()->container->push_back(element);
330 } else if (index < count) {
331 (*d()->container)[index] = element;
332 } else {
333 /* according to ECMA262r3 we need to insert */
334 /* the value at the given index, increasing length to index+1. */
335 d()->container->reserve(index + 1);
336 while (index > count++) {
337 d()->container->push_back(typename Container::value_type());
338 }
339 d()->container->push_back(element);
340 }
341
342 if (d()->isReference)
343 storeReference();
344 return true;
345 }
346
347 QV4::PropertyAttributes containerQueryIndexed(uint index) const
348 {
349 /* Qt containers have int (rather than uint) allowable indexes. */
350 if (index > INT_MAX) {
351 generateWarning(engine(), QLatin1String("Index out of range during indexed query"));
352 return QV4::Attr_Invalid;
353 }
354 if (d()->isReference) {
355 if (!d()->object)
356 return QV4::Attr_Invalid;
357 loadReference();
358 }
359 return (index < size_t(d()->container->size())) ? QV4::Attr_Data : QV4::Attr_Invalid;
360 }
361
362 struct OwnPropertyKeyIterator : ObjectOwnPropertyKeyIterator
363 {
364 ~OwnPropertyKeyIterator() override = default;
365 PropertyKey next(const Object *o, Property *pd = nullptr, PropertyAttributes *attrs = nullptr) override
366 {
367 const QQmlSequence *s = static_cast<const QQmlSequence *>(o);
368
369 if (s->d()->isReference) {
370 if (!s->d()->object)
371 return ObjectOwnPropertyKeyIterator::next(o, pd, attrs);
372 s->loadReference();
373 }
374
375 if (arrayIndex < static_cast<uint>(s->d()->container->size())) {
376 uint index = arrayIndex;
377 ++arrayIndex;
378 if (attrs)
379 *attrs = QV4::Attr_Data;
380
381 // TODO: Replace the container->at() below with operator[] in Qt6!
382 // TODO: But _not_ in Qt5!
383 //
384 // gcc 5.3.1 as shipped on RHEL 7.6 includes a copy of basic_string<char>
385 // into QtQml, when it sees a std::vector::at(). The basic_string symbols
386 // are publicly visible and preferred over the ones from libstdc++ when
387 // building user code. Therefore, removing this at() breaks binary
388 // compatibility. We _do_ want to remove it in Qt6, though.
389 //
390 // The exact mechanism is that at() checks its argument and can throw an
391 // out_of_range exception. The construction of this exception then triggers
392 // some string manipulation that uses the std::basic_string symbols. Clearly,
393 // this is a compiler bug. And clearly, we don't want the check as we can't
394 // catch the exception anyway.
395
396 if (pd)
397 pd->value = convertElementToValue(s->engine(), s->d()->container->at(index));
398 return PropertyKey::fromArrayIndex(idx: index);
399 }
400
401 return ObjectOwnPropertyKeyIterator::next(o, pd, attrs);
402 }
403 };
404
405 static OwnPropertyKeyIterator *containerOwnPropertyKeys(const Object *m, Value *target)
406 {
407 *target = *m;
408 return new OwnPropertyKeyIterator;
409 }
410
411 bool containerDeleteIndexedProperty(uint index)
412 {
413 /* Qt containers have int (rather than uint) allowable indexes. */
414 if (index > INT_MAX)
415 return false;
416 if (d()->isReadOnly)
417 return false;
418 if (d()->isReference) {
419 if (!d()->object)
420 return false;
421 loadReference();
422 }
423
424 if (index >= size_t(d()->container->size()))
425 return false;
426
427 /* according to ECMA262r3 it should be Undefined, */
428 /* but we cannot, so we insert a default-value instead. */
429 (*d()->container)[index] = typename Container::value_type();
430
431 if (d()->isReference)
432 storeReference();
433
434 return true;
435 }
436
437 bool containerIsEqualTo(Managed *other)
438 {
439 if (!other)
440 return false;
441 QQmlSequence<Container> *otherSequence = other->as<QQmlSequence<Container> >();
442 if (!otherSequence)
443 return false;
444 if (d()->isReference && otherSequence->d()->isReference) {
445 return d()->object == otherSequence->d()->object && d()->propertyIndex == otherSequence->d()->propertyIndex;
446 } else if (!d()->isReference && !otherSequence->d()->isReference) {
447 return this == otherSequence;
448 }
449 return false;
450 }
451
452 struct DefaultCompareFunctor
453 {
454 bool operator()(typename Container::value_type lhs, typename Container::value_type rhs)
455 {
456 return convertElementToString(lhs) < convertElementToString(rhs);
457 }
458 };
459
460 struct CompareFunctor
461 {
462 CompareFunctor(QV4::ExecutionEngine *v4, const QV4::Value &compareFn)
463 : m_v4(v4), m_compareFn(&compareFn)
464 {}
465
466 bool operator()(typename Container::value_type lhs, typename Container::value_type rhs)
467 {
468 QV4::Scope scope(m_v4);
469 ScopedFunctionObject compare(scope, m_compareFn);
470 if (!compare)
471 return m_v4->throwTypeError();
472 Value *argv = scope.alloc(nValues: 2);
473 argv[0] = convertElementToValue(m_v4, lhs);
474 argv[1] = convertElementToValue(m_v4, rhs);
475 QV4::ScopedValue result(scope, compare->call(thisObject: m_v4->globalObject, argv, argc: 2));
476 if (scope.engine->hasException)
477 return false;
478 return result->toNumber() < 0;
479 }
480
481 private:
482 QV4::ExecutionEngine *m_v4;
483 const QV4::Value *m_compareFn;
484 };
485
486 bool sort(const FunctionObject *f, const Value *, const Value *argv, int argc)
487 {
488 if (d()->isReadOnly)
489 return false;
490 if (d()->isReference) {
491 if (!d()->object)
492 return false;
493 loadReference();
494 }
495
496 if (argc == 1 && argv[0].as<FunctionObject>()) {
497 CompareFunctor cf(f->engine(), argv[0]);
498 std::sort(d()->container->begin(), d()->container->end(), cf);
499 } else {
500 DefaultCompareFunctor cf;
501 std::sort(d()->container->begin(), d()->container->end(), cf);
502 }
503
504 if (d()->isReference)
505 storeReference();
506
507 return true;
508 }
509
510 static QV4::ReturnedValue method_get_length(const FunctionObject *b, const Value *thisObject, const Value *, int)
511 {
512 QV4::Scope scope(b);
513 QV4::Scoped<QQmlSequence<Container>> This(scope, thisObject->as<QQmlSequence<Container> >());
514 if (!This)
515 THROW_TYPE_ERROR();
516
517 if (This->d()->isReference) {
518 if (!This->d()->object)
519 RETURN_RESULT(Encode(0));
520 This->loadReference();
521 }
522 RETURN_RESULT(Encode(qint32(This->d()->container->size())));
523 }
524
525 static QV4::ReturnedValue method_set_length(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc)
526 {
527 QV4::Scope scope(f);
528 QV4::Scoped<QQmlSequence<Container>> This(scope, thisObject->as<QQmlSequence<Container> >());
529 if (!This)
530 THROW_TYPE_ERROR();
531
532 quint32 newLength = argc ? argv[0].toUInt32() : 0;
533 /* Qt containers have int (rather than uint) allowable indexes. */
534 if (newLength > INT_MAX) {
535 generateWarning(v4: scope.engine, description: QLatin1String("Index out of range during length set"));
536 RETURN_UNDEFINED();
537 }
538
539 if (This->d()->isReadOnly)
540 THROW_TYPE_ERROR();
541
542 /* Read the sequence from the QObject property if we're a reference */
543 if (This->d()->isReference) {
544 if (!This->d()->object)
545 RETURN_UNDEFINED();
546 This->loadReference();
547 }
548 /* Determine whether we need to modify the sequence */
549 quint32 newCount = static_cast<quint32>(newLength);
550 quint32 count = static_cast<quint32>(This->d()->container->size());
551 if (newCount == count) {
552 RETURN_UNDEFINED();
553 } else if (newCount > count) {
554 /* according to ECMA262r3 we need to insert */
555 /* undefined values increasing length to newLength. */
556 /* We cannot, so we insert default-values instead. */
557 This->d()->container->reserve(newCount);
558 while (newCount > count++) {
559 This->d()->container->push_back(typename Container::value_type());
560 }
561 } else {
562 /* according to ECMA262r3 we need to remove */
563 /* elements until the sequence is the required length. */
564 if (newCount < count) {
565 This->d()->container->erase(This->d()->container->begin() + newCount, This->d()->container->end());
566 }
567 }
568 /* write back if required. */
569 if (This->d()->isReference) {
570 /* write back. already checked that object is non-null, so skip that check here. */
571 This->storeReference();
572 }
573 RETURN_UNDEFINED();
574 }
575
576 QVariant toVariant() const
577 { return QVariant::fromValue<Container>(*d()->container); }
578
579 static QVariant toVariant(QV4::ArrayObject *array)
580 {
581 QV4::Scope scope(array->engine());
582 Container result;
583 quint32 length = array->getLength();
584 QV4::ScopedValue v(scope);
585 for (quint32 i = 0; i < length; ++i)
586 result.push_back(convertValueToElement<typename Container::value_type>((v = array->get(idx: i))));
587 return QVariant::fromValue(result);
588 }
589
590 void* getRawContainerPtr() const
591 { return d()->container; }
592
593 void loadReference() const
594 {
595 Q_ASSERT(d()->object);
596 Q_ASSERT(d()->isReference);
597 void *a[] = { d()->container, nullptr };
598 QMetaObject::metacall(d()->object, QMetaObject::ReadProperty, d()->propertyIndex, a);
599 }
600
601 void storeReference()
602 {
603 Q_ASSERT(d()->object);
604 Q_ASSERT(d()->isReference);
605 int status = -1;
606 QQmlPropertyData::WriteFlags flags = QQmlPropertyData::DontRemoveBinding;
607 void *a[] = { d()->container, nullptr, &status, &flags };
608 QMetaObject::metacall(d()->object, QMetaObject::WriteProperty, d()->propertyIndex, a);
609 }
610
611 static QV4::ReturnedValue virtualGet(const QV4::Managed *that, PropertyKey id, const Value *receiver, bool *hasProperty)
612 {
613 if (!id.isArrayIndex())
614 return Object::virtualGet(m: that, id, receiver, hasProperty);
615 return static_cast<const QQmlSequence<Container> *>(that)->containerGetIndexed(id.asArrayIndex(), hasProperty);
616 }
617 static bool virtualPut(Managed *that, PropertyKey id, const QV4::Value &value, Value *receiver)
618 {
619 if (id.isArrayIndex())
620 return static_cast<QQmlSequence<Container> *>(that)->containerPutIndexed(id.asArrayIndex(), value);
621 return Object::virtualPut(m: that, id, value, receiver);
622 }
623 static QV4::PropertyAttributes queryIndexed(const QV4::Managed *that, uint index)
624 { return static_cast<const QQmlSequence<Container> *>(that)->containerQueryIndexed(index); }
625 static bool virtualDeleteProperty(QV4::Managed *that, PropertyKey id)
626 {
627 if (id.isArrayIndex()) {
628 uint index = id.asArrayIndex();
629 return static_cast<QQmlSequence<Container> *>(that)->containerDeleteIndexedProperty(index);
630 }
631 return Object::virtualDeleteProperty(m: that, id);
632 }
633 static bool virtualIsEqualTo(Managed *that, Managed *other)
634 { return static_cast<QQmlSequence<Container> *>(that)->containerIsEqualTo(other); }
635 static QV4::OwnPropertyKeyIterator *virtualOwnPropertyKeys(const Object *m, Value *target)
636 { return static_cast<const QQmlSequence<Container> *>(m)->containerOwnPropertyKeys(m, target);}
637
638};
639
640
641template <typename Container>
642void Heap::QQmlSequence<Container>::init(const Container &container)
643{
644 Object::init();
645 this->container = new Container(container);
646 propertyIndex = -1;
647 isReference = false;
648 isReadOnly = false;
649 object.init();
650
651 QV4::Scope scope(internalClass->engine);
652 QV4::Scoped<QV4::QQmlSequence<Container> > o(scope, this);
653 o->setArrayType(Heap::ArrayData::Custom);
654 o->init();
655}
656
657template <typename Container>
658void Heap::QQmlSequence<Container>::init(QObject *object, int propertyIndex, bool readOnly)
659{
660 Object::init();
661 this->container = new Container;
662 this->propertyIndex = propertyIndex;
663 isReference = true;
664 this->isReadOnly = readOnly;
665 this->object.init(object);
666 QV4::Scope scope(internalClass->engine);
667 QV4::Scoped<QV4::QQmlSequence<Container> > o(scope, this);
668 o->setArrayType(Heap::ArrayData::Custom);
669 o->loadReference();
670 o->init();
671}
672
673}
674
675namespace QV4 {
676
677typedef QQmlSequence<QVector<int> > QQmlIntVectorList;
678DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlIntVectorList);
679typedef QQmlSequence<QVector<qreal> > QQmlRealVectorList;
680DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlRealVectorList);
681typedef QQmlSequence<QVector<bool> > QQmlBoolVectorList;
682DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlBoolVectorList);
683typedef QQmlSequence<std::vector<int> > QQmlIntStdVectorList;
684DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlIntStdVectorList);
685typedef QQmlSequence<std::vector<qreal> > QQmlRealStdVectorList;
686DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlRealStdVectorList);
687typedef QQmlSequence<std::vector<bool> > QQmlBoolStdVectorList;
688DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlBoolStdVectorList);
689typedef QQmlSequence<QStringList> QQmlQStringList;
690DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlQStringList);
691typedef QQmlSequence<QList<QString> > QQmlStringList;
692DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlStringList);
693typedef QQmlSequence<QVector<QString> > QQmlStringVectorList;
694DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlStringVectorList);
695typedef QQmlSequence<std::vector<QString> > QQmlStringStdVectorList;
696DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlStringStdVectorList);
697typedef QQmlSequence<QList<int> > QQmlIntList;
698DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlIntList);
699typedef QQmlSequence<QList<QUrl> > QQmlUrlList;
700DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlUrlList);
701typedef QQmlSequence<QVector<QUrl> > QQmlUrlVectorList;
702DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlUrlVectorList);
703typedef QQmlSequence<std::vector<QUrl> > QQmlUrlStdVectorList;
704DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlUrlStdVectorList);
705#if QT_CONFIG(qml_itemmodel)
706typedef QQmlSequence<QModelIndexList> QQmlQModelIndexList;
707DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlQModelIndexList);
708typedef QQmlSequence<QVector<QModelIndex> > QQmlQModelIndexVectorList;
709DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlQModelIndexVectorList);
710typedef QQmlSequence<std::vector<QModelIndex> > QQmlQModelIndexStdVectorList;
711DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlQModelIndexStdVectorList);
712typedef QQmlSequence<QItemSelection> QQmlQItemSelectionRangeList;
713DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlQItemSelectionRangeList);
714#endif
715typedef QQmlSequence<QList<bool> > QQmlBoolList;
716DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlBoolList);
717typedef QQmlSequence<QList<qreal> > QQmlRealList;
718DEFINE_OBJECT_TEMPLATE_VTABLE(QQmlRealList);
719
720}
721
722#define REGISTER_QML_SEQUENCE_METATYPE(unused, unused2, SequenceType, unused3) qRegisterMetaType<SequenceType>(#SequenceType);
723static bool registerAllSequenceTypes()
724{
725 FOREACH_QML_SEQUENCE_TYPE(REGISTER_QML_SEQUENCE_METATYPE)
726 return true;
727}
728#undef REGISTER_QML_SEQUENCE_METATYPE
729
730void SequencePrototype::init()
731{
732 static const bool registered = registerAllSequenceTypes();
733 Q_UNUSED(registered);
734 defineDefaultProperty(QStringLiteral("sort"), code: method_sort, argumentCount: 1);
735 defineDefaultProperty(name: engine()->id_valueOf(), code: method_valueOf, argumentCount: 0);
736}
737
738ReturnedValue SequencePrototype::method_valueOf(const FunctionObject *f, const Value *thisObject, const Value *, int)
739{
740 return Encode(thisObject->toString(e: f->engine()));
741}
742
743ReturnedValue SequencePrototype::method_sort(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
744{
745 Scope scope(b);
746 QV4::ScopedObject o(scope, thisObject);
747 if (!o || !o->isListType())
748 THROW_TYPE_ERROR();
749
750 if (argc >= 2)
751 return o.asReturnedValue();
752
753#define CALL_SORT(SequenceElementType, SequenceElementTypeName, SequenceType, DefaultValue) \
754 if (QQml##SequenceElementTypeName##List *s = o->as<QQml##SequenceElementTypeName##List>()) { \
755 if (!s->sort(b, thisObject, argv, argc)) \
756 THROW_TYPE_ERROR(); \
757 } else
758
759 FOREACH_QML_SEQUENCE_TYPE(CALL_SORT)
760
761#undef CALL_SORT
762 {}
763 return o.asReturnedValue();
764}
765
766#define IS_SEQUENCE(unused1, unused2, SequenceType, unused3) \
767 if (sequenceTypeId == qMetaTypeId<SequenceType>()) { \
768 return true; \
769 } else
770
771bool SequencePrototype::isSequenceType(int sequenceTypeId)
772{
773 FOREACH_QML_SEQUENCE_TYPE(IS_SEQUENCE) { /* else */ return false; }
774}
775#undef IS_SEQUENCE
776
777#define NEW_REFERENCE_SEQUENCE(ElementType, ElementTypeName, SequenceType, unused) \
778 if (sequenceType == qMetaTypeId<SequenceType>()) { \
779 QV4::ScopedObject obj(scope, engine->memoryManager->allocate<QQml##ElementTypeName##List>(object, propertyIndex, readOnly)); \
780 return obj.asReturnedValue(); \
781 } else
782
783ReturnedValue SequencePrototype::newSequence(QV4::ExecutionEngine *engine, int sequenceType, QObject *object, int propertyIndex, bool readOnly, bool *succeeded)
784{
785 QV4::Scope scope(engine);
786 // This function is called when the property is a QObject Q_PROPERTY of
787 // the given sequence type. Internally we store a typed-sequence
788 // (as well as object ptr + property index for updated-read and write-back)
789 // and so access/mutate avoids variant conversion.
790 *succeeded = true;
791 FOREACH_QML_SEQUENCE_TYPE(NEW_REFERENCE_SEQUENCE) { /* else */ *succeeded = false; return QV4::Encode::undefined(); }
792}
793#undef NEW_REFERENCE_SEQUENCE
794
795#define NEW_COPY_SEQUENCE(ElementType, ElementTypeName, SequenceType, unused) \
796 if (sequenceType == qMetaTypeId<SequenceType>()) { \
797 QV4::ScopedObject obj(scope, engine->memoryManager->allocate<QQml##ElementTypeName##List>(v.value<SequenceType >())); \
798 return obj.asReturnedValue(); \
799 } else
800
801ReturnedValue SequencePrototype::fromVariant(QV4::ExecutionEngine *engine, const QVariant& v, bool *succeeded)
802{
803 QV4::Scope scope(engine);
804 // This function is called when assigning a sequence value to a normal JS var
805 // in a JS block. Internally, we store a sequence of the specified type.
806 // Access and mutation is extremely fast since it will not need to modify any
807 // QObject property.
808 int sequenceType = v.userType();
809 *succeeded = true;
810 FOREACH_QML_SEQUENCE_TYPE(NEW_COPY_SEQUENCE) { /* else */ *succeeded = false; return QV4::Encode::undefined(); }
811}
812#undef NEW_COPY_SEQUENCE
813
814#define SEQUENCE_TO_VARIANT(ElementType, ElementTypeName, SequenceType, unused) \
815 if (QQml##ElementTypeName##List *list = object->as<QQml##ElementTypeName##List>()) \
816 return list->toVariant(); \
817 else
818
819QVariant SequencePrototype::toVariant(Object *object)
820{
821 Q_ASSERT(object->isListType());
822 FOREACH_QML_SEQUENCE_TYPE(SEQUENCE_TO_VARIANT) { /* else */ return QVariant(); }
823}
824
825#undef SEQUENCE_TO_VARIANT
826#define SEQUENCE_TO_VARIANT(ElementType, ElementTypeName, SequenceType, unused) \
827 if (typeHint == qMetaTypeId<SequenceType>()) { \
828 return QQml##ElementTypeName##List::toVariant(a); \
829 } else
830
831QVariant SequencePrototype::toVariant(const QV4::Value &array, int typeHint, bool *succeeded)
832{
833 *succeeded = true;
834
835 if (!array.as<ArrayObject>()) {
836 *succeeded = false;
837 return QVariant();
838 }
839 QV4::Scope scope(array.as<Object>()->engine());
840 QV4::ScopedArrayObject a(scope, array);
841
842 FOREACH_QML_SEQUENCE_TYPE(SEQUENCE_TO_VARIANT) { /* else */ *succeeded = false; return QVariant(); }
843}
844
845#undef SEQUENCE_TO_VARIANT
846
847#define SEQUENCE_GET_RAWCONTAINERPTR(ElementType, ElementTypeName, SequenceType, unused) \
848 if (const QQml##ElementTypeName##List *list = [&]() -> const QQml##ElementTypeName##List* \
849 { if (typeHint == qMetaTypeId<SequenceType>()) return object->as<QQml##ElementTypeName##List>(); return nullptr;}()) \
850 return list->getRawContainerPtr(); \
851 else
852
853void* SequencePrototype::getRawContainerPtr(const Object *object, int typeHint)
854{
855 FOREACH_QML_SEQUENCE_TYPE(SEQUENCE_GET_RAWCONTAINERPTR) { /* else */ return nullptr; }
856}
857
858#undef SEQUENCE_GET_RAWCONTAINERPTR
859
860#define MAP_META_TYPE(ElementType, ElementTypeName, SequenceType, unused) \
861 if (object->as<QQml##ElementTypeName##List>()) { \
862 return qMetaTypeId<SequenceType>(); \
863 } else
864
865int SequencePrototype::metaTypeForSequence(const QV4::Object *object)
866{
867 FOREACH_QML_SEQUENCE_TYPE(MAP_META_TYPE)
868 /*else*/ {
869 return -1;
870 }
871}
872
873#undef MAP_META_TYPE
874
875QT_END_NAMESPACE
876

source code of qtdeclarative/src/qml/jsruntime/qv4sequenceobject.cpp