#include <json.hpp>

Public Types
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	parser_callback_t = typename BasicJsonType::parser_callback_t

using	parse_event_t = typename BasicJsonType::parse_event_t

Public Member Functions
	json_sax_dom_callback_parser (BasicJsonType &r, const parser_callback_t cb, const bool allow_exceptions_=true)

	json_sax_dom_callback_parser (const json_sax_dom_callback_parser &)=delete

	json_sax_dom_callback_parser (json_sax_dom_callback_parser &&)=default

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

	~json_sax_dom_callback_parser ()=default

bool	null ()

bool	boolean (bool val)

bool	number_integer (number_integer_t val)

bool	number_unsigned (number_unsigned_t val)

bool	number_float (number_float_t val, const string_t &)

bool	string (string_t &val)

bool	start_object (std::size_t len)

bool	key (string_t &val)

bool	end_object ()

bool	start_array (std::size_t len)

bool	end_array ()

bool	parse_error (std::size_t, const std::string &, const detail::exception &ex)

constexpr bool	is_errored () const

Private Member Functions
template<typename Value >
std::pair< bool, BasicJsonType * >	handle_value (Value &&v, const bool skip_callback=false)

Private Attributes
BasicJsonType &	root
	the parsed JSON value More...

std::vector< BasicJsonType * >	ref_stack {}
	stack to model hierarchy of values More...

std::vector< bool >	keep_stack {}
	stack to manage which values to keep More...

std::vector< bool >	key_keep_stack {}
	stack to manage which object keys to keep More...

BasicJsonType *	object_element = nullptr
	helper to hold the reference for the next object element More...

bool	errored = false
	whether a syntax error occurred More...

const parser_callback_t	callback = nullptr
	callback function More...

const bool	allow_exceptions = true
	whether to throw exceptions in case of errors More...

BasicJsonType	discarded = BasicJsonType::value_t::discarded
	a discarded value for the callback More...

Detailed Description

template<typename BasicJsonType>
class nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >

Definition at line 4636 of file json.hpp.

Member Typedef Documentation

template<typename BasicJsonType>

using nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::number_float_t = typename BasicJsonType::number_float_t

Definition at line 4641 of file json.hpp.

template<typename BasicJsonType>

using nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::number_integer_t = typename BasicJsonType::number_integer_t

Definition at line 4639 of file json.hpp.

template<typename BasicJsonType>

using nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::number_unsigned_t = typename BasicJsonType::number_unsigned_t

Definition at line 4640 of file json.hpp.

template<typename BasicJsonType>

using nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::parse_event_t = typename BasicJsonType::parse_event_t

Definition at line 4644 of file json.hpp.

template<typename BasicJsonType>

using nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::parser_callback_t = typename BasicJsonType::parser_callback_t

Definition at line 4643 of file json.hpp.

template<typename BasicJsonType>

using nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::string_t = typename BasicJsonType::string_t

Definition at line 4642 of file json.hpp.

Constructor & Destructor Documentation

template<typename BasicJsonType>

nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::json_sax_dom_callback_parser	(	BasicJsonType &	r,
		const parser_callback_t	cb,
		const bool	allow_exceptions_ = `true`
	)

inline

Definition at line 4646 of file json.hpp.

         : root(r), callback(cb), allow_exceptions(allow_exceptions_)
     {
         keep_stack.push_back(true);
     }

template<typename BasicJsonType>

nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::json_sax_dom_callback_parser ( const json_sax_dom_callback_parser< BasicJsonType > & )

delete

template<typename BasicJsonType>

nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::json_sax_dom_callback_parser ( json_sax_dom_callback_parser< BasicJsonType > && )

default

template<typename BasicJsonType>

nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::~json_sax_dom_callback_parser ( )

default

Member Function Documentation

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::boolean ( bool val )

inline

Definition at line 4667 of file json.hpp.

     {
         handle_value(val);
         return true;
     }

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::end_array ( )

inline

Definition at line 4778 of file json.hpp.

     {
         bool keep = true;
 
         if (ref_stack.back())
         {
             keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
             if (not keep)
             {
                 // discard array
                 *ref_stack.back() = discarded;
             }
         }
 
         assert(not ref_stack.empty());
         assert(not keep_stack.empty());
         ref_stack.pop_back();
         keep_stack.pop_back();
 
         // remove discarded value
         if (not keep and not ref_stack.empty() and ref_stack.back()->is_array())
         {
             ref_stack.back()->m_value.array->pop_back();
         }
 
         return true;
     }

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::end_object ( )

inline

Definition at line 4732 of file json.hpp.

     {
         if (ref_stack.back() and not callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
         {
             // discard object
             *ref_stack.back() = discarded;
         }
 
         assert(not ref_stack.empty());
         assert(not keep_stack.empty());
         ref_stack.pop_back();
         keep_stack.pop_back();
 
         if (not ref_stack.empty() and ref_stack.back() and ref_stack.back()->is_object())
         {
             // remove discarded value
             for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
             {
                 if (it->is_discarded())
                 {
                     ref_stack.back()->erase(it);
                     break;
                 }
             }
         }
 
         return true;
     }

template<typename BasicJsonType>

template<typename Value >

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

inlineprivate

Parameters

[in]	v	value to add to the JSON value we build during parsing
[in]	skip_callback	whether we should skip calling the callback function; this is required after start_array() and start_object() SAX events, because otherwise we would call the callback function with an empty array or object, respectively.

Invariant: If the ref stack is empty, then the passed value will be the new root.; If the ref stack contains a value, then it is an array or an object to which we can add elements

Returns: pair of boolean (whether value should be kept) and pointer (to the passed value in the ref_stack hierarchy; nullptr if not kept)

Definition at line 4856 of file json.hpp.

     {
         assert(not keep_stack.empty());
 
         // do not handle this value if we know it would be added to a discarded
         // container
         if (not keep_stack.back())
         {
             return {false, nullptr};
         }
 
         // create value
         auto value = BasicJsonType(std::forward<Value>(v));
 
         // check callback
         const bool keep = skip_callback or 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 (not keep)
         {
             return {false, nullptr};
         }
 
         if (ref_stack.empty())
         {
             root = std::move(value);
             return {true, &root};
         }
 
         // skip this value if we already decided to skip the parent
         // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
         if (not ref_stack.back())
         {
             return {false, nullptr};
         }
 
         // we now only expect arrays and objects
         assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
 
         // array
         if (ref_stack.back()->is_array())
         {
             ref_stack.back()->m_value.array->push_back(std::move(value));
             return {true, &(ref_stack.back()->m_value.array->back())};
         }
 
         // object
         assert(ref_stack.back()->is_object());
         // check if we should store an element for the current key
         assert(not key_keep_stack.empty());
         const bool store_element = key_keep_stack.back();
         key_keep_stack.pop_back();
 
         if (not store_element)
         {
             return {false, nullptr};
         }
 
         assert(object_element);
         *object_element = std::move(value);
         return {true, object_element};
     }

template<typename BasicJsonType>

constexpr bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::is_errored ( ) const

inline

Definition at line 4834 of file json.hpp.

     {
         return errored;
     }

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::key ( string_t & val )

inline

Definition at line 4715 of file json.hpp.

     {
         BasicJsonType k = BasicJsonType(val);
 
         // check callback for key
         const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
         key_keep_stack.push_back(keep);
 
         // add discarded value at given key and store the reference for later
         if (keep and ref_stack.back())
         {
             object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
         }
 
         return true;
     }

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::null ( )

inline

Definition at line 4661 of file json.hpp.

     {
         handle_value(nullptr);
         return true;
     }

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::number_float	(	number_float_t	val,
		const string_t &
	)

inline

Definition at line 4685 of file json.hpp.

     {
         handle_value(val);
         return true;
     }

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::number_integer ( number_integer_t val )

inline

Definition at line 4673 of file json.hpp.

     {
         handle_value(val);
         return true;
     }

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::number_unsigned ( number_unsigned_t val )

inline

Definition at line 4679 of file json.hpp.

     {
         handle_value(val);
         return true;
     }

template<typename BasicJsonType>

json_sax_dom_callback_parser& nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::operator= ( const json_sax_dom_callback_parser< BasicJsonType > & )

delete

template<typename BasicJsonType>

json_sax_dom_callback_parser& nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::operator= ( json_sax_dom_callback_parser< BasicJsonType > && )

default

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::parse_error	(	std::size_t	,
		const std::string &	,
		const detail::exception &	ex
	)

inline

Definition at line 4806 of file json.hpp.

     {
         errored = true;
         if (allow_exceptions)
         {
             // determine the proper exception type from the id
             switch ((ex.id / 100) % 100)
             {
                 case 1:
                     JSON_THROW(*static_cast<const detail::parse_error*>(&ex));
                 case 4:
                     JSON_THROW(*static_cast<const detail::out_of_range*>(&ex));
                 // LCOV_EXCL_START
                 case 2:
                     JSON_THROW(*static_cast<const detail::invalid_iterator*>(&ex));
                 case 3:
                     JSON_THROW(*static_cast<const detail::type_error*>(&ex));
                 case 5:
                     JSON_THROW(*static_cast<const detail::other_error*>(&ex));
                 default:
                     assert(false);
                     // LCOV_EXCL_STOP
             }
         }
         return false;
     }

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::start_array ( std::size_t len )

inline

Definition at line 4761 of file json.hpp.

     {
         const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
         keep_stack.push_back(keep);
 
         auto val = handle_value(BasicJsonType::value_t::array, true);
         ref_stack.push_back(val.second);
 
         // check array limit
         if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
         {
             JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
         }
 
         return true;
     }

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::start_object ( std::size_t len )

inline

Definition at line 4697 of file json.hpp.

     {
         // check callback for object start
         const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
         keep_stack.push_back(keep);
 
         auto val = handle_value(BasicJsonType::value_t::object, true);
         ref_stack.push_back(val.second);
 
         // check object limit
         if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
         {
             JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
         }
 
         return true;
     }

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::string ( string_t & val )

inline

Definition at line 4691 of file json.hpp.

     {
         handle_value(val);
         return true;
     }

Member Data Documentation

template<typename BasicJsonType>

const bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::allow_exceptions = true

private

whether to throw exceptions in case of errors

Definition at line 4934 of file json.hpp.

template<typename BasicJsonType>

const parser_callback_t nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::callback = nullptr

private

callback function

Definition at line 4932 of file json.hpp.

template<typename BasicJsonType>

BasicJsonType nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::discarded = BasicJsonType::value_t::discarded

private

a discarded value for the callback

Definition at line 4936 of file json.hpp.

template<typename BasicJsonType>

bool nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::errored = false

private

whether a syntax error occurred

Definition at line 4930 of file json.hpp.

template<typename BasicJsonType>

std::vector<bool> nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::keep_stack {}

private

stack to manage which values to keep

Definition at line 4924 of file json.hpp.

template<typename BasicJsonType>

std::vector<bool> nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::key_keep_stack {}

private

stack to manage which object keys to keep

Definition at line 4926 of file json.hpp.

template<typename BasicJsonType>

BasicJsonType* nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::object_element = nullptr

private

helper to hold the reference for the next object element

Definition at line 4928 of file json.hpp.

template<typename BasicJsonType>

std::vector<BasicJsonType*> nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::ref_stack {}

private

stack to model hierarchy of values

Definition at line 4922 of file json.hpp.

template<typename BasicJsonType>

BasicJsonType& nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >::root

private

the parsed JSON value

Definition at line 4920 of file json.hpp.

The documentation for this class was generated from the following file:

json.hpp

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

template<typename BasicJsonType> class nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename BasicJsonType>
class nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >