Do not load plugin from the $PWD
[mirror/qt/qtbase.git] / src / corelib / json / qjsonvalue.cpp
1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://www.qt.io/licensing/
5 **
6 ** This file is part of the QtCore module of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL21$
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 http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://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 2.1 or version 3 as published by the Free
20 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22 ** following information to ensure the GNU Lesser General Public License
23 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 **
26 ** As a special exception, The Qt Company gives you certain additional
27 ** rights. These rights are described in The Qt Company LGPL Exception
28 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 **
30 ** $QT_END_LICENSE$
31 **
32 ****************************************************************************/
33
34 #include <qjsonobject.h>
35 #include <qjsonvalue.h>
36 #include <qjsonarray.h>
37 #include <qvariant.h>
38 #include <qstringlist.h>
39 #include <qdebug.h>
40
41 #include "qjson_p.h"
42
43 QT_BEGIN_NAMESPACE
44
45 /*!
46     \class QJsonValue
47     \inmodule QtCore
48     \ingroup json
49     \ingroup shared
50     \reentrant
51     \since 5.0
52
53     \brief The QJsonValue class encapsulates a value in JSON.
54
55     A value in JSON can be one of 6 basic types:
56
57     JSON is a format to store structured data. It has 6 basic data types:
58
59     \list
60     \li bool QJsonValue::Bool
61     \li double QJsonValue::Double
62     \li string QJsonValue::String
63     \li array QJsonValue::Array
64     \li object QJsonValue::Object
65     \li null QJsonValue::Null
66     \endlist
67
68     A value can represent any of the above data types. In addition, QJsonValue has one special
69     flag to represent undefined values. This can be queried with isUndefined().
70
71     The type of the value can be queried with type() or accessors like isBool(), isString(), and so on.
72     Likewise, the value can be converted to the type stored in it using the toBool(), toString() and so on.
73
74     Values are strictly typed internally and contrary to QVariant will not attempt to do any implicit type
75     conversions. This implies that converting to a type that is not stored in the value will return a default
76     constructed return value.
77
78     \section1 QJsonValueRef
79
80     QJsonValueRef is a helper class for QJsonArray and QJsonObject.
81     When you get an object of type QJsonValueRef, you can
82     use it as if it were a reference to a QJsonValue. If you assign to it,
83     the assignment will apply to the element in the QJsonArray or QJsonObject
84     from which you got the reference.
85
86     The following methods return QJsonValueRef:
87     \list
88     \li \l {QJsonArray}::operator[](int i)
89     \li \l {QJsonObject}::operator[](const QString & key) const
90     \endlist
91
92     \sa {JSON Support in Qt}, {JSON Save Game Example}
93 */
94
95 /*!
96     Creates a QJsonValue of type \a type.
97
98     The default is to create a Null value.
99  */
100 QJsonValue::QJsonValue(Type type)
101     : ui(0), d(0), t(type)
102 {
103 }
104
105 /*!
106     \internal
107  */
108 QJsonValue::QJsonValue(QJsonPrivate::Data *data, QJsonPrivate::Base *base, const QJsonPrivate::Value &v)
109     : d(0)
110 {
111     t = (Type)(uint)v.type;
112     switch (t) {
113     case Undefined:
114     case Null:
115         dbl = 0;
116         break;
117     case Bool:
118         b = v.toBoolean();
119         break;
120     case Double:
121         dbl = v.toDouble(base);
122         break;
123     case String: {
124         QString s = v.toString(base);
125         stringData = s.data_ptr();
126         stringData->ref.ref();
127         break;
128     }
129     case Array:
130     case Object:
131         d = data;
132         this->base = v.base(base);
133         break;
134     }
135     if (d)
136         d->ref.ref();
137 }
138
139 /*!
140     Creates a value of type Bool, with value \a b.
141  */
142 QJsonValue::QJsonValue(bool b)
143     : d(0), t(Bool)
144 {
145     this->b = b;
146 }
147
148 /*!
149     Creates a value of type Double, with value \a n.
150  */
151 QJsonValue::QJsonValue(double n)
152     : d(0), t(Double)
153 {
154     this->dbl = n;
155 }
156
157 /*!
158     \overload
159     Creates a value of type Double, with value \a n.
160  */
161 QJsonValue::QJsonValue(int n)
162     : d(0), t(Double)
163 {
164     this->dbl = n;
165 }
166
167 /*!
168     \overload
169     Creates a value of type Double, with value \a n.
170     NOTE: the integer limits for IEEE 754 double precision data is 2^53 (-9007199254740992 to +9007199254740992).
171     If you pass in values outside this range expect a loss of precision to occur.
172  */
173 QJsonValue::QJsonValue(qint64 n)
174     : d(0), t(Double)
175 {
176     this->dbl = n;
177 }
178
179 /*!
180     Creates a value of type String, with value \a s.
181  */
182 QJsonValue::QJsonValue(const QString &s)
183     : d(0), t(String)
184 {
185     stringDataFromQStringHelper(s);
186 }
187
188 /*!
189     \fn QJsonValue::QJsonValue(const char *s)
190
191     Creates a value of type String with value \a s, assuming
192     UTF-8 encoding of the input.
193
194     You can disable this constructor by defining \c
195     QT_NO_CAST_FROM_ASCII when you compile your applications.
196
197     \since 5.3
198  */
199
200 void QJsonValue::stringDataFromQStringHelper(const QString &string)
201 {
202     stringData = *(QStringData **)(&string);
203     stringData->ref.ref();
204 }
205
206 /*!
207     Creates a value of type String, with value \a s.
208  */
209 QJsonValue::QJsonValue(QLatin1String s)
210     : d(0), t(String)
211 {
212     // ### FIXME: Avoid creating the temp QString below
213     QString str(s);
214     stringDataFromQStringHelper(str);
215 }
216
217 /*!
218     Creates a value of type Array, with value \a a.
219  */
220 QJsonValue::QJsonValue(const QJsonArray &a)
221     : d(a.d), t(Array)
222 {
223     base = a.a;
224     if (d)
225         d->ref.ref();
226 }
227
228 /*!
229     Creates a value of type Object, with value \a o.
230  */
231 QJsonValue::QJsonValue(const QJsonObject &o)
232     : d(o.d), t(Object)
233 {
234     base = o.o;
235     if (d)
236         d->ref.ref();
237 }
238
239
240 /*!
241     Destroys the value.
242  */
243 QJsonValue::~QJsonValue()
244 {
245     if (t == String && stringData && !stringData->ref.deref())
246         free(stringData);
247
248     if (d && !d->ref.deref())
249         delete d;
250 }
251
252 /*!
253     Creates a copy of \a other.
254  */
255 QJsonValue::QJsonValue(const QJsonValue &other)
256 {
257     t = other.t;
258     d = other.d;
259     ui = other.ui;
260     if (d)
261         d->ref.ref();
262
263     if (t == String && stringData)
264         stringData->ref.ref();
265 }
266
267 /*!
268     Assigns the value stored in \a other to this object.
269  */
270 QJsonValue &QJsonValue::operator =(const QJsonValue &other)
271 {
272     if (t == String && stringData && !stringData->ref.deref())
273         free(stringData);
274
275     t = other.t;
276     dbl = other.dbl;
277
278     if (d != other.d) {
279
280         if (d && !d->ref.deref())
281             delete d;
282         d = other.d;
283         if (d)
284             d->ref.ref();
285
286     }
287
288     if (t == String && stringData)
289         stringData->ref.ref();
290
291     return *this;
292 }
293
294 /*!
295     \fn bool QJsonValue::isNull() const
296
297     Returns \c true if the value is null.
298 */
299
300 /*!
301     \fn bool QJsonValue::isBool() const
302
303     Returns \c true if the value contains a boolean.
304
305     \sa toBool()
306  */
307
308 /*!
309     \fn bool QJsonValue::isDouble() const
310
311     Returns \c true if the value contains a double.
312
313     \sa toDouble()
314  */
315
316 /*!
317     \fn bool QJsonValue::isString() const
318
319     Returns \c true if the value contains a string.
320
321     \sa toString()
322  */
323
324 /*!
325     \fn bool QJsonValue::isArray() const
326
327     Returns \c true if the value contains an array.
328
329     \sa toArray()
330  */
331
332 /*!
333     \fn bool QJsonValue::isObject() const
334
335     Returns \c true if the value contains an object.
336
337     \sa toObject()
338  */
339
340 /*!
341     \fn bool QJsonValue::isUndefined() const
342
343     Returns \c true if the value is undefined. This can happen in certain
344     error cases as e.g. accessing a non existing key in a QJsonObject.
345  */
346
347
348 /*!
349     Converts \a variant to a QJsonValue and returns it.
350
351     The conversion will convert QVariant types as follows:
352
353     \table
354     \header
355         \li Source type
356         \li Destination type
357     \row
358         \li
359             \list
360                 \li QMetaType::Bool
361             \endlist
362         \li QJsonValue::Bool
363     \row
364         \li
365             \list
366                 \li QMetaType::Int
367                 \li QMetaType::UInt
368                 \li QMetaType::LongLong
369                 \li QMetaType::ULongLong
370                 \li QMetaType::Float
371                 \li QMetaType::Double
372             \endlist
373         \li QJsonValue::Double
374     \row
375         \li
376             \list
377                 \li QMetaType::QString
378             \endlist
379         \li QJsonValue::String
380     \row
381         \li
382             \list
383                 \li QMetaType::QStringList
384                 \li QMetaType::QVariantList
385             \endlist
386         \li QJsonValue::Array
387     \row
388         \li
389             \list
390                 \li QMetaType::QVariantMap
391                 \li QMetaType::QVariantHash
392             \endlist
393         \li QJsonValue::Object
394     \endtable
395
396     For all other QVariant types a conversion to a QString will be attempted. If the returned string
397     is empty, a Null QJsonValue will be stored, otherwise a String value using the returned QString.
398
399     \sa toVariant()
400  */
401 QJsonValue QJsonValue::fromVariant(const QVariant &variant)
402 {
403     switch (variant.userType()) {
404     case QVariant::Bool:
405         return QJsonValue(variant.toBool());
406     case QVariant::Int:
407     case QMetaType::Float:
408     case QVariant::Double:
409     case QVariant::LongLong:
410     case QVariant::ULongLong:
411     case QVariant::UInt:
412         return QJsonValue(variant.toDouble());
413     case QVariant::String:
414         return QJsonValue(variant.toString());
415     case QVariant::StringList:
416         return QJsonValue(QJsonArray::fromStringList(variant.toStringList()));
417     case QVariant::List:
418         return QJsonValue(QJsonArray::fromVariantList(variant.toList()));
419     case QVariant::Map:
420         return QJsonValue(QJsonObject::fromVariantMap(variant.toMap()));
421     case QVariant::Hash:
422         return QJsonValue(QJsonObject::fromVariantHash(variant.toHash()));
423     default:
424         break;
425     }
426     QString string = variant.toString();
427     if (string.isEmpty())
428         return QJsonValue();
429     return QJsonValue(string);
430 }
431
432 /*!
433     Converts the value to a \l {QVariant::}{QVariant()}.
434
435     The QJsonValue types will be converted as follows:
436
437     \value Null     \l {QVariant::}{QVariant()}
438     \value Bool     QMetaType::Bool
439     \value Double   QMetaType::Double
440     \value String   QString
441     \value Array    QVariantList
442     \value Object   QVariantMap
443     \value Undefined \l {QVariant::}{QVariant()}
444
445     \sa fromVariant()
446  */
447 QVariant QJsonValue::toVariant() const
448 {
449     switch (t) {
450     case Bool:
451         return b;
452     case Double:
453         return dbl;
454     case String:
455         return toString();
456     case Array:
457         return d ?
458                QJsonArray(d, static_cast<QJsonPrivate::Array *>(base)).toVariantList() :
459                QVariantList();
460     case Object:
461         return d ?
462                QJsonObject(d, static_cast<QJsonPrivate::Object *>(base)).toVariantMap() :
463                QVariantMap();
464     case Null:
465     case Undefined:
466         break;
467     }
468     return QVariant();
469 }
470
471 /*!
472     \enum QJsonValue::Type
473
474     This enum describes the type of the JSON value.
475
476     \value Null     A Null value
477     \value Bool     A boolean value. Use toBool() to convert to a bool.
478     \value Double   A double. Use toDouble() to convert to a double.
479     \value String   A string. Use toString() to convert to a QString.
480     \value Array    An array. Use toArray() to convert to a QJsonArray.
481     \value Object   An object. Use toObject() to convert to a QJsonObject.
482     \value Undefined The value is undefined. This is usually returned as an
483                     error condition, when trying to read an out of bounds value
484                     in an array or a non existent key in an object.
485 */
486
487 /*!
488     Returns the type of the value.
489
490     \sa QJsonValue::Type
491  */
492 QJsonValue::Type QJsonValue::type() const
493 {
494     return t;
495 }
496
497 /*!
498     Converts the value to a bool and returns it.
499
500     If type() is not bool, the \a defaultValue will be returned.
501  */
502 bool QJsonValue::toBool(bool defaultValue) const
503 {
504     if (t != Bool)
505         return defaultValue;
506     return b;
507 }
508
509 /*!
510     Converts the value to an int and returns it.
511
512     If type() is not Double or the value is not a whole number,
513     the \a defaultValue will be returned.
514  */
515 int QJsonValue::toInt(int defaultValue) const
516 {
517     if (t == Double && int(dbl) == dbl)
518         return dbl;
519     return defaultValue;
520 }
521
522 /*!
523     Converts the value to a double and returns it.
524
525     If type() is not Double, the \a defaultValue will be returned.
526  */
527 double QJsonValue::toDouble(double defaultValue) const
528 {
529     if (t != Double)
530         return defaultValue;
531     return dbl;
532 }
533
534 /*!
535     Converts the value to a QString and returns it.
536
537     If type() is not String, the \a defaultValue will be returned.
538  */
539 QString QJsonValue::toString(const QString &defaultValue) const
540 {
541     if (t != String)
542         return defaultValue;
543     stringData->ref.ref(); // the constructor below doesn't add a ref.
544     QStringDataPtr holder = { stringData };
545     return QString(holder);
546 }
547
548 /*!
549     Converts the value to an array and returns it.
550
551     If type() is not Array, the \a defaultValue will be returned.
552  */
553 QJsonArray QJsonValue::toArray(const QJsonArray &defaultValue) const
554 {
555     if (!d || t != Array)
556         return defaultValue;
557
558     return QJsonArray(d, static_cast<QJsonPrivate::Array *>(base));
559 }
560
561 /*!
562     \overload
563
564     Converts the value to an array and returns it.
565
566     If type() is not Array, a \l{QJsonArray::}{QJsonArray()} will be returned.
567  */
568 QJsonArray QJsonValue::toArray() const
569 {
570     return toArray(QJsonArray());
571 }
572
573 /*!
574     Converts the value to an object and returns it.
575
576     If type() is not Object, the \a defaultValue will be returned.
577  */
578 QJsonObject QJsonValue::toObject(const QJsonObject &defaultValue) const
579 {
580     if (!d || t != Object)
581         return defaultValue;
582
583     return QJsonObject(d, static_cast<QJsonPrivate::Object *>(base));
584 }
585
586 /*!
587     \overload
588
589     Converts the value to an object and returns it.
590
591     If type() is not Object, the \l {QJsonObject::}{QJsonObject()} will be returned.
592 */
593 QJsonObject QJsonValue::toObject() const
594 {
595     return toObject(QJsonObject());
596 }
597
598 /*!
599     Returns \c true if the value is equal to \a other.
600  */
601 bool QJsonValue::operator==(const QJsonValue &other) const
602 {
603     if (t != other.t)
604         return false;
605
606     switch (t) {
607     case Undefined:
608     case Null:
609         break;
610     case Bool:
611         return b == other.b;
612     case Double:
613         return dbl == other.dbl;
614     case String:
615         return toString() == other.toString();
616     case Array:
617         if (base == other.base)
618             return true;
619         if (!base)
620             return !other.base->length;
621         if (!other.base)
622             return !base->length;
623         return QJsonArray(d, static_cast<QJsonPrivate::Array *>(base))
624                 == QJsonArray(other.d, static_cast<QJsonPrivate::Array *>(other.base));
625     case Object:
626         if (base == other.base)
627             return true;
628         if (!base)
629             return !other.base->length;
630         if (!other.base)
631             return !base->length;
632         return QJsonObject(d, static_cast<QJsonPrivate::Object *>(base))
633                 == QJsonObject(other.d, static_cast<QJsonPrivate::Object *>(other.base));
634     }
635     return true;
636 }
637
638 /*!
639     Returns \c true if the value is not equal to \a other.
640  */
641 bool QJsonValue::operator!=(const QJsonValue &other) const
642 {
643     return !(*this == other);
644 }
645
646 /*!
647     \internal
648  */
649 void QJsonValue::detach()
650 {
651     if (!d)
652         return;
653
654     QJsonPrivate::Data *x = d->clone(base);
655     x->ref.ref();
656     if (!d->ref.deref())
657         delete d;
658     d = x;
659     base = static_cast<QJsonPrivate::Object *>(d->header->root());
660 }
661
662
663 /*!
664     \class QJsonValueRef
665     \inmodule QtCore
666     \reentrant
667     \brief The QJsonValueRef class is a helper class for QJsonValue.
668
669     \internal
670
671     \ingroup json
672
673     When you get an object of type QJsonValueRef, if you can assign to it,
674     the assignment will apply to the character in the string from
675     which you got the reference. That is its whole purpose in life.
676
677     You can use it exactly in the same way as a reference to a QJsonValue.
678
679     The QJsonValueRef becomes invalid once modifications are made to the
680     string: if you want to keep the character, copy it into a QJsonValue.
681
682     Most of the QJsonValue member functions also exist in QJsonValueRef.
683     However, they are not explicitly documented here.
684 */
685
686
687 QJsonValueRef &QJsonValueRef::operator =(const QJsonValue &val)
688 {
689     if (is_object)
690         o->setValueAt(index, val);
691     else
692         a->replace(index, val);
693
694     return *this;
695 }
696
697 QJsonValueRef &QJsonValueRef::operator =(const QJsonValueRef &ref)
698 {
699     if (is_object)
700         o->setValueAt(index, ref);
701     else
702         a->replace(index, ref);
703
704     return *this;
705 }
706
707 QVariant QJsonValueRef::toVariant() const
708 {
709     return toValue().toVariant();
710 }
711
712 QJsonArray QJsonValueRef::toArray() const
713 {
714     return toValue().toArray();
715 }
716
717 QJsonObject QJsonValueRef::toObject() const
718 {
719     return toValue().toObject();
720 }
721
722 QJsonValue QJsonValueRef::toValue() const
723 {
724     if (!is_object)
725         return a->at(index);
726     return o->valueAt(index);
727 }
728
729 #if !defined(QT_NO_DEBUG_STREAM) && !defined(QT_JSON_READONLY)
730 QDebug operator<<(QDebug dbg, const QJsonValue &o)
731 {
732     QDebugStateSaver saver(dbg);
733     switch (o.t) {
734     case QJsonValue::Undefined:
735         dbg << "QJsonValue(undefined)";
736         break;
737     case QJsonValue::Null:
738         dbg << "QJsonValue(null)";
739         break;
740     case QJsonValue::Bool:
741         dbg.nospace() << "QJsonValue(bool, " << o.toBool() << ")";
742         break;
743     case QJsonValue::Double:
744         dbg.nospace() << "QJsonValue(double, " << o.toDouble() << ")";
745         break;
746     case QJsonValue::String:
747         dbg.nospace() << "QJsonValue(string, " << o.toString() << ")";
748         break;
749     case QJsonValue::Array:
750         dbg.nospace() << "QJsonValue(array, ";
751         dbg << o.toArray();
752         dbg << ")";
753         break;
754     case QJsonValue::Object:
755         dbg.nospace() << "QJsonValue(object, ";
756         dbg << o.toObject();
757         dbg << ")";
758         break;
759     }
760     return dbg;
761 }
762 #endif
763
764 QT_END_NAMESPACE