#include <algorithm>
#include <cassert>
#include <ciso646>
#include <cstddef>
#include <functional>
#include <initializer_list>
#include <iosfwd>
#include <iterator>
#include <numeric>
#include <string>
#include <utility>
#include <cstdint>
#include <map>
#include <memory>
#include <vector>
#include <type_traits>
#include <limits>
#include <exception>
#include <stdexcept>
#include <array>
#include <forward_list>
#include <tuple>
#include <unordered_map>
#include <valarray>
#include <cstring>
#include <istream>
#include <clocale>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <ios>
#include <ostream>

Include dependency graph for json.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	nlohmann::adl_serializer< typename, typename >
	default JSONSerializer template argument More...

class	nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >
	a class to store JSON values More...

class	nlohmann::json_pointer< BasicJsonType >
	JSON Pointer. More...

struct	nlohmann::detail::index_sequence< Ints >

struct	nlohmann::detail::merge_and_renumber< Sequence1, Sequence2 >

struct	nlohmann::detail::merge_and_renumber< index_sequence< I1... >, index_sequence< I2... > >

struct	nlohmann::detail::make_index_sequence< N >

struct	nlohmann::detail::make_index_sequence< 0 >

struct	nlohmann::detail::make_index_sequence< 1 >

struct	nlohmann::detail::priority_tag< N >

struct	nlohmann::detail::priority_tag< 0 >

struct	nlohmann::detail::static_const< T >

struct	nlohmann::detail::make_void< Ts >

struct	nlohmann::detail::nonesuch

struct	nlohmann::detail::detector< Default, AlwaysVoid, Op, Args >

struct	nlohmann::detail::detector< Default, void_t< Op< Args... > >, Op, Args... >

struct	nlohmann::detail::is_basic_json< typename >

struct	nlohmann::detail::is_basic_json< basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer > >

struct	nlohmann::detail::has_from_json< BasicJsonType, T, typename >

struct	nlohmann::detail::has_from_json< BasicJsonType, T, enable_if_t< not is_basic_json< T >::value > >

struct	nlohmann::detail::has_non_default_from_json< BasicJsonType, T, typename >

struct	nlohmann::detail::has_non_default_from_json< BasicJsonType, T, enable_if_t< not is_basic_json< T >::value > >

struct	nlohmann::detail::has_to_json< BasicJsonType, T, typename >

struct	nlohmann::detail::has_to_json< BasicJsonType, T, enable_if_t< not is_basic_json< T >::value > >

struct	nlohmann::detail::is_iterator_traits< T, typename >

struct	nlohmann::detail::is_iterator_traits< std::iterator_traits< T > >

struct	nlohmann::detail::is_complete_type< T, typename >

struct	nlohmann::detail::is_complete_type< T, decltype(void(sizeof(T)))>

struct	nlohmann::detail::is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType, typename >

struct	nlohmann::detail::is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType, enable_if_t< is_detected< mapped_type_t, CompatibleObjectType >::value andis_detected< key_type_t, CompatibleObjectType >::value > >

struct	nlohmann::detail::is_compatible_object_type< BasicJsonType, CompatibleObjectType >

struct	nlohmann::detail::is_constructible_object_type_impl< BasicJsonType, ConstructibleObjectType, typename >

struct	nlohmann::detail::is_constructible_object_type_impl< BasicJsonType, ConstructibleObjectType, enable_if_t< is_detected< mapped_type_t, ConstructibleObjectType >::value andis_detected< key_type_t, ConstructibleObjectType >::value > >

struct	nlohmann::detail::is_constructible_object_type< BasicJsonType, ConstructibleObjectType >

struct	nlohmann::detail::is_compatible_string_type_impl< BasicJsonType, CompatibleStringType, typename >

struct	nlohmann::detail::is_compatible_string_type_impl< BasicJsonType, CompatibleStringType, enable_if_t< is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, CompatibleStringType >::value > >

struct	nlohmann::detail::is_compatible_string_type< BasicJsonType, ConstructibleStringType >

struct	nlohmann::detail::is_constructible_string_type_impl< BasicJsonType, ConstructibleStringType, typename >

struct	nlohmann::detail::is_constructible_string_type_impl< BasicJsonType, ConstructibleStringType, enable_if_t< is_detected_exact< typename BasicJsonType::string_t::value_type, value_type_t, ConstructibleStringType >::value > >

struct	nlohmann::detail::is_constructible_string_type< BasicJsonType, ConstructibleStringType >

struct	nlohmann::detail::is_compatible_array_type_impl< BasicJsonType, CompatibleArrayType, typename >

struct	nlohmann::detail::is_compatible_array_type_impl< BasicJsonType, CompatibleArrayType, enable_if_t< is_detected< value_type_t, CompatibleArrayType >::value andis_detected< iterator_t, CompatibleArrayType >::value andnot is_iterator_traits< std::iterator_traits< CompatibleArrayType > >::value > >

struct	nlohmann::detail::is_compatible_array_type< BasicJsonType, CompatibleArrayType >

struct	nlohmann::detail::is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, typename >

struct	nlohmann::detail::is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value > >

struct	nlohmann::detail::is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< not std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value andis_detected< value_type_t, ConstructibleArrayType >::value andis_detected< iterator_t, ConstructibleArrayType >::value andis_complete_type< detected_t< value_type_t, ConstructibleArrayType > >::value > >

struct	nlohmann::detail::is_constructible_array_type< BasicJsonType, ConstructibleArrayType >

struct	nlohmann::detail::is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, typename >

struct	nlohmann::detail::is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, enable_if_t< std::is_integral< RealIntegerType >::value andstd::is_integral< CompatibleNumberIntegerType >::value andnot std::is_same< bool, CompatibleNumberIntegerType >::value > >

struct	nlohmann::detail::is_compatible_integer_type< RealIntegerType, CompatibleNumberIntegerType >

struct	nlohmann::detail::is_compatible_type_impl< BasicJsonType, CompatibleType, typename >

struct	nlohmann::detail::is_compatible_type_impl< BasicJsonType, CompatibleType, enable_if_t< is_complete_type< CompatibleType >::value > >

struct	nlohmann::detail::is_compatible_type< BasicJsonType, CompatibleType >

struct	nlohmann::detail::position_t
	struct to capture the start position of the current token More...

class	nlohmann::detail::exception
	general exception of the basic_json class More...

class	nlohmann::detail::parse_error
	exception indicating a parse error More...

class	nlohmann::detail::invalid_iterator
	exception indicating errors with iterators More...

class	nlohmann::detail::type_error
	exception indicating executing a member function with a wrong type More...

class	nlohmann::detail::out_of_range
	exception indicating access out of the defined range More...

class	nlohmann::detail::other_error
	exception indicating other library errors More...

struct	nlohmann::detail::from_json_fn

class	nlohmann::detail::iteration_proxy< IteratorType >
	proxy class for the items() function More...

class	nlohmann::detail::iteration_proxy< IteratorType >::iteration_proxy_internal
	helper class for iteration More...

struct	nlohmann::detail::external_constructor< value_t >

struct	nlohmann::detail::external_constructor< value_t::boolean >

struct	nlohmann::detail::external_constructor< value_t::string >

struct	nlohmann::detail::external_constructor< value_t::number_float >

struct	nlohmann::detail::external_constructor< value_t::number_unsigned >

struct	nlohmann::detail::external_constructor< value_t::number_integer >

struct	nlohmann::detail::external_constructor< value_t::array >

struct	nlohmann::detail::external_constructor< value_t::object >

struct	nlohmann::detail::to_json_fn

struct	nlohmann::detail::input_adapter_protocol
	abstract input adapter interface More...

class	nlohmann::detail::input_stream_adapter

class	nlohmann::detail::input_buffer_adapter
	input adapter for buffer input More...

struct	nlohmann::detail::wide_string_input_helper< WideStringType, T >

struct	nlohmann::detail::wide_string_input_helper< WideStringType, 2 >

class	nlohmann::detail::wide_string_input_adapter< WideStringType >

class	nlohmann::detail::input_adapter

class	nlohmann::detail::lexer< BasicJsonType >
	lexical analysis More...

struct	nlohmann::detail::is_sax< SAX, BasicJsonType >

struct	nlohmann::detail::is_sax_static_asserts< SAX, BasicJsonType >

struct	nlohmann::json_sax< BasicJsonType >
	SAX interface. More...

class	nlohmann::detail::json_sax_dom_parser< BasicJsonType >
	SAX implementation to create a JSON value from SAX events. More...

class	nlohmann::detail::json_sax_dom_callback_parser< BasicJsonType >

class	nlohmann::detail::json_sax_acceptor< BasicJsonType >

class	nlohmann::detail::parser< BasicJsonType >
	syntax analysis More...

class	nlohmann::detail::primitive_iterator_t

struct	nlohmann::detail::internal_iterator< BasicJsonType >
	an iterator value More...

class	nlohmann::detail::iteration_proxy< IteratorType >
	proxy class for the items() function More...

class	nlohmann::detail::iter_impl< BasicJsonType >
	a template for a bidirectional iterator for the basic_json class More...

class	nlohmann::detail::json_reverse_iterator< Base >
	a template for a reverse iterator class More...

struct	nlohmann::detail::output_adapter_protocol< CharType >
	abstract output adapter interface More...

class	nlohmann::detail::output_vector_adapter< CharType >
	output adapter for byte vectors More...

class	nlohmann::detail::output_stream_adapter< CharType >
	output adapter for output streams More...

class	nlohmann::detail::output_string_adapter< CharType, StringType >
	output adapter for basic_string More...

class	nlohmann::detail::output_adapter< CharType, StringType >

class	nlohmann::detail::binary_reader< BasicJsonType, SAX >
	deserialization of CBOR, MessagePack, and UBJSON values More...

class	nlohmann::detail::binary_writer< BasicJsonType, CharType >
	serialization to CBOR and MessagePack values More...

struct	nlohmann::detail::dtoa_impl::diyfp

struct	nlohmann::detail::dtoa_impl::boundaries

struct	nlohmann::detail::dtoa_impl::cached_power

class	nlohmann::detail::serializer< BasicJsonType >

class	nlohmann::detail::json_ref< BasicJsonType >

class	nlohmann::json_pointer< BasicJsonType >
	JSON Pointer. More...

struct	nlohmann::adl_serializer< typename, typename >
	default JSONSerializer template argument More...

class	nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >
	a class to store JSON values More...

union	nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::json_value
	a JSON value More...

struct	std::hash< nlohmann::json >
	hash value for JSON objects More...

struct	std::less< ::nlohmann::detail::value_t >

Namespaces
	nlohmann
	namespace for Niels Lohmann

	nlohmann::detail
	detail namespace with internal helper functions

	nlohmann::anonymous_namespace{json.hpp}
	namespace to hold default `to_json` function

	nlohmann::detail::dtoa_impl
	implements the Grisu2 algorithm for binary to decimal floating-point conversion.

	std

Macros
#define	NLOHMANN_JSON_VERSION_MAJOR 3

#define	NLOHMANN_JSON_VERSION_MINOR 4

#define	NLOHMANN_JSON_VERSION_PATCH 0

#define	NLOHMANN_JSON_FWD_HPP

#define	JSON_DEPRECATED

#define	JSON_THROW(exception) std::abort()

#define	JSON_TRY if(true)

#define	JSON_CATCH(exception) if(false)

#define	JSON_INTERNAL_CATCH(exception) if(false)

#define	JSON_LIKELY(x) x

#define	JSON_UNLIKELY(x) x

#define	NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)
	macro to briefly define a mapping between an enum and JSON More...

#define	NLOHMANN_BASIC_JSON_TPL_DECLARATION

#define	NLOHMANN_BASIC_JSON_TPL

Typedefs
using	nlohmann::json = basic_json<>
	default JSON class More...

template<bool B, typename T = void>
using	nlohmann::detail::enable_if_t = typename std::enable_if< B, T >::type

template<typename T >
using	nlohmann::detail::uncvref_t = typename std::remove_cv< typename std::remove_reference< T >::type >::type

template<typename... Ts>
using	nlohmann::detail::index_sequence_for = make_index_sequence< sizeof...(Ts)>

template<typename... Ts>
using	nlohmann::detail::void_t = typename make_void< Ts... >::type

template<template< class... > class Op, class... Args>
using	nlohmann::detail::is_detected = typename detector< nonesuch, void, Op, Args... >::value_t

template<template< class... > class Op, class... Args>
using	nlohmann::detail::detected_t = typename detector< nonesuch, void, Op, Args... >::type

template<class Default , template< class... > class Op, class... Args>
using	nlohmann::detail::detected_or = detector< Default, void, Op, Args... >

template<class Default , template< class... > class Op, class... Args>
using	nlohmann::detail::detected_or_t = typename detected_or< Default, Op, Args... >::type

template<class Expected , template< class... > class Op, class... Args>
using	nlohmann::detail::is_detected_exact = std::is_same< Expected, detected_t< Op, Args... >>

template<class To , template< class... > class Op, class... Args>
using	nlohmann::detail::is_detected_convertible = std::is_convertible< detected_t< Op, Args... >, To >

template<typename T >
using	nlohmann::detail::mapped_type_t = typename T::mapped_type

template<typename T >
using	nlohmann::detail::key_type_t = typename T::key_type

template<typename T >
using	nlohmann::detail::value_type_t = typename T::value_type

template<typename T >
using	nlohmann::detail::difference_type_t = typename T::difference_type

template<typename T >
using	nlohmann::detail::pointer_t = typename T::pointer

template<typename T >
using	nlohmann::detail::reference_t = typename T::reference

template<typename T >
using	nlohmann::detail::iterator_category_t = typename T::iterator_category

template<typename T >
using	nlohmann::detail::iterator_t = typename T::iterator

template<typename T , typename... Args>
using	nlohmann::detail::to_json_function = decltype(T::to_json(std::declval< Args >()...))

template<typename T , typename... Args>
using	nlohmann::detail::from_json_function = decltype(T::from_json(std::declval< Args >()...))

template<typename T , typename U >
using	nlohmann::detail::get_template_function = decltype(std::declval< T >().template get< U >())

using	nlohmann::detail::input_adapter_t = std::shared_ptr< input_adapter_protocol >
	a type to simplify interfaces More...

template<typename T >
using	nlohmann::detail::null_function_t = decltype(std::declval< T & >().null())

template<typename T >
using	nlohmann::detail::boolean_function_t = decltype(std::declval< T & >().boolean(std::declval< bool >()))

template<typename T , typename Integer >
using	nlohmann::detail::number_integer_function_t = decltype(std::declval< T & >().number_integer(std::declval< Integer >()))

template<typename T , typename Unsigned >
using	nlohmann::detail::number_unsigned_function_t = decltype(std::declval< T & >().number_unsigned(std::declval< Unsigned >()))

template<typename T , typename Float , typename String >
using	nlohmann::detail::number_float_function_t = decltype(std::declval< T & >().number_float(std::declval< Float >(), std::declval< const String & >()))

template<typename T , typename String >
using	nlohmann::detail::string_function_t = decltype(std::declval< T & >().string(std::declval< String & >()))

template<typename T >
using	nlohmann::detail::start_object_function_t = decltype(std::declval< T & >().start_object(std::declval< std::size_t >()))

template<typename T , typename String >
using	nlohmann::detail::key_function_t = decltype(std::declval< T & >().key(std::declval< String & >()))

template<typename T >
using	nlohmann::detail::end_object_function_t = decltype(std::declval< T & >().end_object())

template<typename T >
using	nlohmann::detail::start_array_function_t = decltype(std::declval< T & >().start_array(std::declval< std::size_t >()))

template<typename T >
using	nlohmann::detail::end_array_function_t = decltype(std::declval< T & >().end_array())

template<typename T , typename Exception >
using	nlohmann::detail::parse_error_function_t = decltype(std::declval< T & >().parse_error(std::declval< std::size_t >(), std::declval< const std::string & >(), std::declval< const Exception & >()))

template<typename CharType >
using	nlohmann::detail::output_adapter_t = std::shared_ptr< output_adapter_protocol< CharType >>
	a type to simplify interfaces More...

Enumerations
enum	nlohmann::detail::value_t : std::uint8_t { nlohmann::detail::value_t::null, nlohmann::detail::value_t::object, nlohmann::detail::value_t::array, nlohmann::detail::value_t::string, nlohmann::detail::value_t::boolean, nlohmann::detail::value_t::number_integer, nlohmann::detail::value_t::number_unsigned, nlohmann::detail::value_t::number_float, nlohmann::detail::value_t::discarded }
	the JSON type enumeration More...

enum	nlohmann::detail::input_format_t { nlohmann::detail::input_format_t::json, nlohmann::detail::input_format_t::cbor, nlohmann::detail::input_format_t::msgpack, nlohmann::detail::input_format_t::ubjson, nlohmann::detail::input_format_t::bson }
	the supported input formats More...

enum	nlohmann::detail::error_handler_t { nlohmann::detail::error_handler_t::strict, nlohmann::detail::error_handler_t::replace, nlohmann::detail::error_handler_t::ignore }
	how to treat decoding errors More...

Functions
bool	nlohmann::detail::operator< (const value_t lhs, const value_t rhs) noexcept
	comparison operator for JSON types More...

template<typename BasicJsonType >
void	nlohmann::detail::from_json (const BasicJsonType &j, typename std::nullptr_t &n)

template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value andnot std::is_same< ArithmeticType, typename BasicJsonType::boolean_t >::value, int > = 0>
void	nlohmann::detail::get_arithmetic_value (const BasicJsonType &j, ArithmeticType &val)

template<typename BasicJsonType >
void	nlohmann::detail::from_json (const BasicJsonType &j, typename BasicJsonType::boolean_t &b)

template<typename BasicJsonType >
void	nlohmann::detail::from_json (const BasicJsonType &j, typename BasicJsonType::string_t &s)

template<typename BasicJsonType , typename ConstructibleStringType , enable_if_t< is_constructible_string_type< BasicJsonType, ConstructibleStringType >::value andnot std::is_same< typename BasicJsonType::string_t, ConstructibleStringType >::value, int > = 0>
void	nlohmann::detail::from_json (const BasicJsonType &j, ConstructibleStringType &s)

template<typename BasicJsonType >
void	nlohmann::detail::from_json (const BasicJsonType &j, typename BasicJsonType::number_float_t &val)

template<typename BasicJsonType >
void	nlohmann::detail::from_json (const BasicJsonType &j, typename BasicJsonType::number_unsigned_t &val)

template<typename BasicJsonType >
void	nlohmann::detail::from_json (const BasicJsonType &j, typename BasicJsonType::number_integer_t &val)

template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>
void	nlohmann::detail::from_json (const BasicJsonType &j, EnumType &e)

template<typename BasicJsonType , typename T , typename Allocator , enable_if_t< std::is_convertible< BasicJsonType, T >::value, int > = 0>
void	nlohmann::detail::from_json (const BasicJsonType &j, std::forward_list< T, Allocator > &l)

template<typename BasicJsonType , typename T , enable_if_t< std::is_convertible< BasicJsonType, T >::value, int > = 0>
void	nlohmann::detail::from_json (const BasicJsonType &j, std::valarray< T > &l)

template<typename BasicJsonType >
void	nlohmann::detail::from_json_array_impl (const BasicJsonType &j, typename BasicJsonType::array_t &arr, priority_tag< 3 >)

template<typename BasicJsonType , typename T , std::size_t N>
auto	nlohmann::detail::from_json_array_impl (const BasicJsonType &j, std::array< T, N > &arr, priority_tag< 2 >) -> decltype(j.template get< T >(), void())

template<typename BasicJsonType , typename ConstructibleArrayType >
auto	nlohmann::detail::from_json_array_impl (const BasicJsonType &j, ConstructibleArrayType &arr, priority_tag< 1 >) -> decltype(arr.reserve(std::declval< typename ConstructibleArrayType::size_type >()), j.template get< typename ConstructibleArrayType::value_type >(), void())

template<typename BasicJsonType , typename ConstructibleArrayType >
void	nlohmann::detail::from_json_array_impl (const BasicJsonType &j, ConstructibleArrayType &arr, priority_tag< 0 >)

template<typename BasicJsonType , typename ConstructibleArrayType , enable_if_t< is_constructible_array_type< BasicJsonType, ConstructibleArrayType >::value andnot is_constructible_object_type< BasicJsonType, ConstructibleArrayType >::value andnot is_constructible_string_type< BasicJsonType, ConstructibleArrayType >::value andnot is_basic_json< ConstructibleArrayType >::value, int > = 0>
auto	nlohmann::detail::from_json (const BasicJsonType &j, ConstructibleArrayType &arr) -> decltype(from_json_array_impl(j, arr, priority_tag< 3 >

j template	nlohmann::detail::get< typename ConstructibleArrayType::value_type > ()

j template	nlohmann::detail::void ())

template<typename BasicJsonType , typename ConstructibleObjectType , enable_if_t< is_constructible_object_type< BasicJsonType, ConstructibleObjectType >::value, int > = 0>
void	nlohmann::detail::from_json (const BasicJsonType &j, ConstructibleObjectType &obj)

template<typename BasicJsonType , typename ArithmeticType , enable_if_t< std::is_arithmetic< ArithmeticType >::value andnot std::is_same< ArithmeticType, typename BasicJsonType::number_unsigned_t >::value andnot std::is_same< ArithmeticType, typename BasicJsonType::number_integer_t >::value andnot std::is_same< ArithmeticType, typename BasicJsonType::number_float_t >::value andnot std::is_same< ArithmeticType, typename BasicJsonType::boolean_t >::value, int > = 0>
void	nlohmann::detail::from_json (const BasicJsonType &j, ArithmeticType &val)

template<typename BasicJsonType , typename A1 , typename A2 >
void	nlohmann::detail::from_json (const BasicJsonType &j, std::pair< A1, A2 > &p)

template<typename BasicJsonType , typename Tuple , std::size_t... Idx>
void	nlohmann::detail::from_json_tuple_impl (const BasicJsonType &j, Tuple &t, index_sequence< Idx... >)

template<typename BasicJsonType , typename... Args>
void	nlohmann::detail::from_json (const BasicJsonType &j, std::tuple< Args... > &t)

template<typename BasicJsonType , typename Key , typename Value , typename Compare , typename Allocator , typename = enable_if_t<not std::is_constructible< typename BasicJsonType::string_t, Key>::value>>
void	nlohmann::detail::from_json (const BasicJsonType &j, std::map< Key, Value, Compare, Allocator > &m)

template<typename BasicJsonType , typename Key , typename Value , typename Hash , typename KeyEqual , typename Allocator , typename = enable_if_t<not std::is_constructible< typename BasicJsonType::string_t, Key>::value>>
void	nlohmann::detail::from_json (const BasicJsonType &j, std::unordered_map< Key, Value, Hash, KeyEqual, Allocator > &m)

template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, typename BasicJsonType::boolean_t >::value, int > = 0>
void	nlohmann::detail::to_json (BasicJsonType &j, T b) noexcept

template<typename BasicJsonType , typename CompatibleString , enable_if_t< std::is_constructible< typename BasicJsonType::string_t, CompatibleString >::value, int > = 0>
void	nlohmann::detail::to_json (BasicJsonType &j, const CompatibleString &s)

template<typename BasicJsonType >
void	nlohmann::detail::to_json (BasicJsonType &j, typename BasicJsonType::string_t &&s)

template<typename BasicJsonType , typename FloatType , enable_if_t< std::is_floating_point< FloatType >::value, int > = 0>
void	nlohmann::detail::to_json (BasicJsonType &j, FloatType val) noexcept

template<typename BasicJsonType , typename CompatibleNumberUnsignedType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType >::value, int > = 0>
void	nlohmann::detail::to_json (BasicJsonType &j, CompatibleNumberUnsignedType val) noexcept

template<typename BasicJsonType , typename CompatibleNumberIntegerType , enable_if_t< is_compatible_integer_type< typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType >::value, int > = 0>
void	nlohmann::detail::to_json (BasicJsonType &j, CompatibleNumberIntegerType val) noexcept

template<typename BasicJsonType , typename EnumType , enable_if_t< std::is_enum< EnumType >::value, int > = 0>
void	nlohmann::detail::to_json (BasicJsonType &j, EnumType e) noexcept

template<typename BasicJsonType >
void	nlohmann::detail::to_json (BasicJsonType &j, const std::vector< bool > &e)

template<typename BasicJsonType , typename CompatibleArrayType , enable_if_t< is_compatible_array_type< BasicJsonType, CompatibleArrayType >::value andnot is_compatible_object_type< BasicJsonType, CompatibleArrayType >::value andnot is_compatible_string_type< BasicJsonType, CompatibleArrayType >::value andnot is_basic_json< CompatibleArrayType >::value, int > = 0>
void	nlohmann::detail::to_json (BasicJsonType &j, const CompatibleArrayType &arr)

template<typename BasicJsonType , typename T , enable_if_t< std::is_convertible< T, BasicJsonType >::value, int > = 0>
void	nlohmann::detail::to_json (BasicJsonType &j, const std::valarray< T > &arr)

template<typename BasicJsonType >
void	nlohmann::detail::to_json (BasicJsonType &j, typename BasicJsonType::array_t &&arr)

template<typename BasicJsonType , typename CompatibleObjectType , enable_if_t< is_compatible_object_type< BasicJsonType, CompatibleObjectType >::value and not is_basic_json< CompatibleObjectType >::value, int > = 0>
void	nlohmann::detail::to_json (BasicJsonType &j, const CompatibleObjectType &obj)

template<typename BasicJsonType >
void	nlohmann::detail::to_json (BasicJsonType &j, typename BasicJsonType::object_t &&obj)

template<typename BasicJsonType , typename T , std::size_t N, enable_if_t< not std::is_constructible< typename BasicJsonType::string_t, const T(&)[N]>::value, int > = 0>
void	nlohmann::detail::to_json (BasicJsonType &j, const T(&arr)[N])

template<typename BasicJsonType , typename... Args>
void	nlohmann::detail::to_json (BasicJsonType &j, const std::pair< Args... > &p)

template<typename BasicJsonType , typename T , enable_if_t< std::is_same< T, typename iteration_proxy< typename BasicJsonType::iterator >::iteration_proxy_internal >::value, int > = 0>
void	nlohmann::detail::to_json (BasicJsonType &j, const T &b)

template<typename BasicJsonType , typename Tuple , std::size_t... Idx>
void	nlohmann::detail::to_json_tuple_impl (BasicJsonType &j, const Tuple &t, index_sequence< Idx... >)

template<typename BasicJsonType , typename... Args>
void	nlohmann::detail::to_json (BasicJsonType &j, const std::tuple< Args... > &t)

template<typename Target , typename Source >
Target	nlohmann::detail::dtoa_impl::reinterpret_bits (const Source source)

template<typename FloatType >
boundaries	nlohmann::detail::dtoa_impl::compute_boundaries (FloatType value)

cached_power	nlohmann::detail::dtoa_impl::get_cached_power_for_binary_exponent (int e)

int	nlohmann::detail::dtoa_impl::find_largest_pow10 (const uint32_t n, uint32_t &pow10)

void	nlohmann::detail::dtoa_impl::grisu2_round (char *buf, int len, uint64_t dist, uint64_t delta, uint64_t rest, uint64_t ten_k)

void	nlohmann::detail::dtoa_impl::grisu2_digit_gen (char *buffer, int &length, int &decimal_exponent, diyfp M_minus, diyfp w, diyfp M_plus)

void	nlohmann::detail::dtoa_impl::grisu2 (char *buf, int &len, int &decimal_exponent, diyfp m_minus, diyfp v, diyfp m_plus)

template<typename FloatType >
void	nlohmann::detail::dtoa_impl::grisu2 (char *buf, int &len, int &decimal_exponent, FloatType value)

char *	nlohmann::detail::dtoa_impl::append_exponent (char *buf, int e)
	appends a decimal representation of e to buf More...

char *	nlohmann::detail::dtoa_impl::format_buffer (char *buf, int len, int decimal_exponent, int min_exp, int max_exp)
	prettify v = buf * 10^decimal_exponent More...

template<typename FloatType >
char *	nlohmann::detail::to_chars (char first, const char last, FloatType value)
	generates a decimal representation of the floating-point number value in [first, last). More...

template<>
void	std::swap< nlohmann::json > (nlohmann::json &j1, nlohmann::json &j2) noexcept(is_nothrow_move_constructible< nlohmann::json >::value andis_nothrow_move_assignable< nlohmann::json >::value)
	exchanges the values of two JSON objects More...

nlohmann::json	operator""_json (const char *s, std::size_t n)
	user-defined string literal for JSON values More...

nlohmann::json::json_pointer	operator""_json_pointer (const char *s, std::size_t n)
	user-defined string literal for JSON pointer More...

Variables
constexpr const auto &	nlohmann::anonymous_namespace{json.hpp}::from_json = detail::static_const<detail::from_json_fn>::value

constexpr const auto &	nlohmann::anonymous_namespace{json.hpp}::to_json = detail::static_const<detail::to_json_fn>::value

constexpr int	nlohmann::detail::dtoa_impl::kAlpha = -60

constexpr int	nlohmann::detail::dtoa_impl::kGamma = -32

Macro Definition Documentation

#define JSON_CATCH ( exception ) if(false)

Definition at line 164 of file json.hpp.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::at(), nlohmann::json_pointer< BasicJsonType >::get_and_create(), nlohmann::json_pointer< BasicJsonType >::get_checked(), and nlohmann::json_pointer< BasicJsonType >::get_unchecked().

#define JSON_DEPRECATED

Definition at line 152 of file json.hpp.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::crend(), nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::iterator_wrapper(), and nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::sax_parse().

#define JSON_INTERNAL_CATCH ( exception ) if(false)

Definition at line 165 of file json.hpp.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::patch(), and nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::value().

#define JSON_LIKELY ( x ) x

Definition at line 193 of file json.hpp.

#define JSON_THROW ( exception ) std::abort()

Definition at line 162 of file json.hpp.

#define JSON_TRY if(true)

Definition at line 163 of file json.hpp.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::at(), nlohmann::json_pointer< BasicJsonType >::get_and_create(), nlohmann::json_pointer< BasicJsonType >::get_checked(), nlohmann::json_pointer< BasicJsonType >::get_unchecked(), nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::patch(), and nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::value().

#define JSON_UNLIKELY ( x ) x

Definition at line 194 of file json.hpp.

#define NLOHMANN_BASIC_JSON_TPL

Value:

basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
    AllocatorType, JSONSerializer>

Definition at line 247 of file json.hpp.

#define NLOHMANN_BASIC_JSON_TPL_DECLARATION

Value:

template<template<typename, typename, typename...> class ObjectType,   \
             template<typename, typename...> class ArrayType,              \
             class StringType, class BooleanType, class NumberIntegerType, \
             class NumberUnsignedType, class NumberFloatType,              \
             template<typename> class AllocatorType,                       \
             template<typename, typename = void> class JSONSerializer>

Definition at line 239 of file json.hpp.

Referenced by nlohmann::adl_serializer< typename, typename >::to_json().

#define NLOHMANN_JSON_FWD_HPP

Definition at line 51 of file json.hpp.

#define NLOHMANN_JSON_SERIALIZE_ENUM	(	ENUM_TYPE,
		...
	)

Value:

template<typename BasicJsonType>                                                           \
    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                  \
    {                                                                                          \
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");         \
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                    \
        auto it = std::find_if(std::begin(m), std::end(m),                                     \
                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
        {                                                                                      \
            return ej_pair.first == e;                                                         \
        });                                                                                    \
        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                \
    }                                                                                          \
    template<typename BasicJsonType>                                                           \
    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                \
    {                                                                                          \
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");         \
        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                    \
        auto it = std::find_if(std::begin(m), std::end(m),                                     \
                               [j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
        {                                                                                      \
            return ej_pair.second == j;                                                        \
        });                                                                                    \
        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                 \
    }

macro to briefly define a mapping between an enum and JSON

Since: version 3.4.0

Definition at line 210 of file json.hpp.

#define NLOHMANN_JSON_VERSION_MAJOR 3

Definition at line 33 of file json.hpp.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::meta().

#define NLOHMANN_JSON_VERSION_MINOR 4

Definition at line 34 of file json.hpp.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::meta().

#define NLOHMANN_JSON_VERSION_PATCH 0

Definition at line 35 of file json.hpp.

Referenced by nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::meta().

Function Documentation

nlohmann::json operator""_json	(	const char *	s,
		std::size_t	n
	)

inline

user-defined string literal for JSON values

This operator implements a user-defined string literal for JSON objects. It can be used by adding "_json" to a string literal and returns a JSON object if no parse error occurred.

Parameters

[in]	s	a string representation of a JSON object
[in]	n	the length of string s

Returns: a JSON object

Since: version 1.0.0

Definition at line 20226 of file json.hpp.

References nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::parse().

 {
     return nlohmann::json::parse(s, s + n);
 }

nlohmann::json::json_pointer operator""_json_pointer	(	const char *	s,
		std::size_t	n
	)

inline

user-defined string literal for JSON pointer

This operator implements a user-defined string literal for JSON Pointers. It can be used by adding "_json_pointer" to a string literal and returns a JSON pointer object if no parse error occurred.

Parameters

[in]	s	a string representation of a JSON Pointer
[in]	n	the length of string s

Returns: a JSON pointer object

Since: version 2.0.0

Definition at line 20244 of file json.hpp.

References nlohmann::detail::string.

 {
     return nlohmann::json::json_pointer(std::string(s, n));
 }

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

Function Documentation