Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: CPL - Common Portability Library
4 : * Purpose: JSon streaming writer
5 : * Author: Even Rouault, even.rouault at spatialys.com
6 : *
7 : ******************************************************************************
8 : * Copyright (c) 2019, Even Rouault <even.rouault at spatialys.com>
9 : *
10 : * SPDX-License-Identifier: MIT
11 : ****************************************************************************/
12 :
13 : /*! @cond Doxygen_Suppress */
14 :
15 : #include <cmath>
16 : #include <vector>
17 : #include <string>
18 :
19 : #include "cpl_conv.h"
20 : #include "cpl_float.h"
21 : #include "cpl_string.h"
22 : #include "cpl_json_streaming_writer.h"
23 :
24 171 : CPLJSonStreamingWriter::CPLJSonStreamingWriter(
25 171 : SerializationFuncType pfnSerializationFunc, void *pUserData)
26 171 : : m_pfnSerializationFunc(pfnSerializationFunc), m_pUserData(pUserData)
27 : {
28 171 : }
29 :
30 171 : CPLJSonStreamingWriter::~CPLJSonStreamingWriter()
31 : {
32 171 : CPLAssert(m_nLevel == 0);
33 171 : CPLAssert(m_states.empty());
34 171 : }
35 :
36 200 : void CPLJSonStreamingWriter::clear()
37 : {
38 200 : m_nLevel = 0;
39 200 : m_osStr.clear();
40 200 : m_osIndentAcc.clear();
41 200 : m_states.clear();
42 200 : m_bWaitForValue = false;
43 200 : }
44 :
45 17460 : void CPLJSonStreamingWriter::Serialize(const std::string_view &str)
46 : {
47 17460 : if (m_pfnSerializationFunc)
48 : {
49 4990 : m_osTmpForSerialize = str;
50 4990 : m_pfnSerializationFunc(m_osTmpForSerialize.c_str(), m_pUserData);
51 : }
52 : else
53 : {
54 12470 : m_osStr.append(str);
55 : }
56 17460 : }
57 :
58 13482 : void CPLJSonStreamingWriter::Serialize(const char *pszStr, size_t nLength)
59 : {
60 13482 : Serialize(std::string_view(pszStr, nLength));
61 13482 : }
62 :
63 0 : void CPLJSonStreamingWriter::SetIndentationSize(int nSpaces)
64 : {
65 0 : CPLAssert(m_nLevel == 0);
66 0 : m_osIndent.clear();
67 0 : m_osIndent.resize(nSpaces, ' ');
68 0 : }
69 :
70 1136 : void CPLJSonStreamingWriter::IncIndent()
71 : {
72 1136 : m_nLevel++;
73 1136 : if (m_bPretty)
74 1002 : m_osIndentAcc += m_osIndent;
75 1136 : }
76 :
77 1126 : void CPLJSonStreamingWriter::DecIndent()
78 : {
79 1126 : CPLAssert(m_nLevel > 0);
80 1126 : m_nLevel--;
81 1126 : if (m_bPretty)
82 992 : m_osIndentAcc.resize(m_osIndentAcc.size() - m_osIndent.size());
83 1126 : }
84 :
85 : const std::string &
86 3308 : CPLJSonStreamingWriter::FormatString(const std::string_view &str)
87 : {
88 3308 : m_osTmpForFormatString.clear();
89 3308 : m_osTmpForFormatString += '"';
90 50334 : for (char ch : str)
91 : {
92 47026 : switch (ch)
93 : {
94 858 : case '"':
95 858 : m_osTmpForFormatString += "\\\"";
96 858 : break;
97 2 : case '\\':
98 2 : m_osTmpForFormatString += "\\\\";
99 2 : break;
100 2 : case '\b':
101 2 : m_osTmpForFormatString += "\\b";
102 2 : break;
103 2 : case '\f':
104 2 : m_osTmpForFormatString += "\\f";
105 2 : break;
106 165 : case '\n':
107 165 : m_osTmpForFormatString += "\\n";
108 165 : break;
109 2 : case '\r':
110 2 : m_osTmpForFormatString += "\\r";
111 2 : break;
112 2 : case '\t':
113 2 : m_osTmpForFormatString += "\\t";
114 2 : break;
115 45993 : default:
116 45993 : if (static_cast<unsigned char>(ch) < ' ')
117 2 : m_osTmpForFormatString += CPLSPrintf("\\u%04X", ch);
118 : else
119 45991 : m_osTmpForFormatString += ch;
120 45993 : break;
121 : }
122 : }
123 3308 : m_osTmpForFormatString += '"';
124 3308 : return m_osTmpForFormatString;
125 : }
126 :
127 5186 : void CPLJSonStreamingWriter::EmitCommaIfNeeded()
128 : {
129 5186 : if (m_bWaitForValue)
130 : {
131 1975 : m_bWaitForValue = false;
132 : }
133 3211 : else if (!m_states.empty())
134 : {
135 3028 : if (!m_states.back().bFirstChild)
136 : {
137 1930 : Serialize(",", 1);
138 1930 : if (m_bPretty && !m_bNewLineEnabled)
139 131 : Serialize(" ", 1);
140 : }
141 3028 : if (m_bPretty && m_bNewLineEnabled)
142 : {
143 2638 : Serialize("\n", 1);
144 2638 : Serialize(m_osIndentAcc.c_str(), m_osIndentAcc.size());
145 : }
146 3028 : m_states.back().bFirstChild = false;
147 : }
148 5186 : }
149 :
150 700 : void CPLJSonStreamingWriter::StartObj()
151 : {
152 700 : EmitCommaIfNeeded();
153 700 : Serialize("{", 1);
154 700 : IncIndent();
155 700 : m_states.emplace_back(State(true));
156 700 : }
157 :
158 690 : void CPLJSonStreamingWriter::EndObj()
159 : {
160 690 : CPLAssert(!m_bWaitForValue);
161 690 : CPLAssert(!m_states.empty());
162 690 : CPLAssert(m_states.back().bIsObj);
163 690 : DecIndent();
164 690 : if (!m_states.back().bFirstChild)
165 : {
166 670 : if (m_bPretty && m_bNewLineEnabled)
167 : {
168 575 : Serialize("\n", 1);
169 575 : Serialize(m_osIndentAcc.c_str(), m_osIndentAcc.size());
170 : }
171 : }
172 690 : m_states.pop_back();
173 690 : Serialize("}", 1);
174 690 : }
175 :
176 436 : void CPLJSonStreamingWriter::StartArray()
177 : {
178 436 : EmitCommaIfNeeded();
179 436 : Serialize("[", 1);
180 436 : IncIndent();
181 436 : m_states.emplace_back(State(false));
182 436 : }
183 :
184 436 : void CPLJSonStreamingWriter::EndArray()
185 : {
186 436 : CPLAssert(!m_states.empty());
187 436 : CPLAssert(!m_states.back().bIsObj);
188 436 : DecIndent();
189 436 : if (!m_states.back().bFirstChild)
190 : {
191 418 : if (m_bPretty && m_bNewLineEnabled)
192 : {
193 343 : Serialize("\n", 1);
194 343 : Serialize(m_osIndentAcc.c_str(), m_osIndentAcc.size());
195 : }
196 : }
197 436 : m_states.pop_back();
198 436 : Serialize("]", 1);
199 436 : }
200 :
201 1975 : void CPLJSonStreamingWriter::AddObjKey(const std::string_view &key)
202 : {
203 1975 : CPLAssert(!m_states.empty());
204 1975 : CPLAssert(m_states.back().bIsObj);
205 1975 : CPLAssert(!m_bWaitForValue);
206 1975 : EmitCommaIfNeeded();
207 1975 : Serialize(FormatString(key));
208 1975 : if (m_bPretty)
209 1810 : Serialize(": ", 2);
210 : else
211 165 : Serialize(":", 1);
212 1975 : m_bWaitForValue = true;
213 1975 : }
214 :
215 5 : void CPLJSonStreamingWriter::Add(bool bVal)
216 : {
217 5 : EmitCommaIfNeeded();
218 5 : Serialize(bVal ? "true" : "false", bVal ? 4 : 5);
219 5 : }
220 :
221 516 : void CPLJSonStreamingWriter::Add(const char *pszStr)
222 : {
223 516 : EmitCommaIfNeeded();
224 516 : Serialize(FormatString(std::string_view(pszStr)));
225 516 : }
226 :
227 25 : void CPLJSonStreamingWriter::Add(const std::string_view &str)
228 : {
229 25 : EmitCommaIfNeeded();
230 25 : Serialize(FormatString(str));
231 25 : }
232 :
233 792 : void CPLJSonStreamingWriter::Add(const std::string &str)
234 : {
235 792 : EmitCommaIfNeeded();
236 792 : Serialize(FormatString(str));
237 792 : }
238 :
239 135 : void CPLJSonStreamingWriter::AddSerializedValue(const std::string_view &str)
240 : {
241 135 : EmitCommaIfNeeded();
242 135 : Serialize(str);
243 135 : }
244 :
245 178 : void CPLJSonStreamingWriter::Add(std::int64_t nVal)
246 : {
247 178 : EmitCommaIfNeeded();
248 178 : Serialize(CPLSPrintf(CPL_FRMT_GIB, static_cast<GIntBig>(nVal)));
249 178 : }
250 :
251 292 : void CPLJSonStreamingWriter::Add(std::uint64_t nVal)
252 : {
253 292 : EmitCommaIfNeeded();
254 292 : Serialize(CPLSPrintf(CPL_FRMT_GUIB, static_cast<GUIntBig>(nVal)));
255 292 : }
256 :
257 0 : void CPLJSonStreamingWriter::Add(GFloat16 hfVal, int nPrecision)
258 : {
259 0 : EmitCommaIfNeeded();
260 0 : if (CPLIsNan(hfVal))
261 : {
262 0 : Serialize("\"NaN\"", 5);
263 : }
264 0 : else if (CPLIsInf(hfVal))
265 : {
266 0 : Serialize(hfVal > 0 ? "\"Infinity\"" : "\"-Infinity\"",
267 0 : hfVal > 0 ? 10 : 11);
268 : }
269 : else
270 : {
271 : char szFormatting[10];
272 0 : snprintf(szFormatting, sizeof(szFormatting), "%%.%dg", nPrecision);
273 0 : Serialize(CPLSPrintf(szFormatting, double(hfVal)));
274 : }
275 0 : }
276 :
277 18 : void CPLJSonStreamingWriter::Add(float fVal, int nPrecision)
278 : {
279 18 : EmitCommaIfNeeded();
280 18 : if (std::isnan(fVal))
281 : {
282 3 : Serialize("\"NaN\"", 5);
283 : }
284 15 : else if (std::isinf(fVal))
285 : {
286 2 : Serialize(fVal > 0 ? "\"Infinity\"" : "\"-Infinity\"",
287 : fVal > 0 ? 10 : 11);
288 : }
289 : else
290 : {
291 : char szFormatting[10];
292 13 : snprintf(szFormatting, sizeof(szFormatting), "%%.%dg", nPrecision);
293 13 : Serialize(CPLSPrintf(szFormatting, static_cast<double>(fVal)));
294 : }
295 18 : }
296 :
297 87 : void CPLJSonStreamingWriter::Add(double dfVal, int nPrecision)
298 : {
299 87 : EmitCommaIfNeeded();
300 87 : if (std::isnan(dfVal))
301 : {
302 35 : Serialize("\"NaN\"", 5);
303 : }
304 52 : else if (std::isinf(dfVal))
305 : {
306 2 : Serialize(dfVal > 0 ? "\"Infinity\"" : "\"-Infinity\"");
307 : }
308 : else
309 : {
310 : char szFormatting[10];
311 50 : snprintf(szFormatting, sizeof(szFormatting), "%%.%dg", nPrecision);
312 50 : Serialize(CPLSPrintf(szFormatting, dfVal));
313 : }
314 87 : }
315 :
316 27 : void CPLJSonStreamingWriter::AddNull()
317 : {
318 27 : EmitCommaIfNeeded();
319 27 : Serialize("null", 4);
320 27 : }
321 :
322 : /*! @endcond */
|