nlib
JsonStreamParser.h
1 
2 /*--------------------------------------------------------------------------------*
3  Project: CrossRoad
4  Copyright (C)Nintendo All rights reserved.
5 
6  These coded instructions, statements, and computer programs contain proprietary
7  information of Nintendo and/or its licensed developers and are protected by
8  national and international copyright laws. They may not be disclosed to third
9  parties or copied or duplicated in any form, in whole or in part, without the
10  prior written consent of Nintendo.
11 
12  The content herein is highly confidential and should be handled accordingly.
13  *--------------------------------------------------------------------------------*/
14 
15 #pragma once
16 #ifndef INCLUDE_NN_NLIB_MSGPACK_JSONSTREAMPARSER_H_
17 #define INCLUDE_NN_NLIB_MSGPACK_JSONSTREAMPARSER_H_
18 
19 #include <float.h>
20 #include <utility>
21 
22 #include "nn/nlib/UniquePtr.h"
23 #include "nn/nlib/Swap.h"
25 
26 #if defined(_MSC_VER) && defined(nx_msgpack_EXPORTS)
27 #undef NLIB_VIS_PUBLIC
28 #define NLIB_VIS_PUBLIC NLIB_WINEXPORT
29 #endif
30 NLIB_NAMESPACE_BEGIN
31 class InputStream;
32 class TextReader;
33 namespace msgpack {
34 
36  enum Format {
37  kFormatAdaptive = 0,
38  kFormatJson,
39  kFormatMsgpack,
40  FORMAT_ADAPTIVE = kFormatAdaptive,
41  FORMAT_JSON = kFormatJson,
42  FORMAT_MSGPACK = kFormatMsgpack
43  };
45  size_t max_map_size;
47  size_t max_depth;
48  Format format;
49  bool strict;
51  max_array_size(8192), max_map_size(256), token_buffer_size(2048), max_depth(7),
52  format(kFormatAdaptive), strict(false) {}
53 };
54 
56  public:
57  enum Event {
58  kNone = -1,
59  kEventNull = 1,
74  kEventBinary, // msgpack only
75  kEventExt, // msgpack only
77  NONE = kNone,
78  EVENT_NULL = kEventNull,
79  EVENT_TRUE = kEventTrue,
80  EVENT_FALSE = kEventFalse,
81  EVENT_STRING = kEventString,
82  EVENT_NUMBER_INT32 = kEventNumberInt32,
83  EVENT_NUMBER_UINT32 = kEventNumberUint32,
84  EVENT_NUMBER_INT64 = kEventNumberInt64,
85  EVENT_NUMBER_UINT64 = kEventNumberUint64,
86  EVENT_NUMBER_FLOAT = kEventNumberFloat,
87  EVENT_NUMBER_DOUBLE = kEventNumberDouble,
88  EVENT_START_ARRAY = kEventStartArray,
89  EVENT_END_ARRAY = kEventEndArray,
90  EVENT_START_MAP = kEventStartMap,
91  EVENT_END_MAP = kEventEndMap,
92  EVENT_KEY_NAME = kEventKeyName,
93  EVENT_BINARY = kEventBinary,
94  EVENT_EXT = kEventExt,
95  EVENT_END_DOCUMENT = kEventEndDocument
96  };
97  enum Error {
98  kOk = 0,
99  kErrorColon,
100  kErrorComma,
101  kErrorQuote,
102  kErrorKeyTooLong,
103  kErrorNumberTooLong,
104  kErrorArrayTooBig,
105  kErrorMapTooBig,
106  kErrorCharacter,
107  kErrorNumberRange,
108  kErrorDepth,
109  kErrorToken,
110  kErrorStream,
111  ERROR_OK = kOk,
112  ERROR_COLON = kErrorColon,
113  ERROR_COMMA = kErrorComma,
114  ERROR_QUOTE = kErrorQuote,
115  ERROR_KEY_TOOLONG = kErrorKeyTooLong,
116  ERROR_NUMBER_TOOLONG = kErrorNumberTooLong,
117  ERROR_ARRAY_TOOBIG = kErrorArrayTooBig,
118  ERROR_MAP_TOOBIG = kErrorMapTooBig,
119  ERROR_CHARACTER = kErrorCharacter,
120  ERROR_NUMBER_RANGE = kErrorNumberRange,
121  ERROR_DEPTH = kErrorDepth,
122  ERROR_TOKEN = kErrorToken,
123  ERROR_STREAM = kErrorStream
124  };
125  struct Token {
128  union {
129  uint64_t u64;
130  int64_t i64;
131  size_t size;
132  double f64;
133  int32_t i32;
134  uint32_t u32;
135  float f32;
136  } number;
138  int8_t ext; // for kEventExt
139  };
140  struct Detail {
141  nlib_utf8_t path[1024];
142  };
143 
144  public:
145  static errno_t Parse(JsonStreamParser* parser, UniquePtr<MpObject>& obj, // NOLINT
146  bool peek, Detail* detail) NLIB_NOEXCEPT NLIB_NONNULL_1;
147  static errno_t Parse(JsonStreamParser* parser, UniquePtr<MpObject>& obj, // NOLINT
148  bool peek) NLIB_NOEXCEPT {
149  return Parse(parser, obj, peek, nullptr);
150  }
152  return Parse(parser, obj, false);
153  }
154  static errno_t Parse(UniquePtr<MpObject>& obj, const void* data, size_t n, // NOLINT
155  const JsonStreamParserSettings& settings,
157  static errno_t Parse(UniquePtr<MpObject>& obj, const void* data, size_t n, // NOLINT
158  const JsonStreamParserSettings& settings) NLIB_NOEXCEPT {
159  return Parse(obj, data, n, settings, nullptr);
160  }
161  static errno_t Parse(UniquePtr<MpObject>& obj, const void* data, size_t n) NLIB_NOEXCEPT { // NOLINT
162  JsonStreamParserSettings settings;
163  return Parse(obj, data, n, settings);
164  }
165  static errno_t Parse(UniquePtr<MpObject>& obj, const nlib_utf8_t* str, // NOLINT
166  const JsonStreamParserSettings& settings,
167  Detail* detail) NLIB_NOEXCEPT {
168  size_t n = nlib_strlen(str);
169  if (settings.format == JsonStreamParserSettings::kFormatJson) {
170  return Parse(obj, str, n, settings, detail);
171  } else {
172  JsonStreamParserSettings settings_ = settings;
173  settings_.format = JsonStreamParserSettings::kFormatJson;
174  return Parse(obj, str, n, settings_, detail);
175  }
176  }
177  static errno_t Parse(UniquePtr<MpObject>& obj, const nlib_utf8_t* str, // NOLINT
178  const JsonStreamParserSettings& settings) NLIB_NOEXCEPT {
179  return Parse(obj, str, settings, nullptr);
180  }
181  static errno_t Parse(UniquePtr<MpObject>& obj, const nlib_utf8_t* str) NLIB_NOEXCEPT { // NOLINT
182  JsonStreamParserSettings settings;
183  return Parse(obj, str, settings);
184  }
185 #ifdef __cpp_rvalue_references
186  static ::std::pair<errno_t, UniquePtr<MpObject> >
187  Parse(JsonStreamParser* parser, bool peek, Detail* detail) NLIB_NOEXCEPT NLIB_NONNULL_1;
188  static ::std::pair<errno_t, UniquePtr<MpObject> >
189  Parse(JsonStreamParser* parser, bool peek) NLIB_NOEXCEPT {
190  return Parse(parser, peek, nullptr);
191  }
192  static ::std::pair<errno_t, UniquePtr<MpObject> >
193  Parse(JsonStreamParser* parser) NLIB_NOEXCEPT {
194  return Parse(parser, false);
195  }
196  static ::std::pair<errno_t, UniquePtr<MpObject> >
197  Parse(const nlib_byte_t* first, const nlib_byte_t* last,
198  const JsonStreamParserSettings& settings,
199  Detail* detail) NLIB_NOEXCEPT NLIB_NONNULL_1 NLIB_NONNULL_2;
200  static ::std::pair<errno_t, UniquePtr<MpObject> >
201  Parse(const nlib_byte_t* first, const nlib_byte_t* last, Detail* detail) NLIB_NOEXCEPT {
202  JsonStreamParserSettings settings;
203  return Parse(first, last, settings, detail);
204  }
205  static ::std::pair<errno_t, UniquePtr<MpObject> >
206  Parse(const nlib_byte_t* first, const nlib_byte_t* last,
207  const JsonStreamParserSettings& settings) NLIB_NOEXCEPT {
208  return Parse(first, last, settings, nullptr);
209  }
210  static ::std::pair<errno_t, UniquePtr<MpObject> >
211  Parse(const nlib_byte_t* first, const nlib_byte_t* last) NLIB_NOEXCEPT {
212  JsonStreamParserSettings settings;
213  return Parse(first, last, settings);
214  }
215  static ::std::pair<errno_t, UniquePtr<MpObject> >
216  Parse(const nlib_utf8_t* str, const JsonStreamParserSettings& settings,
217  Detail* detail) NLIB_NOEXCEPT {
218  const nlib_byte_t* first = reinterpret_cast<const nlib_byte_t*>(str);
219  const nlib_byte_t* last = first + nlib_strlen(str);
220  if (settings.format != JsonStreamParserSettings::kFormatJson)
221  return ::std::make_pair(EINVAL, nullptr);
222  return Parse(first, last, settings, detail);
223  }
224  static ::std::pair<errno_t, UniquePtr<MpObject> >
225  Parse(const nlib_utf8_t* str, const JsonStreamParserSettings& settings) NLIB_NOEXCEPT {
226  return Parse(str, settings, nullptr);
227  }
228  static ::std::pair<errno_t, UniquePtr<MpObject> >
229  Parse(const nlib_utf8_t* str, Detail* detail) NLIB_NOEXCEPT {
230  JsonStreamParserSettings settings;
231  settings.format = JsonStreamParserSettings::kFormatJson;
232  return Parse(str, settings, detail);
233  }
234  static ::std::pair<errno_t, UniquePtr<MpObject> >
235  Parse(const nlib_utf8_t* str) NLIB_NOEXCEPT {
236  return Parse(str, nullptr);
237  }
238 #endif
239 
240  static errno_t ToInt32(const Token& token, int32_t* number) NLIB_NOEXCEPT NLIB_NONNULL;
241  static errno_t ToUint32(const Token& token, uint32_t* number) NLIB_NOEXCEPT NLIB_NONNULL;
242  static errno_t ToInt64(const Token& token, int64_t* number) NLIB_NOEXCEPT NLIB_NONNULL;
243  static errno_t ToUint64(const Token& token, uint64_t* number) NLIB_NOEXCEPT NLIB_NONNULL;
244  static errno_t ToFloat(const Token& token, float* number) NLIB_NOEXCEPT NLIB_NONNULL;
245  static errno_t ToDouble(const Token& token, double* number) NLIB_NOEXCEPT NLIB_NONNULL;
246  static errno_t ToTimestamp(const Token& token, nlib_time* t) NLIB_NOEXCEPT NLIB_NONNULL;
247 
248  static std::pair<errno_t, int32_t> ToInt32(const Token& token) NLIB_NOEXCEPT {
249  std::pair<errno_t, int32_t> rval;
250  rval.first = ToInt32(token, &rval.second);
251  return rval;
252  }
253  static std::pair<errno_t, uint32_t> ToUint32(const Token& token) NLIB_NOEXCEPT {
254  std::pair<errno_t, uint32_t> rval;
255  rval.first = ToUint32(token, &rval.second);
256  return rval;
257  }
258  static std::pair<errno_t, int64_t> ToInt64(const Token& token) NLIB_NOEXCEPT {
259  std::pair<errno_t, int64_t> rval;
260  rval.first = ToInt64(token, &rval.second);
261  return rval;
262  }
263  static std::pair<errno_t, uint64_t> ToUint64(const Token& token) NLIB_NOEXCEPT {
264  std::pair<errno_t, uint64_t> rval;
265  rval.first = ToUint64(token, &rval.second);
266  return rval;
267  }
268  static std::pair<errno_t, float> ToFloat(const Token& token) NLIB_NOEXCEPT {
269  std::pair<errno_t, float> rval;
270  rval.first = ToFloat(token, &rval.second);
271  return rval;
272  }
273  static std::pair<errno_t, double> ToDouble(const Token& token) NLIB_NOEXCEPT {
274  std::pair<errno_t, double> rval;
275  rval.first = ToDouble(token, &rval.second);
276  return rval;
277  }
278  static std::pair<errno_t, nlib_time> ToTimestamp(const Token& token) NLIB_NOEXCEPT {
279  std::pair<errno_t, nlib_time> rval;
280  rval.first = ToTimestamp(token, &rval.second);
281  return rval;
282  }
283 
285  : prv_(nullptr), error_(kOk), token_() {
286  token_.event = kNone;
287  token_.buf = nullptr;
288  token_.number.u64 = 0U;
289  token_.token_toobig = false;
290  token_.ext = 0;
291  }
293 #ifdef __cpp_rvalue_references
295  : prv_(rhs.prv_), error_(rhs.error_), token_(rhs.token_) {
296  rhs.prv_ = nullptr;
297  }
299  prv_ = rhs.prv_;
300  rhs.prv_ = nullptr;
301  error_ = rhs.error_;
302  token_ = rhs.token_;
303  return *this;
304  }
305 #endif
307  : prv_(rhs.prv_), error_(rhs.error_), token_(rhs.token_) {
308  rhs.prv_ = nullptr;
309  }
310  JsonStreamParser& assign(JsonStreamParser& rhs, move_tag) NLIB_NOEXCEPT { // NOLINT
311  prv_ = rhs.prv_;
312  rhs.prv_ = nullptr;
313  error_ = rhs.error_;
314  token_ = rhs.token_;
315  return *this;
316  }
318  using std::swap;
319  swap(prv_, rhs.prv_);
320  swap(error_, rhs.error_);
321  swap(token_, rhs.token_);
322  }
323  errno_t Init(const JsonStreamParserSettings& settings) NLIB_NOEXCEPT;
324  errno_t Init() NLIB_NOEXCEPT {
326  return this->Init(settings);
327  }
328  errno_t Open(InputStream* stream) NLIB_NOEXCEPT NLIB_NONNULL;
329  NLIB_DEPRECATED errno_t Open(TextReader* reader) NLIB_NOEXCEPT NLIB_NONNULL;
330  errno_t Close() NLIB_NOEXCEPT;
331  Error GetError() const NLIB_NOEXCEPT;
332  bool HasNext() const NLIB_NOEXCEPT;
333  Event Next() NLIB_NOEXCEPT;
334  bool Skip() NLIB_NOEXCEPT;
335  int GetLine() const NLIB_NOEXCEPT;
336  int GetColumn() const NLIB_NOEXCEPT;
337  const Token& GetToken() const NLIB_NOEXCEPT { return token_; }
338  NLIB_SAFE_BOOL(JsonStreamParser, error_ == kOk);
339 
340  private:
341  NLIB_VIS_HIDDEN Error ReadString() NLIB_NOEXCEPT;
342  NLIB_VIS_HIDDEN Error ReadNumber() NLIB_NOEXCEPT;
344  NLIB_VIS_HIDDEN Event NextMsgpack() NLIB_NOEXCEPT;
345  NLIB_VIS_HIDDEN Event NextMsgpackVal() NLIB_NOEXCEPT;
346 
347  struct JsonStreamParserPrivate;
348  JsonStreamParserPrivate* prv_;
349  Error error_;
350  Token token_;
352 };
353 
354 inline errno_t JsonStreamParser::ToInt32(const Token& token, int32_t* number) NLIB_NOEXCEPT {
355  NLIB_EINVAL_IFNULL(number);
356  switch (token.event) {
357  case kEventNumberInt32:
358  *number = token.number.i32;
359  break;
360  case kEventNumberUint32:
361  *number = static_cast<int32_t>(token.number.u32);
362  if (token.number.u32 > INT32_MAX) return ERANGE;
363  break;
364  case kEventNumberInt64:
365  *number = static_cast<int32_t>(token.number.i64);
366  if (token.number.i64 > INT32_MAX ||
367  token.number.i64 < INT32_MIN) return ERANGE;
368  break;
369  case kEventNumberUint64:
370  *number = static_cast<int32_t>(token.number.u64);
371  if (token.number.u64 > INT32_MAX) return ERANGE;
372  break;
373  case kEventNumberFloat:
374  *number = static_cast<int32_t>(token.number.f32);
375  if (token.number.f32 > static_cast<float>(INT32_MAX) ||
376  token.number.f32 < static_cast<float>(INT32_MIN))
377  return ERANGE;
378  return EDOM;
379  case kEventNumberDouble:
380  *number = static_cast<int32_t>(token.number.f64);
381  if (token.number.f64 > static_cast<double>(INT32_MAX) ||
382  token.number.f64 < static_cast<double>(INT32_MIN))
383  return ERANGE;
384  return EDOM;
385  default:
386  return EINVAL;
387  }
388  return 0;
389 }
390 
391 inline errno_t JsonStreamParser::ToUint32(const Token& token, uint32_t* number) NLIB_NOEXCEPT {
392  NLIB_EINVAL_IFNULL(number);
393  switch (token.event) {
394  case kEventNumberInt32:
395  *number = static_cast<uint32_t>(token.number.i32);
396  if (token.number.i32 < 0) return ERANGE;
397  break;
398  case kEventNumberUint32:
399  *number = token.number.u32;
400  break;
401  case kEventNumberInt64:
402  *number = static_cast<uint32_t>(token.number.i64);
403  if (token.number.i64 > UINT32_MAX ||
404  token.number.i64 < 0) return ERANGE;
405  break;
406  case kEventNumberUint64:
407  *number = static_cast<uint32_t>(token.number.u64);
408  if (token.number.u64 > UINT32_MAX) return ERANGE;
409  break;
410  case kEventNumberFloat:
411  *number = static_cast<uint32_t>(token.number.f32);
412  if (token.number.f32 > static_cast<float>(UINT32_MAX) ||
413  token.number.f32 < 0.f)
414  return ERANGE;
415  return EDOM;
416  case kEventNumberDouble:
417  *number = static_cast<uint32_t>(token.number.f64);
418  if (token.number.f64 > static_cast<double>(UINT32_MAX) ||
419  token.number.f64 < 0.0)
420  return ERANGE;
421  return EDOM;
422  default:
423  return EINVAL;
424  }
425  return 0;
426 }
427 
428 inline errno_t JsonStreamParser::ToInt64(const Token& token, int64_t* number) NLIB_NOEXCEPT {
429  NLIB_EINVAL_IFNULL(number);
430  switch (token.event) {
431  case JsonStreamParser::kEventNumberInt32:
432  *number = token.number.i32;
433  break;
434  case JsonStreamParser::kEventNumberUint32:
435  *number = static_cast<int64_t>(token.number.u32);
436  break;
437  case JsonStreamParser::kEventNumberInt64:
438  *number = token.number.i64;
439  break;
440  case JsonStreamParser::kEventNumberUint64:
441  *number = static_cast<int64_t>(token.number.u64);
442  if (token.number.u64 > INT64_MAX) return ERANGE;
443  break;
444  case kEventNumberFloat:
445  *number = static_cast<int64_t>(token.number.f32);
446  if (token.number.f32 > static_cast<float>(INT64_MAX) ||
447  token.number.f32 < static_cast<float>(INT64_MIN))
448  return ERANGE;
449  return EDOM;
450  case kEventNumberDouble:
451  *number = static_cast<int64_t>(token.number.f64);
452  if (token.number.f64 > static_cast<double>(INT64_MAX) ||
453  token.number.f64 < static_cast<double>(INT64_MIN))
454  return ERANGE;
455  return EDOM;
456  default:
457  return EINVAL;
458  }
459  return 0;
460 }
461 
462 inline errno_t JsonStreamParser::ToUint64(const Token& token, uint64_t* number) NLIB_NOEXCEPT {
463  NLIB_EINVAL_IFNULL(number);
464  switch (token.event) {
465  case kEventNumberInt32:
466  *number = static_cast<uint64_t>(token.number.i32);
467  if (token.number.i32 < 0) return ERANGE;
468  break;
469  case kEventNumberUint32:
470  *number = token.number.u32;
471  break;
472  case kEventNumberInt64:
473  *number = static_cast<uint64_t>(token.number.i64);
474  if (token.number.i64 < 0) return ERANGE;
475  break;
476  case kEventNumberUint64:
477  *number = token.number.u64;
478  break;
479  case kEventNumberFloat:
480  *number = static_cast<uint64_t>(token.number.f32);
481  if (token.number.f32 > static_cast<float>(UINT64_MAX) ||
482  token.number.f32 < 0.f)
483  return ERANGE;
484  return EDOM;
485  case kEventNumberDouble:
486  *number = static_cast<uint64_t>(token.number.f64);
487  if (token.number.f64 > static_cast<double>(UINT64_MAX) ||
488  token.number.f64 < 0.0)
489  return ERANGE;
490  return EDOM;
491  default:
492  return EINVAL;
493  }
494  return 0;
495 }
496 
497 inline errno_t JsonStreamParser::ToFloat(const Token& token, float* number) NLIB_NOEXCEPT {
498  NLIB_EINVAL_IFNULL(number);
499  switch (token.event) {
500  case kEventNumberInt32:
501  *number = static_cast<float>(token.number.i32);
502  if (token.number.i32 > 16777215 || token.number.i32 < -16777215)
503  return EDOM;
504  break;
505  case kEventNumberUint32:
506  *number = static_cast<float>(token.number.u32);
507  if (token.number.u32 > 16777215)
508  return EDOM;
509  break;
510  case kEventNumberInt64:
511  *number = static_cast<float>(token.number.i64);
512  if (token.number.i64 > 16777215 || token.number.i64 < -16777215)
513  return EDOM;
514  break;
515  case kEventNumberUint64:
516  *number = static_cast<float>(token.number.u64);
517  if (token.number.u64 > 16777215)
518  return EDOM;
519  break;
520  case kEventNumberFloat:
521  *number = token.number.f32;
522  break;
523  case kEventNumberDouble:
524  *number = static_cast<float>(token.number.f32);
525  if (token.number.f64 < FLT_MIN ||
526  token.number.f64 > FLT_MAX)
527  return ERANGE;
528  else
529  return EDOM;
530  default:
531  return EINVAL;
532  }
533  return 0;
534 }
535 
536 inline errno_t JsonStreamParser::ToDouble(const Token& token, double* number) NLIB_NOEXCEPT {
537  NLIB_EINVAL_IFNULL(number);
538  switch (token.event) {
539  case kEventNumberInt32:
540  *number = static_cast<double>(token.number.i32);
541  break;
542  case kEventNumberUint32:
543  *number = static_cast<double>(token.number.u32);
544  break;
545  case kEventNumberInt64:
546  *number = static_cast<double>(token.number.i64);
547  if (token.number.i64 > 9007199254740991LL ||
548  token.number.i64 < -9007199254740991LL)
549  return EDOM;
550  break;
551  case kEventNumberUint64:
552  *number = static_cast<double>(token.number.u64);
553  if (token.number.u64 > 9007199254740991ULL)
554  return EDOM;
555  break;
556  case kEventNumberFloat:
557  *number = token.number.f32;
558  break;
559  case kEventNumberDouble:
560  *number = token.number.f64;
561  break;
562  default:
563  return EINVAL;
564  }
565  return 0;
566 }
567 
568 } // namespace msgpack
569 NLIB_NAMESPACE_END
570 NLIB_DEFINE_STD_SWAP(::nlib_ns::msgpack::JsonStreamParser)
571 #if defined(_MSC_VER) && defined(nx_msgpack_EXPORTS)
572 #undef NLIB_VIS_PUBLIC
573 #define NLIB_VIS_PUBLIC NLIB_WINIMPORT
574 #endif
575 
576 #endif // INCLUDE_NN_NLIB_MSGPACK_JSONSTREAMPARSER_H_
size_t token_buffer_size
Specifies the size of the buffer to store tokens. The default is 2048 and the minimum value is 512...
Extended data has been read (msgpack only).
#define NLIB_DISALLOW_COPY_AND_ASSIGN(TypeName)
Prohibits use of the copy constructor and assignment operator for the class specified by TypeName...
Definition: Config.h:179
#define NLIB_SAFE_BOOL(class_name, exp)
Defines a safe operator bool function in the class. Uses the C++11 explicit bool if it is available f...
Definition: Config.h:194
#define NLIB_NONNULL_1
Indicates that you cannot specify NULL for the first argument.
A uint64_t type integer has been read.
bool strict
If a value other than 0 is set, a stricter error check is performed. The default is 0...
constexpr JsonStreamParserSettings() noexcept
Instantiates the object with default parameters (default constructor). Sets each data member to the d...
std::pair< errno_t, size_t > ToFloat(float *v, const StringView &str) noexcept
Internally calls nlib_float_from_chars() to convert a string to a numerical value. The returned value is a pair of the error value and the number of read characters.
Definition: StringView.h:414
nlib_utf8_t * buf
Stores strings or binary data.
UniquePtr owns the pointer, and when it goes out of scope, the pointer is released by the destructor ...
Definition: UniquePtr.h:109
Defines that class that is corresponding to std::unique_ptr.
An int32_t type integer has been read.
int64_t nlib_time
The type expressing the time in increments of 100 ns from the zero starting point of 1970-01-01...
Definition: Platform.h:457
#define NLIB_CEXPR14
constexpr is defined if C++14 constexpr is available for use. If not, holds an empty string...
Definition: Config.h:108
#define NLIB_VIS_HIDDEN
Symbols for functions and classes are not made available outside of the library.
Definition: Platform_unix.h:88
#define NLIB_DEPRECATED
Indicates that a function or something has been deprecated.
Definition: Config.h:109
static errno_t Parse(UniquePtr< MpObject > &obj, const void *data, size_t n) noexcept
Runs Parse(obj, data, n, settings) with the default JsonStreamParserSettings settings specified...
#define NLIB_VIS_PUBLIC
Symbols for functions and classes are made available outside of the library.
Definition: Platform_unix.h:89
static errno_t Parse(JsonStreamParser *parser, UniquePtr< MpObject > &obj, bool peek) noexcept
Runs Parse(parser, obj, peek, NULL).
Event event
The event returned by Next().
#define NLIB_NONNULL_2
Indicates that you cannot specify NULL for the second argument.
A double type floating-point number has been read.
An empty structure indicating that an argument to a function needs to be moved.
Definition: Config.h:265
Data structure used to store the JsonStreamParser settings parameters.
The class to parse JSON or msgpack in a pull manner.
The class for reading text from streams.
Definition: TextReader.h:33
Event
The type used by JsonStreamParser::Next() and Token, and the event that corresponds to the data read ...
Object created when MessagePack, JSON, or CSV is read.
When an error occurs, the string indicating the location of the error is stored in path...
size_t max_map_size
Specifies the maximum associative array size. The default is 256 and the minimum value is 16...
size_t max_array_size
Specifies the maximum array size. The default is 8192 and the minimum value is 16.
The base class for input streams. This class cannot be instantiated.
Definition: InputStream.h:29
An associative array key has been read.
A uint32_t type integer has been read.
constexpr JsonStreamParser() noexcept
Instantiates the object with default parameters (default constructor).
static errno_t Parse(UniquePtr< MpObject > &obj, const nlib_utf8_t *str, const JsonStreamParserSettings &settings) noexcept
Runs Parse(obj, str, settings, NULL).
#define NLIB_NOEXCEPT
Defines noexcept geared to the environment, or the equivalent.
Definition: Config.h:105
JSON or msgpack has finished (A return value of Next() when HasNext() returns false).
#define NLIB_CEXPR
Defines constexpr if it is available for use. If not, holds an empty string.
Definition: Config.h:107
bool token_toobig
When the event is kEventString and the token is too large, stores a non-zero value. In this case, a null string is set to buf.
static errno_t Parse(UniquePtr< MpObject > &obj, const nlib_utf8_t *str, const JsonStreamParserSettings &settings, Detail *detail) noexcept
Creates MpObject by parsing JSON.
std::pair< errno_t, size_t > ToDouble(double *v, const StringView &str) noexcept
Internally calls nlib_double_from_chars() to convert a string to a numerical value. The returned value is a pair of the error value and the number of read characters.
Definition: StringView.h:420
static errno_t Parse(JsonStreamParser *parser, UniquePtr< MpObject > &obj) noexcept
Runs Parse(parser, obj, false).
const Token & GetToken() const noexcept
Gets the token.
size_t nlib_strlen(const char *s)
Internally calls strlen(). In some cases, it may operate as an independent implementation.
Stores data on the tokens obtained by the parser.
A string other than an associative array key has been read.
static errno_t Parse(UniquePtr< MpObject > &obj, const nlib_utf8_t *str) noexcept
Runs Parse(obj, str, settings) with the default JsonStreamParserSettings settings specified...
#define NLIB_FINAL
Defines final if it is available for use. If not, holds an empty string.
Definition: Config.h:245
int8_t ext
When the event is kEventExt, stores a data type 8-bit value.
An int64_t type integer has been read.
errno_t Init() noexcept
Initializes the parser using the default settings.
Binary data has been read (msgpack only).
static errno_t Parse(UniquePtr< MpObject > &obj, const void *data, size_t n, const JsonStreamParserSettings &settings) noexcept
Runs Parse(obj, data, n, settings, NULL).
unsigned char nlib_byte_t
This type will be defined as std::byte in a typedef of C++17 or later.
Definition: Platform.h:319
size_t max_depth
Specifies the maximum value for the depth of array or associative array. The default is 7...
The associative array has finished.
Format format
Decides how formats are determined when parsing. The default is kFormatAdaptive.
#define NLIB_NONNULL
Indicates that you cannot specify NULL for all arguments.
A float type floating-point number has been read.
char nlib_utf8_t
Defines char with a typedef. Indicates that it is a UTF-8 string.
Definition: Platform.h:308
StringView GetLine(StringView &str) noexcept
Obtains the strings from the start to the end of the line. Its own object ( str) moves to the beginni...
Definition: StringView.h:456
int errno_t
Indicates with an int-type typedef that a POSIX error value is returned as the return value...
Definition: NMalloc.h:37