8 #include <nlohmann/detail/exceptions.hpp>
9 #include <nlohmann/detail/macro_scope.hpp>
22 template<
typename BasicJsonType>
25 using number_integer_t =
typename BasicJsonType::number_integer_t;
26 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
27 using number_float_t =
typename BasicJsonType::number_float_t;
28 using string_t =
typename BasicJsonType::string_t;
29 using binary_t =
typename BasicJsonType::binary_t;
35 virtual bool null() = 0;
64 virtual bool number_float(number_float_t val,
const string_t& s) = 0;
72 virtual bool string(string_t& val) = 0;
80 virtual bool binary(binary_t& val) = 0;
96 virtual bool key(string_t& val) = 0;
126 const std::string& last_token,
148 template<
typename BasicJsonType>
152 using number_integer_t =
typename BasicJsonType::number_integer_t;
153 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
154 using number_float_t =
typename BasicJsonType::number_float_t;
155 using string_t =
typename BasicJsonType::string_t;
156 using binary_t =
typename BasicJsonType::binary_t;
164 : root(r), allow_exceptions(allow_exceptions_)
176 handle_value(
nullptr);
180 bool boolean(
bool val)
186 bool number_integer(number_integer_t val)
192 bool number_unsigned(number_unsigned_t val)
198 bool number_float(number_float_t val,
const string_t& )
204 bool string(string_t& val)
210 bool binary(binary_t& val)
212 handle_value(std::move(val));
216 bool start_object(std::size_t len)
218 ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
220 if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
222 JSON_THROW(out_of_range::create(408,
223 "excessive object size: " + std::to_string(len)));
229 bool key(string_t& val)
232 object_element = &(ref_stack.back()->m_value.object->operator[](val));
238 ref_stack.pop_back();
242 bool start_array(std::size_t len)
244 ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
246 if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
248 JSON_THROW(out_of_range::create(408,
249 "excessive array size: " + std::to_string(len)));
257 ref_stack.pop_back();
261 template<
class Exception>
262 bool parse_error(std::size_t ,
const std::string& ,
266 static_cast<void>(ex);
267 if (allow_exceptions)
274 constexpr
bool is_errored()
const
286 template<
typename Value>
287 JSON_HEDLEY_RETURNS_NON_NULL
288 BasicJsonType* handle_value(Value&& v)
290 if (ref_stack.empty())
292 root = BasicJsonType(std::forward<Value>(v));
296 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
298 if (ref_stack.back()->is_array())
300 ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
301 return &(ref_stack.back()->m_value.array->back());
304 JSON_ASSERT(ref_stack.back()->is_object());
305 JSON_ASSERT(object_element);
306 *object_element = BasicJsonType(std::forward<Value>(v));
307 return object_element;
313 std::vector<BasicJsonType*> ref_stack {};
315 BasicJsonType* object_element =
nullptr;
317 bool errored =
false;
319 const bool allow_exceptions =
true;
322 template<
typename BasicJsonType>
326 using number_integer_t =
typename BasicJsonType::number_integer_t;
327 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
328 using number_float_t =
typename BasicJsonType::number_float_t;
329 using string_t =
typename BasicJsonType::string_t;
330 using binary_t =
typename BasicJsonType::binary_t;
331 using parser_callback_t =
typename BasicJsonType::parser_callback_t;
332 using parse_event_t =
typename BasicJsonType::parse_event_t;
335 const parser_callback_t cb,
336 const bool allow_exceptions_ =
true)
337 : root(r), callback(cb), allow_exceptions(allow_exceptions_)
339 keep_stack.push_back(
true);
351 handle_value(
nullptr);
355 bool boolean(
bool val)
361 bool number_integer(number_integer_t val)
367 bool number_unsigned(number_unsigned_t val)
373 bool number_float(number_float_t val,
const string_t& )
379 bool string(string_t& val)
385 bool binary(binary_t& val)
387 handle_value(std::move(val));
391 bool start_object(std::size_t len)
395 keep_stack.push_back(keep);
397 auto val = handle_value(BasicJsonType::value_t::object,
true);
398 ref_stack.push_back(val.second);
401 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
403 JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len)));
409 bool key(string_t& val)
411 BasicJsonType k = BasicJsonType(val);
414 const bool keep = callback(
static_cast<int>(ref_stack.size()),
parse_event_t::key, k);
415 key_keep_stack.push_back(keep);
418 if (keep && ref_stack.back())
420 object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
431 *ref_stack.back() = discarded;
434 JSON_ASSERT(!ref_stack.empty());
435 JSON_ASSERT(!keep_stack.empty());
436 ref_stack.pop_back();
437 keep_stack.pop_back();
439 if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
442 for (
auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
444 if (it->is_discarded())
446 ref_stack.back()->erase(it);
455 bool start_array(std::size_t len)
458 keep_stack.push_back(keep);
460 auto val = handle_value(BasicJsonType::value_t::array,
true);
461 ref_stack.push_back(val.second);
464 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
466 JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len)));
476 if (ref_stack.back())
482 *ref_stack.back() = discarded;
486 JSON_ASSERT(!ref_stack.empty());
487 JSON_ASSERT(!keep_stack.empty());
488 ref_stack.pop_back();
489 keep_stack.pop_back();
492 if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
494 ref_stack.back()->m_value.array->pop_back();
500 template<
class Exception>
501 bool parse_error(std::size_t ,
const std::string& ,
505 static_cast<void>(ex);
506 if (allow_exceptions)
513 constexpr
bool is_errored()
const
534 template<
typename Value>
535 std::pair<bool, BasicJsonType*> handle_value(Value&& v,
const bool skip_callback =
false)
537 JSON_ASSERT(!keep_stack.empty());
541 if (!keep_stack.back())
543 return {
false,
nullptr};
547 auto value = BasicJsonType(std::forward<Value>(v));
555 return {
false,
nullptr};
558 if (ref_stack.empty())
560 root = std::move(
value);
561 return {
true, &root};
566 if (!ref_stack.back())
568 return {
false,
nullptr};
572 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
575 if (ref_stack.back()->is_array())
577 ref_stack.back()->m_value.array->push_back(std::move(
value));
578 return {
true, &(ref_stack.back()->m_value.array->back())};
582 JSON_ASSERT(ref_stack.back()->is_object());
584 JSON_ASSERT(!key_keep_stack.empty());
585 const bool store_element = key_keep_stack.back();
586 key_keep_stack.pop_back();
590 return {
false,
nullptr};
593 JSON_ASSERT(object_element);
594 *object_element = std::move(
value);
595 return {
true, object_element};
601 std::vector<BasicJsonType*> ref_stack {};
603 std::vector<bool> keep_stack {};
605 std::vector<bool> key_keep_stack {};
607 BasicJsonType* object_element =
nullptr;
609 bool errored =
false;
611 const parser_callback_t callback =
nullptr;
613 const bool allow_exceptions =
true;
615 BasicJsonType discarded = BasicJsonType::value_t::discarded;
618 template<
typename BasicJsonType>
622 using number_integer_t =
typename BasicJsonType::number_integer_t;
623 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
624 using number_float_t =
typename BasicJsonType::number_float_t;
625 using string_t =
typename BasicJsonType::string_t;
626 using binary_t =
typename BasicJsonType::binary_t;
638 bool number_integer(number_integer_t )
643 bool number_unsigned(number_unsigned_t )
648 bool number_float(number_float_t ,
const string_t& )
653 bool string(string_t& )
658 bool binary(binary_t& )
663 bool start_object(std::size_t = std::size_t(-1))
678 bool start_array(std::size_t = std::size_t(-1))
general exception of the basic_json class
Definition: exceptions.hpp:47
Definition: json_sax.hpp:620
Definition: json_sax.hpp:324
SAX implementation to create a JSON value from SAX events.
Definition: json_sax.hpp:150
json_sax_dom_parser(BasicJsonType &r, const bool allow_exceptions_=true)
Definition: json_sax.hpp:163
exception indicating a parse error
Definition: exceptions.hpp:119
@ value
the parser finished reading a JSON value
@ key
the parser read a key of a value in an object
@ array_end
the parser read ] and finished processing a JSON array
@ array_start
the parser read [ and started to process a JSON array
@ object_start
the parser read { and started to process a JSON object
@ object_end
the parser read } and finished processing a JSON object
namespace for Niels Lohmann
Definition: adl_serializer.hpp:9
SAX interface.
Definition: json_sax.hpp:24
virtual bool start_object(std::size_t elements)=0
the beginning of an object was read
virtual bool string(string_t &val)=0
a string was read
virtual bool end_array()=0
the end of an array was read
virtual bool key(string_t &val)=0
an object key was read
virtual bool binary(binary_t &val)=0
a binary string was read
virtual bool start_array(std::size_t elements)=0
the beginning of an array was read
virtual bool parse_error(std::size_t position, const std::string &last_token, const detail::exception &ex)=0
a parse error occurred
virtual bool boolean(bool val)=0
a boolean value was read
virtual bool end_object()=0
the end of an object was read
virtual bool number_unsigned(number_unsigned_t val)=0
an unsigned integer number was read
virtual bool number_float(number_float_t val, const string_t &s)=0
an floating-point number was read
virtual bool number_integer(number_integer_t val)=0
an integer number was read