-> decltype(arr.reserve(len), void())

{

constexpr std::size_t reserve_cap = 16384;

arr.reserve((std::min)(len, reserve_cap));

{

/*!

template<typename BasicJsonType, typename LexerType>

static void set_from_lexer(BasicJsonType& v, LexerType* lexer)

{

if (lexer)

{

// Lexer has read past the current field value, so set the end position to the current position.

// The start position will be set below based on the length of the string representation

// of the value.

v.end_position = lexer->get_position();

switch (v.type())

{

case value_t::boolean:

{

// 4 and 5 are the string length of "true" and "false"

v.start_position = v.end_position - (v.m_data.m_value.boolean ? 4 : 5);

break;

}

case value_t::null:

{

// 4 is the string length of "null"

v.start_position = v.end_position - 4;

break;

}

case value_t::string:

{

// escape sequences make the token longer than the value it

// parses to, so the start position cannot be derived from

// the value; use the offset the lexer recorded instead

v.start_position = lexer->get_token_start_position();

break;

}

case value_t::discarded:

{

// an object or array the callback of

// json_sax_dom_callback_parser rejected has no position

v.end_position = std::string::npos;

v.start_position = v.end_position;

break;

}

case value_t::binary:

case value_t::number_integer:

case value_t::number_unsigned:

case value_t::number_float:

{

v.start_position = v.end_position - lexer->get_string().size();

break;

}

case value_t::object:

case value_t::array:

{

// object and array are handled in start_object() and start_array() handlers

// skip setting the values here.

break;

}

default: // LCOV_EXCL_LINE

// Handle all possible types discretely, default handler should never be reached.

JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE

}

}

}

{

public:

using number_integer_t = typename BasicJsonType::number_integer_t;

using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

using number_float_t = typename BasicJsonType::number_float_t;

using string_t = typename BasicJsonType::string_t;

using binary_t = typename BasicJsonType::binary_t;

using lexer_t = lexer<BasicJsonType, InputAdapterType>;

/*!

explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true, lexer_t* lexer_ = nullptr)

: root(r), allow_exceptions(allow_exceptions_), m_lexer_ref(lexer_)

{}

// make class move-only

json_sax_dom_parser(const json_sax_dom_parser&) = delete;

json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)

json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;

json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)

~json_sax_dom_parser() = default;

bool null()

{

handle_value(nullptr);

return true;

}

bool boolean(bool val)

{

handle_value(val);

return true;

}

bool number_integer(number_integer_t val)

{

handle_value(val);

return true;

}

bool number_unsigned(number_unsigned_t val)

{

handle_value(val);

return true;

}

bool number_float(number_float_t val, const string_t& /*unused*/)

{

handle_value(val);

return true;

}

bool string(string_t& val)

{

// json_sax documents that the passed value may be moved from,

// so hand the buffer over instead of copying it

handle_value(std::move(val));

return true;

}

bool binary(binary_t& val)

{

// json_sax documents that the passed value may be moved from,

// so hand the buffer over instead of copying it

handle_value(std::move(val));

return true;

}

bool start_object(std::size_t len)

{

ref_stack.push_back(handle_value(BasicJsonType::value_t::object));

#if JSON_DIAGNOSTIC_POSITIONS

// Manually set the start position of the object here.

// Ensure this is after the call to handle_value to ensure correct start position.

if (m_lexer_ref)

{

// Lexer has read the first character of the object, so

// subtract 1 from the position to get the correct start position.

ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;

}

#endif

if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))

{

return parse_error(0, "", out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));

}

return true;

}

bool key(string_t& val)

{

JSON_ASSERT(!ref_stack.empty());

JSON_ASSERT(ref_stack.back()->is_object());

// add null at the given key and store the reference for later

object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));

return true;

}

bool end_object()

{

JSON_ASSERT(!ref_stack.empty());

JSON_ASSERT(ref_stack.back()->is_object());

#if JSON_DIAGNOSTIC_POSITIONS

if (m_lexer_ref)

{

// Lexer's position is past the closing brace, so set that as the end position.

ref_stack.back()->end_position = m_lexer_ref->get_position();

}

#endif

ref_stack.back()->set_parents();

ref_stack.pop_back();

return true;

}

bool start_array(std::size_t len)

{

ref_stack.push_back(handle_value(BasicJsonType::value_t::array));

#if JSON_DIAGNOSTIC_POSITIONS

// Manually set the start position of the array here.

// Ensure this is after the call to handle_value to ensure correct start position.

if (m_lexer_ref)

{

ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;

}

#endif

if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))

{

return parse_error(0, "", out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));

}

if (len != detail::unknown_size())

{

reserve_array(*ref_stack.back()->m_data.m_value.array, len, priority_tag<1> {});

}

return true;

}

bool end_array()

{

JSON_ASSERT(!ref_stack.empty());

JSON_ASSERT(ref_stack.back()->is_array());

#if JSON_DIAGNOSTIC_POSITIONS

if (m_lexer_ref)

{

// Lexer's position is past the closing bracket, so set that as the end position.

ref_stack.back()->end_position = m_lexer_ref->get_position();

}

#endif

ref_stack.back()->set_parents();

ref_stack.pop_back();

return true;

}

template<class Exception>

bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,

const Exception& ex)

{

errored = true;

static_cast<void>(ex);

if (allow_exceptions)

{

JSON_THROW(ex);

}

return false;

}

constexpr bool is_errored() const

{

return errored;

}

private:

/*!

template<typename Value>

JSON_HEDLEY_RETURNS_NON_NULL

BasicJsonType* handle_value(Value&& v)

{

if (ref_stack.empty())

{

root = BasicJsonType(std::forward<Value>(v));

#if JSON_DIAGNOSTIC_POSITIONS

diagnostic_positions::set_from_lexer(root, m_lexer_ref);

#endif

return &root;

}

JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());

if (ref_stack.back()->is_array())

{

ref_stack.back()->m_data.m_value.array->emplace_back(std::forward<Value>(v));

#if JSON_DIAGNOSTIC_POSITIONS

diagnostic_positions::set_from_lexer(ref_stack.back()->m_data.m_value.array->back(), m_lexer_ref);

#endif

return &(ref_stack.back()->m_data.m_value.array->back());

}

JSON_ASSERT(ref_stack.back()->is_object());

JSON_ASSERT(object_element);

*object_element = BasicJsonType(std::forward<Value>(v));

#if JSON_DIAGNOSTIC_POSITIONS

diagnostic_positions::set_from_lexer(*object_element, m_lexer_ref);

#endif

return object_element;

}

/// the parsed JSON value

BasicJsonType& root;

/// stack to model hierarchy of values

std::vector<BasicJsonType*> ref_stack {};

/// helper to hold the reference for the next object element

BasicJsonType* object_element = nullptr;

/// whether a syntax error occurred

bool errored = false;

/// whether to throw exceptions in case of errors

const bool allow_exceptions = true;

/// the lexer reference to obtain the current position

lexer_t* m_lexer_ref = nullptr;

{

public:

using number_integer_t = typename BasicJsonType::number_integer_t;

using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

using number_float_t = typename BasicJsonType::number_float_t;

using string_t = typename BasicJsonType::string_t;

using binary_t = typename BasicJsonType::binary_t;

using parser_callback_t = typename BasicJsonType::parser_callback_t;

using parse_event_t = typename BasicJsonType::parse_event_t;

using lexer_t = lexer<BasicJsonType, InputAdapterType>;

json_sax_dom_callback_parser(BasicJsonType& r,

parser_callback_t cb,

const bool allow_exceptions_ = true,

lexer_t* lexer_ = nullptr)

: root(r), callback(std::move(cb)), allow_exceptions(allow_exceptions_), m_lexer_ref(lexer_)

{

keep_stack.push_back(true);

}

// make class move-only

json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;

json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)

json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;

json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)

~json_sax_dom_callback_parser() = default;

bool null()

{

handle_value(nullptr);

return true;

}

bool boolean(bool val)

{

handle_value(val);

return true;

}

bool number_integer(number_integer_t val)

{

handle_value(val);

return true;

}

bool number_unsigned(number_unsigned_t val)

{

handle_value(val);

return true;

}

bool number_float(number_float_t val, const string_t& /*unused*/)

{

handle_value(val);

return true;

}

bool string(string_t& val)

{

// json_sax documents that the passed value may be moved from,

// so hand the buffer over instead of copying it

handle_value(std::move(val));

return true;

}

bool binary(binary_t& val)

{

// json_sax documents that the passed value may be moved from,

// so hand the buffer over instead of copying it

handle_value(std::move(val));

return true;

}

bool start_object(std::size_t len)

{

// check callback for object start; not called inside a discarded container

const bool keep = keep_stack.back() && callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);

keep_stack.push_back(keep);

// the key this object will be stored under, read before handle_value()

// may consume it; kept in lockstep with ref_stack so end_object() can

// find the object in its parent again

container_key_stack.push_back(current_key());

auto val = handle_value(BasicJsonType::value_t::object, true);

ref_stack.push_back(val.second);

if (ref_stack.back())

{

#if JSON_DIAGNOSTIC_POSITIONS

// Manually set the start position of the object here.

// Ensure this is after the call to handle_value to ensure correct start position.

if (m_lexer_ref)

{

// Lexer has read the first character of the object, so

// subtract 1 from the position to get the correct start position.

ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;

}

#endif

// check object limit

if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))

{

return parse_error(0, "", out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));

}

}

return true;

}

bool key(string_t& val)

{

if (!keep_stack.back() || !ref_stack.back())

{

// the object is not stored: the value of this key is dropped in

// handle_value() without touching the key stacks

if (keep_stack.back())

{

BasicJsonType k = BasicJsonType(val);

static_cast<void>(callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k));

}

return true;

}

BasicJsonType k = BasicJsonType(val);

// check callback for the key

const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);

key_keep_stack.push_back(keep);

// remember the key so a rejected value can be erased without searching

// the object for it (kept in lockstep with key_keep_stack)

key_stack.push_back(val);

// add discarded value at the given key and store the reference for later

if (keep && ref_stack.back())

{

auto& obj = *ref_stack.back()->m_data.m_value.object;

const auto it = obj.find(val);

if (it != obj.end())

{

// this is a duplicate key (legal in JSON); remember its

// current value so it can be restored later if the new

// value is rejected by the callback, instead of being

// erased together with the discarded placeholder

duplicate_key_stash.emplace_back(&(it->second), it->second);

}

object_element = &(obj[val] = discarded);

}

return true;

}

bool end_object()

{

if (ref_stack.back())

{

if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))

{

// discard object, unless this slot holds a duplicate key's

// previous value pending restoration, in which case that

// value is restored instead of being discarded

if (!resolve_duplicate_key_stash(ref_stack.back(), true))

{

*ref_stack.back() = discarded;

#if JSON_DIAGNOSTIC_POSITIONS

// Set start/end positions for discarded object.

diagnostic_positions::set_from_lexer(*ref_stack.back(), m_lexer_ref);

#endif

}

}

else

{

#if JSON_DIAGNOSTIC_POSITIONS

if (m_lexer_ref)

{

// Lexer's position is past the closing brace, so set that as the end position.

ref_stack.back()->end_position = m_lexer_ref->get_position();

}

#endif

ref_stack.back()->set_parents();

// this object is finally, definitively kept; drop any

// pending duplicate-key stash entry for its slot since it

// can no longer be restored

resolve_duplicate_key_stash(ref_stack.back(), false);

}

}

JSON_ASSERT(!ref_stack.empty());

JSON_ASSERT(!keep_stack.empty());

JSON_ASSERT(!container_key_stack.empty());

ref_stack.pop_back();

keep_stack.pop_back();

const string_t object_key = std::move(container_key_stack.back());

container_key_stack.pop_back();

if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())

{

// remove discarded value

remove_discarded_value(*ref_stack.back(), object_key);

}

return true;

}

bool start_array(std::size_t len)

{

const bool keep = keep_stack.back() && callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);

keep_stack.push_back(keep);

// see start_object()

container_key_stack.push_back(current_key());

auto val = handle_value(BasicJsonType::value_t::array, true);

ref_stack.push_back(val.second);

if (ref_stack.back())

{

#if JSON_DIAGNOSTIC_POSITIONS

// Manually set the start position of the array here.

// Ensure this is after the call to handle_value to ensure correct start position.

if (m_lexer_ref)

{

// Lexer has read the first character of the array, so

// subtract 1 from the position to get the correct start position.

ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;

}

#endif

// check array limit

if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))

{

return parse_error(0, "", out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));

}

if (len != detail::unknown_size())

{

reserve_array(*ref_stack.back()->m_data.m_value.array, len, priority_tag<1> {});

}

}

return true;

}

bool end_array()

{

bool keep = true;

const bool stored = ref_stack.back() != nullptr;

if (stored)

{

keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());

if (keep)

{

#if JSON_DIAGNOSTIC_POSITIONS

if (m_lexer_ref)

{

// Lexer's position is past the closing bracket, so set that as the end position.

ref_stack.back()->end_position = m_lexer_ref->get_position();

}

#endif

ref_stack.back()->set_parents();

// this array is finally, definitively kept; drop any

// pending duplicate-key stash entry for its slot since it

// can no longer be restored

resolve_duplicate_key_stash(ref_stack.back(), false);

}

else

{

// discard array, unless this slot holds a duplicate key's

// previous value pending restoration, in which case that

// value is restored instead of being discarded

if (!resolve_duplicate_key_stash(ref_stack.back(), true))

{

*ref_stack.back() = discarded;

#if JSON_DIAGNOSTIC_POSITIONS

// Set start/end positions for discarded array.

diagnostic_positions::set_from_lexer(*ref_stack.back(), m_lexer_ref);

#endif

}

}

}

JSON_ASSERT(!ref_stack.empty());

JSON_ASSERT(!keep_stack.empty());

JSON_ASSERT(!container_key_stack.empty());

ref_stack.pop_back();

keep_stack.pop_back();

const string_t object_key = std::move(container_key_stack.back());

container_key_stack.pop_back();

// remove discarded value

if (!ref_stack.empty() && ref_stack.back())

{

if (!keep && ref_stack.back()->is_array())

{

ref_stack.back()->m_data.m_value.array->pop_back();

}

else if ((!keep || !stored) && ref_stack.back()->is_object())

{

// the array is either still stored under its key or was never

// stored, leaving the placeholder key() wrote; both show up as

// a discarded member of the parent object

remove_discarded_value(*ref_stack.back(), object_key);

}

}

return true;

}

template<class Exception>

bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,

const Exception& ex)

{

errored = true;

static_cast<void>(ex);

if (allow_exceptions)

{

JSON_THROW(ex);

}

return false;

}

constexpr bool is_errored() const

{

return errored;

}

private:

/// if there is a pending duplicate-key stash entry for this exact slot,

/// remove it from the stash; if restore_value is true, the stashed

/// previous value is moved back into the slot first (use this when the

/// new value at that slot was rejected); otherwise the stash entry is

/// simply dropped (use this when the new value was accepted, so it

/// correctly supersedes the old one and no restore should ever happen

/// for this slot again)

/// @return whether a matching stash entry was found (and processed)

bool resolve_duplicate_key_stash(BasicJsonType* slot, bool restore_value)

{

const auto it = std::find_if(duplicate_key_stash.begin(), duplicate_key_stash.end(),

[slot](const std::pair<BasicJsonType*, BasicJsonType>& entry)

{

return entry.first == slot;

});

if (it == duplicate_key_stash.end())

{

return false;

}

if (restore_value)

{

*slot = std::move(it->second);

}

duplicate_key_stash.erase(it);

return true;

}

/*!

string_t current_key() const

{

if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_object()

&& !key_stack.empty())

{

return key_stack.back();

}

return string_t{};

}

/*!

void remove_discarded_value(BasicJsonType& parent, const string_t& key)

{

if (parent.is_array())

{

auto& array = *parent.m_data.m_value.array;

if (!array.empty() && array.back().is_discarded())

{

array.pop_back();

}

}

else if (parent.is_object())

{

auto& object = *parent.m_data.m_value.object;

const auto it = object.find(key);

if (it != object.end() && it->second.is_discarded())

{

// a duplicate key's slot has a stashed previous value that

// must be restored instead of being erased

if (!resolve_duplicate_key_stash(&it->second, true))

{

object.erase(it);

}

}

}

}

/*!

template<typename Value>

std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)

{

JSON_ASSERT(!keep_stack.empty());

// do not handle this value if we know it would be added to a discarded

// container

if (!keep_stack.back())

{

return {false, nullptr};

}

// create value

auto value = BasicJsonType(std::forward<Value>(v));

#if JSON_DIAGNOSTIC_POSITIONS

diagnostic_positions::set_from_lexer(value, m_lexer_ref);

#endif

// check callback

const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);

// do not handle this value if we just learnt it shall be discarded

if (!keep)

{

// if the value was to become an object member, key() already

// stored a placeholder for it that has to be removed again

if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_object())

{

JSON_ASSERT(!key_keep_stack.empty());

JSON_ASSERT(!key_stack.empty());

const bool placeholder_stored = key_keep_stack.back();

key_keep_stack.pop_back();

const string_t key = std::move(key_stack.back());

key_stack.pop_back();

if (placeholder_stored)

{