1// Copyright (C) 2016 The Qt Company Ltd.
2// Copyright (C) 2016 Intel Corporation.
3// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
4// Qt-Security score:critical reason:data-parser
5
6#ifndef QJSON_P_H
7#define QJSON_P_H
8
9//
10// W A R N I N G
11// -------------
12//
13// This file is not part of the Qt API. It exists purely as an
14// implementation detail. This header file may change from version to
15// version without notice, or even be removed.
16//
17// We mean it.
18//
19
20#include <qjsonvalue.h>
21#include <qcborvalue.h>
22#include <private/qcborvalue_p.h>
23
24#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED)
25# include <qjsonarray.h>
26# include <qjsonobject.h>
27#endif
28
29QT_BEGIN_NAMESPACE
30
31namespace QJsonPrivate {
32
33template<typename Element, typename ElementsIterator>
34struct ObjectIterator
35{
36 using pointer = Element *;
37
38 struct value_type;
39 struct reference {
40 reference(Element &ref) : m_key(&ref) {}
41
42 reference() = delete;
43 ~reference() = default;
44
45 reference(const reference &other) = default;
46 reference(reference &&other) = default;
47
48 reference &operator=(const value_type &value);
49 reference &operator=(const reference &other)
50 {
51 if (m_key != other.m_key) {
52 key() = other.key();
53 value() = other.value();
54 }
55 return *this;
56 }
57
58 reference &operator=(reference &&other)
59 {
60 key() = other.key();
61 value() = other.value();
62 return *this;
63 }
64
65 Element &key() { return *m_key; }
66 Element &value() { return *(m_key + 1); }
67
68 const Element &key() const { return *m_key; }
69 const Element &value() const { return *(m_key + 1); }
70
71
72 private:
73 Element *m_key;
74 };
75
76 struct value_type {
77 value_type(reference ref) : m_key(ref.key()), m_value(ref.value()) {}
78
79 Element key() const { return m_key; }
80 Element value() const { return m_value; }
81 private:
82 Element m_key;
83 Element m_value;
84 };
85
86 using difference_type = typename QList<Element>::difference_type;
87 using iterator_category = std::random_access_iterator_tag;
88
89 ObjectIterator() = default;
90 ObjectIterator(ElementsIterator it) : it(it) {}
91 ElementsIterator elementsIterator() { return it; }
92
93 ObjectIterator operator++(int) { ObjectIterator ret(it); it += 2; return ret; }
94 ObjectIterator &operator++() { it += 2; return *this; }
95 ObjectIterator &operator+=(difference_type n) { it += 2 * n; return *this; }
96
97 ObjectIterator operator--(int) { ObjectIterator ret(it); it -= 2; return ret; }
98 ObjectIterator &operator--() { it -= 2; return *this; }
99 ObjectIterator &operator-=(difference_type n) { it -= 2 * n; return *this; }
100
101 reference operator*() const { return *it; }
102 reference operator[](qsizetype n) const { return it[n * 2]; }
103
104 bool operator<(ObjectIterator other) const { return it < other.it; }
105 bool operator>(ObjectIterator other) const { return it > other.it; }
106 bool operator<=(ObjectIterator other) const { return it <= other.it; }
107 bool operator>=(ObjectIterator other) const { return it >= other.it; }
108
109 ElementsIterator it;
110};
111
112template<typename Element, typename ElementsIterator>
113inline ObjectIterator<Element, ElementsIterator> operator+(
114 ObjectIterator<Element, ElementsIterator> a,
115 typename ObjectIterator<Element, ElementsIterator>::difference_type n)
116{
117 return {a.elementsIterator() + 2 * n};
118}
119template<typename Element, typename ElementsIterator>
120inline ObjectIterator<Element, ElementsIterator> operator+(
121 qsizetype n, ObjectIterator<Element, ElementsIterator> a)
122{
123 return {a.elementsIterator() + 2 * n};
124}
125template<typename Element, typename ElementsIterator>
126inline ObjectIterator<Element, ElementsIterator> operator-(
127 ObjectIterator<Element, ElementsIterator> a,
128 typename ObjectIterator<Element, ElementsIterator>::difference_type n)
129{
130 return {a.elementsIterator() - 2 * n};
131}
132template<typename Element, typename ElementsIterator>
133inline qsizetype operator-(
134 ObjectIterator<Element, ElementsIterator> a,
135 ObjectIterator<Element, ElementsIterator> b)
136{
137 return (a.elementsIterator() - b.elementsIterator()) / 2;
138}
139template<typename Element, typename ElementsIterator>
140inline bool operator!=(
141 ObjectIterator<Element, ElementsIterator> a,
142 ObjectIterator<Element, ElementsIterator> b)
143{
144 return a.elementsIterator() != b.elementsIterator();
145}
146template<typename Element, typename ElementsIterator>
147inline bool operator==(
148 ObjectIterator<Element, ElementsIterator> a,
149 ObjectIterator<Element, ElementsIterator> b)
150{
151 return a.elementsIterator() == b.elementsIterator();
152}
153
154using KeyIterator = ObjectIterator<QtCbor::Element, QList<QtCbor::Element>::iterator>;
155using ConstKeyIterator = ObjectIterator<const QtCbor::Element, QList<QtCbor::Element>::const_iterator>;
156
157template<>
158inline KeyIterator::reference &KeyIterator::reference::operator=(const KeyIterator::value_type &value)
159{
160 *m_key = value.key();
161 *(m_key + 1) = value.value();
162 return *this;
163}
164
165inline void swap(KeyIterator::reference a, KeyIterator::reference b)
166{
167 KeyIterator::value_type t = a;
168 a = b;
169 b = t;
170}
171
172class Value
173{
174public:
175 static qint64 valueHelper(const QCborValue &v) { return v.n; }
176 static QCborContainerPrivate *container(const QCborValue &v) { return v.container; }
177 static const QCborContainerPrivate *container(QJsonValueConstRef r) noexcept
178 {
179#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED)
180 return (r.is_object ? r.o->o : r.a->a).data();
181#else
182 return r.d;
183#endif
184 }
185 static QCborContainerPrivate *container(QJsonValueRef r) noexcept
186 {
187 return const_cast<QCborContainerPrivate *>(container(r: QJsonValueConstRef(r)));
188 }
189 static qsizetype indexHelper(QJsonValueConstRef r) noexcept
190 {
191 qsizetype index = r.index;
192 if (r.is_object)
193 index = index * 2 + 1;
194 return index;
195 }
196 static const QtCbor::Element &elementHelper(QJsonValueConstRef r) noexcept
197 {
198 return container(r)->elements.at(i: indexHelper(r));
199 }
200
201 static QJsonValue fromTrustedCbor(const QCborValue &v)
202 {
203 QJsonValue result;
204 result.value = v;
205 return result;
206 }
207};
208
209class Variant
210{
211public:
212 static QJsonObject toJsonObject(const QVariantMap &map);
213 static QJsonArray toJsonArray(const QVariantList &list);
214};
215
216} // namespace QJsonPrivate
217
218QT_END_NAMESPACE
219
220#endif // QJSON_P_H
221

source code of qtbase/src/corelib/serialization/qjson_p.h