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
トークンを格納するバッファのサイズを指定します。デフォルトは2048で512が最小の値です。 ...
拡張データを読み込みました(msgpackのみ)。
#define NLIB_DISALLOW_COPY_AND_ASSIGN(TypeName)
TypeName で指定されたクラスのコピーコンストラクタと代入演算子を禁止します。
Definition: Config.h:179
#define NLIB_SAFE_BOOL(class_name, exp)
クラス内に安全なoperator bool()を定義します。 可能であればC++11のexplicit boolを利用します。 ...
Definition: Config.h:194
#define NLIB_NONNULL_1
1番目の引数にNULLを指定することができないことを示します。
uint64_t型の整数を読み込みました。
bool strict
0以外を設定した場合、より厳密にエラーチェックを行います。デフォルトは0です。
constexpr JsonStreamParserSettings() noexcept
デフォルトコンストラクタです。各データメンバにデフォルト値を設定します。
std::pair< errno_t, size_t > ToFloat(float *v, const StringView &str) noexcept
内部でnlib_float_from_chars()を呼び出して、文字列を数値に変換します。戻り値はエラー値と読み込んだ文字...
Definition: StringView.h:414
連想配列が開始しました。
nlib_utf8_t * buf
文字列やバイナリデータが格納されます。
UniquePtrはポインタの所有権を保持し、UniquePtrがスコープから出るときにデストラクタでポインタをDELで指...
Definition: UniquePtr.h:109
std::unique_ptrに相当するクラスが定義されています。
int32_t型の整数を読み込みました。
int64_t nlib_time
1970/01/01を起点(0)としてから100ns刻みで時刻を表現する型です。64bit符号付き整数です。 ...
Definition: Platform.h:457
#define NLIB_CEXPR14
C++14のconstexprが利用可能であればconstexprが定義されます。そうでない場合は空文字列です。 ...
Definition: Config.h:108
#define NLIB_VIS_HIDDEN
関数やクラス等のシンボルをライブラリの外部に公開しません。
Definition: Platform_unix.h:88
#define NLIB_DEPRECATED
関数等がdeprecatedになったことを示します。
Definition: Config.h:109
static errno_t Parse(UniquePtr< MpObject > &obj, const void *data, size_t n) noexcept
JsonStreamParserSettingsのデフォルト設定でParse(obj, data, n, settings)を実行します。 ...
#define NLIB_VIS_PUBLIC
関数やクラス等のシンボルをライブラリの外部に公開します。
Definition: Platform_unix.h:89
static errno_t Parse(JsonStreamParser *parser, UniquePtr< MpObject > &obj, bool peek) noexcept
Parse(parser, obj, peek, NULL)を実行します。
Event event
Next()によって返されたイベント
#define NLIB_NONNULL_2
2番目の引数にNULLを指定することができないことを示します。
double型の浮動小数点数を読み込みました。
空の構造体で、関数の引数をムーブすべきことを示すために利用されます。
Definition: Config.h:265
JsonStreamParserの設定パラメータ群を格納する構造体です。
JSON又はmsgpackをプル形式でパースするためのクラスです。
ストリームからテキストを読み込むクラスです。
Definition: TextReader.h:33
Event
JsonStreamParser::Next()及びTokenで利用される型で、パーサーが読み込んだデータに対応するイベントです。...
MessagePack, JSON及びCSVを読み込むと作成されるオブジェクトです。
エラーが発生した場合、pathにエラーが発生した箇所を示す文字列が格納されます。
size_t max_map_size
連想配列の最大サイズを指定します。デフォルトは256で16が最小の値です。
size_t max_array_size
配列の最大サイズを指定します。デフォルトは8192で16が最小の値です。
入力ストリームの基底クラスです。このクラスを実体化することはできません。
Definition: InputStream.h:29
連想配列のキーを読み込みました。
uint32_t型の整数を読み込みました。
constexpr JsonStreamParser() noexcept
デフォルトコンストラクタです。
static errno_t Parse(UniquePtr< MpObject > &obj, const nlib_utf8_t *str, const JsonStreamParserSettings &settings) noexcept
Parse(obj, str, settings, NULL)を実行します。
#define NLIB_NOEXCEPT
環境に合わせてnoexcept 又は同等の定義がされます。
Definition: Config.h:105
JSON又はmsgpackが終了しました(HasNext()がfalseを返した場合のNext()の戻り値)。
#define NLIB_CEXPR
利用可能であればconstexprが定義されます。そうでない場合は空文字列です。
Definition: Config.h:107
bool token_toobig
イベントがkEventStringかつトークンが大きすぎた場合に、0以外の値が格納されます。この場合bufにはヌル文...
static errno_t Parse(UniquePtr< MpObject > &obj, const nlib_utf8_t *str, const JsonStreamParserSettings &settings, Detail *detail) noexcept
JSONをパースして、MpObjectを作成します。
std::pair< errno_t, size_t > ToDouble(double *v, const StringView &str) noexcept
内部でnlib_double_from_chars()を呼び出して、文字列を数値に変換します。戻り値はエラー値と読み込んだ文...
Definition: StringView.h:420
static errno_t Parse(JsonStreamParser *parser, UniquePtr< MpObject > &obj) noexcept
Parse(parser, obj, false)を実行します。
const Token & GetToken() const noexcept
トークンを取得します。
size_t nlib_strlen(const char *s)
内部でstrlen()を呼び出します。独自の実装が動作する場合もあります。
パーサーが取得したトークンに関するデータが格納されています。
連想配列のキー以外の文字列を読み込みました。
static errno_t Parse(UniquePtr< MpObject > &obj, const nlib_utf8_t *str) noexcept
JsonStreamParserSettingsのデフォルト設定でParse(obj, str, settingsを実行します。
#define NLIB_FINAL
利用可能であればfinalが定義されます。そうでない場合は空文字列です。
Definition: Config.h:245
int8_t ext
イベントがkEventExtだった場合に、データ型に関する8ビットの値が格納されます。
int64_t型の整数を読み込みました。
errno_t Init() noexcept
デフォルト設定でパーサーの初期化を行います。
バイナリデータを読み込みました(msgpackのみ)。
static errno_t Parse(UniquePtr< MpObject > &obj, const void *data, size_t n, const JsonStreamParserSettings &settings) noexcept
Parse(obj, data, n, settings, NULL)を実行します。
unsigned char nlib_byte_t
C++17以降でstd::byteにtypedefされる型です。
Definition: Platform.h:319
size_t max_depth
配列や連想配列の深さの最大値を指定します。デフォルトは7です。
連想配列が終了しました。
Format format
パースする際のフォーマット判定をどのように行うかを決定します。デフォルトはkFormatAdaptiveです。 ...
#define NLIB_NONNULL
全ての引数にNULLを指定することができないことを示します。
float型の浮動小数点数を読み込みました。
char nlib_utf8_t
charのtypedefです。文字列がUTF-8であることを示します。
Definition: Platform.h:308
StringView GetLine(StringView &str) noexcept
先頭から行末までの文字列を取得します。自身のオブジェクト(str)は次の行の行頭に移動します。 ...
Definition: StringView.h:456
int errno_t
intのtypedefで、戻り値としてPOSIXのエラー値を返すことを示します。
Definition: NMalloc.h:37